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.3.
   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.3'
 271 PACKAGE_STRING='GNU Fortran Runtime Library 0.3'
 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 build_libsubdir build_subdir host_subdir target_subdir 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 DEPDIR am__include am__quote AMDEP_TRUE AMDEP_FALSE AMDEPBACKSLASH CCDEPMODE am__fastdepCC_TRUE am__fastdepCC_FALSE 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.3 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.3:";;
 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   --disable-dependency-tracking  speeds up one-time build
 859   --enable-dependency-tracking   do not reject slow dependency extractors
 860   --enable-shared=PKGS  build shared libraries default=yes
 861   --enable-static=PKGS  build static libraries default=yes
 862   --enable-fast-install=PKGS  optimize for fast installation default=yes
 863   --disable-libtool-lock  avoid locking (might break parallel builds)
 864   --disable-largefile     omit support for large files
 865
 866 Optional Packages:
 867   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 868   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 869   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 870   --with-gnu-ld           assume the C compiler uses GNU ld default=no
 871   --with-pic              try to use only PIC/non-PIC objects default=use both
 872
 873 Some influential environment variables:
 874   CC          C compiler command
 875   CFLAGS      C compiler flags
 876   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 877               nonstandard directory <lib dir>
 878   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 879               headers in a nonstandard directory <include dir>
 880   FC          Fortran compiler command
 881   FCFLAGS     Fortran compiler flags
 882   CPP         C preprocessor
 883
 884 Use these variables to override the choices made by `configure' or to help
 885 it to find libraries and programs with nonstandard names/locations.
 886
 887 _ACEOF
 888 fi
 889
 890 if test "$ac_init_help" = "recursive"; then
 891   # If there are subdirs, report their specific --help.
 892   ac_popdir=`pwd`
 893   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
 894     test -d $ac_dir || continue
 895     ac_builddir=.
 896
 897 if test "$ac_dir" != .; then
 898   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
 899   # A "../" for each directory in $ac_dir_suffix.
 900   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
 901 else
 902   ac_dir_suffix= ac_top_builddir=
 903 fi
 904
 905 case $srcdir in
 906   .)  # No --srcdir option.  We are building in place.
 907     ac_srcdir=.
 908     if test -z "$ac_top_builddir"; then
 909        ac_top_srcdir=.
 910     else
 911        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
 912     fi ;;
 913   [\\/]* | ?:[\\/]* )  # Absolute path.
 914     ac_srcdir=$srcdir$ac_dir_suffix;
 915     ac_top_srcdir=$srcdir ;;
 916   *) # Relative path.
 917     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
 918     ac_top_srcdir=$ac_top_builddir$srcdir ;;
 919 esac
 920
 921 # Do not use `cd foo && pwd` to compute absolute paths, because
 922 # the directories may not exist.
 923 case `pwd` in
 924 .) ac_abs_builddir="$ac_dir";;
 925 *)
 926   case "$ac_dir" in
 927   .) ac_abs_builddir=`pwd`;;
 928   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
 929   *) ac_abs_builddir=`pwd`/"$ac_dir";;
 930   esac;;
 931 esac
 932 case $ac_abs_builddir in
 933 .) ac_abs_top_builddir=${ac_top_builddir}.;;
 934 *)
 935   case ${ac_top_builddir}. in
 936   .) ac_abs_top_builddir=$ac_abs_builddir;;
 937   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
 938   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
 939   esac;;
 940 esac
 941 case $ac_abs_builddir in
 942 .) ac_abs_srcdir=$ac_srcdir;;
 943 *)
 944   case $ac_srcdir in
 945   .) ac_abs_srcdir=$ac_abs_builddir;;
 946   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
 947   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
 948   esac;;
 949 esac
 950 case $ac_abs_builddir in
 951 .) ac_abs_top_srcdir=$ac_top_srcdir;;
 952 *)
 953   case $ac_top_srcdir in
 954   .) ac_abs_top_srcdir=$ac_abs_builddir;;
 955   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
 956   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
 957   esac;;
 958 esac
 959
 960     cd $ac_dir
 961     # Check for guested configure; otherwise get Cygnus style configure.
 962     if test -f $ac_srcdir/configure.gnu; then
 963       echo
 964       $SHELL $ac_srcdir/configure.gnu  --help=recursive
 965     elif test -f $ac_srcdir/configure; then
 966       echo
 967       $SHELL $ac_srcdir/configure  --help=recursive
 968     elif test -f $ac_srcdir/configure.ac ||
 969            test -f $ac_srcdir/configure.in; then
 970       echo
 971       $ac_configure --help
 972     else
 973       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
 974     fi
 975     cd $ac_popdir
 976   done
 977 fi
 978
 979 test -n "$ac_init_help" && exit 0
 980 if $ac_init_version; then
 981   cat <<\_ACEOF
 982 GNU Fortran Runtime Library configure 0.3
 983 generated by GNU Autoconf 2.59
 984
 985 Copyright (C) 2003 Free Software Foundation, Inc.
 986 This configure script is free software; the Free Software Foundation
 987 gives unlimited permission to copy, distribute and modify it.
 988 _ACEOF
 989   exit 0
 990 fi
 991 exec 5>config.log
 992 cat >&5 <<_ACEOF
 993 This file contains any messages produced by compilers while
 994 running configure, to aid debugging if configure makes a mistake.
 995
 996 It was created by GNU Fortran Runtime Library $as_me 0.3, which was
 997 generated by GNU Autoconf 2.59.  Invocation command line was
 998
 999   $ $0 $@
1000
1001 _ACEOF
1002 {
1003 cat <<_ASUNAME
1004 ## --------- ##
1005 ## Platform. ##
1006 ## --------- ##
1007
1008 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1009 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1010 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1011 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1012 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1013
1014 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1015 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1016
1017 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1018 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1019 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1020 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1021 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1022 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1023 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1024
1025 _ASUNAME
1026
1027 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1028 for as_dir in $PATH
1029 do
1030   IFS=$as_save_IFS
1031   test -z "$as_dir" && as_dir=.
1032   echo "PATH: $as_dir"
1033 done
1034
1035 } >&5
1036
1037 cat >&5 <<_ACEOF
1038
1039
1040 ## ----------- ##
1041 ## Core tests. ##
1042 ## ----------- ##
1043
1044 _ACEOF
1045
1046
1047 # Keep a trace of the command line.
1048 # Strip out --no-create and --no-recursion so they do not pile up.
1049 # Strip out --silent because we don't want to record it for future runs.
1050 # Also quote any args containing shell meta-characters.
1051 # Make two passes to allow for proper duplicate-argument suppression.
1052 ac_configure_args=
1053 ac_configure_args0=
1054 ac_configure_args1=
1055 ac_sep=
1056 ac_must_keep_next=false
1057 for ac_pass in 1 2
1058 do
1059   for ac_arg
1060   do
1061     case $ac_arg in
1062     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1063     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1064     | -silent | --silent | --silen | --sile | --sil)
1065       continue ;;
1066     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1067       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1068     esac
1069     case $ac_pass in
1070     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1071     2)
1072       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1073       if test $ac_must_keep_next = true; then
1074         ac_must_keep_next=false # Got value, back to normal.
1075       else
1076         case $ac_arg in
1077           *=* | --config-cache | -C | -disable-* | --disable-* \
1078           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1079           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1080           | -with-* | --with-* | -without-* | --without-* | --x)
1081             case "$ac_configure_args0 " in
1082               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1083             esac
1084             ;;
1085           -* ) ac_must_keep_next=true ;;
1086         esac
1087       fi
1088       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1089       # Get rid of the leading space.
1090       ac_sep=" "
1091       ;;
1092     esac
1093   done
1094 done
1095 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1096 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1097
1098 # When interrupted or exit'd, cleanup temporary files, and complete
1099 # config.log.  We remove comments because anyway the quotes in there
1100 # would cause problems or look ugly.
1101 # WARNING: Be sure not to use single quotes in there, as some shells,
1102 # such as our DU 5.0 friend, will then `close' the trap.
1103 trap 'exit_status=$?
1104   # Save into config.log some information that might help in debugging.
1105   {
1106     echo
1107
1108     cat <<\_ASBOX
1109 ## ---------------- ##
1110 ## Cache variables. ##
1111 ## ---------------- ##
1112 _ASBOX
1113     echo
1114     # The following way of writing the cache mishandles newlines in values,
1115 {
1116   (set) 2>&1 |
1117     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1118     *ac_space=\ *)
1119       sed -n \
1120         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1121           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1122       ;;
1123     *)
1124       sed -n \
1125         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1126       ;;
1127     esac;
1128 }
1129     echo
1130
1131     cat <<\_ASBOX
1132 ## ----------------- ##
1133 ## Output variables. ##
1134 ## ----------------- ##
1135 _ASBOX
1136     echo
1137     for ac_var in $ac_subst_vars
1138     do
1139       eval ac_val=$`echo $ac_var`
1140       echo "$ac_var='"'"'$ac_val'"'"'"
1141     done | sort
1142     echo
1143
1144     if test -n "$ac_subst_files"; then
1145       cat <<\_ASBOX
1146 ## ------------- ##
1147 ## Output files. ##
1148 ## ------------- ##
1149 _ASBOX
1150       echo
1151       for ac_var in $ac_subst_files
1152       do
1153         eval ac_val=$`echo $ac_var`
1154         echo "$ac_var='"'"'$ac_val'"'"'"
1155       done | sort
1156       echo
1157     fi
1158
1159     if test -s confdefs.h; then
1160       cat <<\_ASBOX
1161 ## ----------- ##
1162 ## confdefs.h. ##
1163 ## ----------- ##
1164 _ASBOX
1165       echo
1166       sed "/^$/d" confdefs.h | sort
1167       echo
1168     fi
1169     test "$ac_signal" != 0 &&
1170       echo "$as_me: caught signal $ac_signal"
1171     echo "$as_me: exit $exit_status"
1172   } >&5
1173   rm -f core *.core &&
1174   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1175     exit $exit_status
1176      ' 0
1177 for ac_signal in 1 2 13 15; do
1178   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1179 done
1180 ac_signal=0
1181
1182 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1183 rm -rf conftest* confdefs.h
1184 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1185 echo >confdefs.h
1186
1187 # Predefined preprocessor variables.
1188
1189 cat >>confdefs.h <<_ACEOF
1190 #define PACKAGE_NAME "$PACKAGE_NAME"
1191 _ACEOF
1192
1193
1194 cat >>confdefs.h <<_ACEOF
1195 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1196 _ACEOF
1197
1198
1199 cat >>confdefs.h <<_ACEOF
1200 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1201 _ACEOF
1202
1203
1204 cat >>confdefs.h <<_ACEOF
1205 #define PACKAGE_STRING "$PACKAGE_STRING"
1206 _ACEOF
1207
1208
1209 cat >>confdefs.h <<_ACEOF
1210 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1211 _ACEOF
1212
1213
1214 # Let the site file select an alternate cache file if it wants to.
1215 # Prefer explicitly selected file to automatically selected ones.
1216 if test -z "$CONFIG_SITE"; then
1217   if test "x$prefix" != xNONE; then
1218     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1219   else
1220     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1221   fi
1222 fi
1223 for ac_site_file in $CONFIG_SITE; do
1224   if test -r "$ac_site_file"; then
1225     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1226 echo "$as_me: loading site script $ac_site_file" >&6;}
1227     sed 's/^/| /' "$ac_site_file" >&5
1228     . "$ac_site_file"
1229   fi
1230 done
1231
1232 if test -r "$cache_file"; then
1233   # Some versions of bash will fail to source /dev/null (special
1234   # files actually), so we avoid doing that.
1235   if test -f "$cache_file"; then
1236     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1237 echo "$as_me: loading cache $cache_file" >&6;}
1238     case $cache_file in
1239       [\\/]* | ?:[\\/]* ) . $cache_file;;
1240       *)                      . ./$cache_file;;
1241     esac
1242   fi
1243 else
1244   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1245 echo "$as_me: creating cache $cache_file" >&6;}
1246   >$cache_file
1247 fi
1248
1249 # Check that the precious variables saved in the cache have kept the same
1250 # value.
1251 ac_cache_corrupted=false
1252 for ac_var in `(set) 2>&1 |
1253                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1254   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1255   eval ac_new_set=\$ac_env_${ac_var}_set
1256   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1257   eval ac_new_val="\$ac_env_${ac_var}_value"
1258   case $ac_old_set,$ac_new_set in
1259     set,)
1260       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1261 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1262       ac_cache_corrupted=: ;;
1263     ,set)
1264       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1265 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1266       ac_cache_corrupted=: ;;
1267     ,);;
1268     *)
1269       if test "x$ac_old_val" != "x$ac_new_val"; then
1270         { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1271 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1272         { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1273 echo "$as_me:   former value:  $ac_old_val" >&2;}
1274         { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1275 echo "$as_me:   current value: $ac_new_val" >&2;}
1276         ac_cache_corrupted=:
1277       fi;;
1278   esac
1279   # Pass precious variables to config.status.
1280   if test "$ac_new_set" = set; then
1281     case $ac_new_val in
1282     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1283       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1284     *) ac_arg=$ac_var=$ac_new_val ;;
1285     esac
1286     case " $ac_configure_args " in
1287       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1288       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1289     esac
1290   fi
1291 done
1292 if $ac_cache_corrupted; then
1293   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1294 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1295   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1296 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1297    { (exit 1); exit 1; }; }
1298 fi
1299
1300 ac_ext=c
1301 ac_cpp='$CPP $CPPFLAGS'
1302 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1303 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1304 ac_compiler_gnu=$ac_cv_c_compiler_gnu
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
1330
1331
1332           ac_config_headers="$ac_config_headers config.h"
1333
1334 ac_aux_dir=
1335 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1336   if test -f $ac_dir/install-sh; then
1337     ac_aux_dir=$ac_dir
1338     ac_install_sh="$ac_aux_dir/install-sh -c"
1339     break
1340   elif test -f $ac_dir/install.sh; then
1341     ac_aux_dir=$ac_dir
1342     ac_install_sh="$ac_aux_dir/install.sh -c"
1343     break
1344   elif test -f $ac_dir/shtool; then
1345     ac_aux_dir=$ac_dir
1346     ac_install_sh="$ac_aux_dir/shtool install -c"
1347     break
1348   fi
1349 done
1350 if test -z "$ac_aux_dir"; then
1351   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1352 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1353    { (exit 1); exit 1; }; }
1354 fi
1355 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1356 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1357 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1358
1359 # Make sure we can run config.sub.
1360 $ac_config_sub sun4 >/dev/null 2>&1 ||
1361   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1362 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1363    { (exit 1); exit 1; }; }
1364
1365 echo "$as_me:$LINENO: checking build system type" >&5
1366 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1367 if test "${ac_cv_build+set}" = set; then
1368   echo $ECHO_N "(cached) $ECHO_C" >&6
1369 else
1370   ac_cv_build_alias=$build_alias
1371 test -z "$ac_cv_build_alias" &&
1372   ac_cv_build_alias=`$ac_config_guess`
1373 test -z "$ac_cv_build_alias" &&
1374   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1375 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1376    { (exit 1); exit 1; }; }
1377 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1378   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1379 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1380    { (exit 1); exit 1; }; }
1381
1382 fi
1383 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1384 echo "${ECHO_T}$ac_cv_build" >&6
1385 build=$ac_cv_build
1386 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1387 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1388 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1389
1390
1391  case ${build_alias} in
1392   "") build_noncanonical=${build} ;;
1393   *) build_noncanonical=${build_alias} ;;
1394 esac
1395
1396  case ${host_alias} in
1397   "") host_noncanonical=${build_noncanonical} ;;
1398   *) host_noncanonical=${host_alias} ;;
1399 esac
1400
1401  case ${target_alias} in
1402   "") target_noncanonical=${host_noncanonical} ;;
1403   *) target_noncanonical=${target_alias} ;;
1404 esac
1405
1406
1407 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1408 # have matching libraries, they should use host libraries: Makefile.tpl
1409 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1410 # However, they still use the build modules, because the corresponding
1411 # host modules (e.g. bison) are only built for the host when bootstrap
1412 # finishes. So:
1413 # - build_subdir is where we find build modules, and never changes.
1414 # - build_libsubdir is where we find build libraries, and can be overridden.
1415
1416 # Prefix 'build-' so this never conflicts with target_subdir.
1417 build_subdir="build-${build_noncanonical}"
1418
1419 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1420 if test "${with_build_libsubdir+set}" = set; then
1421   withval="$with_build_libsubdir"
1422   build_libsubdir="$withval"
1423 else
1424   build_libsubdir="$build_subdir"
1425 fi;
1426 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1427 if ( test $srcdir = . && test -d gcc ) \
1428    || test -d $srcdir/../host-${host_noncanonical}; then
1429   host_subdir="host-${host_noncanonical}"
1430 else
1431   host_subdir=.
1432 fi
1433 # No prefix.
1434 target_subdir=${target_noncanonical}
1435
1436
1437 # -------
1438 # Options
1439 # -------
1440
1441 echo "$as_me:$LINENO: checking for --enable-version-specific-runtime-libs" >&5
1442 echo $ECHO_N "checking for --enable-version-specific-runtime-libs... $ECHO_C" >&6
1443 # Check whether --enable-version-specific-runtime-libs or --disable-version-specific-runtime-libs was given.
1444 if test "${enable_version_specific_runtime_libs+set}" = set; then
1445   enableval="$enable_version_specific_runtime_libs"
1446   case "$enableval" in
1447  yes) version_specific_libs=yes ;;
1448  no)  version_specific_libs=no ;;
1449  *)   { { echo "$as_me:$LINENO: error: Unknown argument to enable/disable version-specific libs" >&5
1450 echo "$as_me: error: Unknown argument to enable/disable version-specific libs" >&2;}
1451    { (exit 1); exit 1; }; };;
1452  esac
1453 else
1454   version_specific_libs=no
1455 fi;
1456 echo "$as_me:$LINENO: result: $version_specific_libs" >&5
1457 echo "${ECHO_T}$version_specific_libs" >&6
1458
1459
1460 # Gets build, host, target, *_vendor, *_cpu, *_os, etc.
1461 #
1462 # You will slowly go insane if you do not grok the following fact:  when
1463 # building this library, the top-level /target/ becomes the library's /host/.
1464 #
1465 # configure then causes --target to default to --host, exactly like any
1466 # other package using autoconf.  Therefore, 'target' and 'host' will
1467 # always be the same.  This makes sense both for native and cross compilers
1468 # just think about it for a little while.  :-)
1469 #
1470 # Also, if this library is being configured as part of a cross compiler, the
1471 # top-level configure script will pass the "real" host as $with_cross_host.
1472 #
1473 # Do not delete or change the following two lines.  For why, see
1474 # http://gcc.gnu.org/ml/libstdc++/2003-07/msg00451.html
1475 echo "$as_me:$LINENO: checking host system type" >&5
1476 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1477 if test "${ac_cv_host+set}" = set; then
1478   echo $ECHO_N "(cached) $ECHO_C" >&6
1479 else
1480   ac_cv_host_alias=$host_alias
1481 test -z "$ac_cv_host_alias" &&
1482   ac_cv_host_alias=$ac_cv_build_alias
1483 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1484   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1485 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1486    { (exit 1); exit 1; }; }
1487
1488 fi
1489 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1490 echo "${ECHO_T}$ac_cv_host" >&6
1491 host=$ac_cv_host
1492 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1493 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1494 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1495
1496
1497 echo "$as_me:$LINENO: checking target system type" >&5
1498 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1499 if test "${ac_cv_target+set}" = set; then
1500   echo $ECHO_N "(cached) $ECHO_C" >&6
1501 else
1502   ac_cv_target_alias=$target_alias
1503 test "x$ac_cv_target_alias" = "x" &&
1504   ac_cv_target_alias=$ac_cv_host_alias
1505 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1506   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1507 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1508    { (exit 1); exit 1; }; }
1509
1510 fi
1511 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1512 echo "${ECHO_T}$ac_cv_target" >&6
1513 target=$ac_cv_target
1514 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1515 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1516 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1517
1518
1519 # The aliases save the names the user supplied, while $host etc.
1520 # will get canonicalized.
1521 test -n "$target_alias" &&
1522   test "$program_prefix$program_suffix$program_transform_name" = \
1523     NONENONEs,x,x, &&
1524   program_prefix=${target_alias}-
1525 target_alias=${target_alias-$host_alias}
1526
1527 # Sets up automake.  Must come after AC_CANONICAL_SYSTEM.  Each of the
1528 # following is magically included in AUTOMAKE_OPTIONS in each Makefile.am.
1529 #  1.9.6:  minimum required version
1530 #  no-define:  PACKAGE and VERSION will not be #define'd in config.h (a bunch
1531 #              of other PACKAGE_* variables will, however, and there's nothing
1532 #              we can do about that; they come from AC_INIT).
1533 #  foreign:  we don't follow the normal rules for GNU packages (no COPYING
1534 #            file in the top srcdir, etc, etc), so stop complaining.
1535 #  -Wall:  turns on all automake warnings...
1536 #  -Wno-portability:  ...except this one, since GNU make is required.
1537 am__api_version="1.9"
1538 # Find a good install program.  We prefer a C program (faster),
1539 # so one script is as good as another.  But avoid the broken or
1540 # incompatible versions:
1541 # SysV /etc/install, /usr/sbin/install
1542 # SunOS /usr/etc/install
1543 # IRIX /sbin/install
1544 # AIX /bin/install
1545 # AmigaOS /C/install, which installs bootblocks on floppy discs
1546 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1547 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1548 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1549 # OS/2's system install, which has a completely different semantic
1550 # ./install, which can be erroneously created by make from ./install.sh.
1551 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1552 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1553 if test -z "$INSTALL"; then
1554 if test "${ac_cv_path_install+set}" = set; then
1555   echo $ECHO_N "(cached) $ECHO_C" >&6
1556 else
1557   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1558 for as_dir in $PATH
1559 do
1560   IFS=$as_save_IFS
1561   test -z "$as_dir" && as_dir=.
1562   # Account for people who put trailing slashes in PATH elements.
1563 case $as_dir/ in
1564   ./ | .// | /cC/* | \
1565   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1566   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1567   /usr/ucb/* ) ;;
1568   *)
1569     # OSF1 and SCO ODT 3.0 have their own names for install.
1570     # Don't use installbsd from OSF since it installs stuff as root
1571     # by default.
1572     for ac_prog in ginstall scoinst install; do
1573       for ac_exec_ext in '' $ac_executable_extensions; do
1574         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1575           if test $ac_prog = install &&
1576             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1577             # AIX install.  It has an incompatible calling convention.
1578             :
1579           elif test $ac_prog = install &&
1580             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1581             # program-specific install script used by HP pwplus--don't use.
1582             :
1583           else
1584             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1585             break 3
1586           fi
1587         fi
1588       done
1589     done
1590     ;;
1591 esac
1592 done
1593
1594
1595 fi
1596   if test "${ac_cv_path_install+set}" = set; then
1597     INSTALL=$ac_cv_path_install
1598   else
1599     # As a last resort, use the slow shell script.  We don't cache a
1600     # path for INSTALL within a source directory, because that will
1601     # break other packages using the cache if that directory is
1602     # removed, or if the path is relative.
1603     INSTALL=$ac_install_sh
1604   fi
1605 fi
1606 echo "$as_me:$LINENO: result: $INSTALL" >&5
1607 echo "${ECHO_T}$INSTALL" >&6
1608
1609 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1610 # It thinks the first close brace ends the variable substitution.
1611 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1612
1613 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1614
1615 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1616
1617 echo "$as_me:$LINENO: checking whether build environment is sane" >&5
1618 echo $ECHO_N "checking whether build environment is sane... $ECHO_C" >&6
1619 # Just in case
1620 sleep 1
1621 echo timestamp > conftest.file
1622 # Do `set' in a subshell so we don't clobber the current shell's
1623 # arguments.  Must try -L first in case configure is actually a
1624 # symlink; some systems play weird games with the mod time of symlinks
1625 # (eg FreeBSD returns the mod time of the symlink's containing
1626 # directory).
1627 if (
1628    set X `ls -Lt $srcdir/configure conftest.file 2> /dev/null`
1629    if test "$*" = "X"; then
1630       # -L didn't work.
1631       set X `ls -t $srcdir/configure conftest.file`
1632    fi
1633    rm -f conftest.file
1634    if test "$*" != "X $srcdir/configure conftest.file" \
1635       && test "$*" != "X conftest.file $srcdir/configure"; then
1636
1637       # If neither matched, then we have a broken ls.  This can happen
1638       # if, for instance, CONFIG_SHELL is bash and it inherits a
1639       # broken ls alias from the environment.  This has actually
1640       # happened.  Such a system could not be considered "sane".
1641       { { echo "$as_me:$LINENO: error: ls -t appears to fail.  Make sure there is not a broken
1642 alias in your environment" >&5
1643 echo "$as_me: error: ls -t appears to fail.  Make sure there is not a broken
1644 alias in your environment" >&2;}
1645    { (exit 1); exit 1; }; }
1646    fi
1647
1648    test "$2" = conftest.file
1649    )
1650 then
1651    # Ok.
1652    :
1653 else
1654    { { echo "$as_me:$LINENO: error: newly created file is older than distributed files!
1655 Check your system clock" >&5
1656 echo "$as_me: error: newly created file is older than distributed files!
1657 Check your system clock" >&2;}
1658    { (exit 1); exit 1; }; }
1659 fi
1660 echo "$as_me:$LINENO: result: yes" >&5
1661 echo "${ECHO_T}yes" >&6
1662 test "$program_prefix" != NONE &&
1663   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1664 # Use a double $ so make ignores it.
1665 test "$program_suffix" != NONE &&
1666   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1667 # Double any \ or $.  echo might interpret backslashes.
1668 # By default was `s,x,x', remove it if useless.
1669 cat <<\_ACEOF >conftest.sed
1670 s/[\\$]/&&/g;s/;s,x,x,$//
1671 _ACEOF
1672 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1673 rm conftest.sed
1674
1675 # expand $ac_aux_dir to an absolute path
1676 am_aux_dir=`cd $ac_aux_dir && pwd`
1677
1678 test x"${MISSING+set}" = xset || MISSING="\${SHELL} $am_aux_dir/missing"
1679 # Use eval to expand $SHELL
1680 if eval "$MISSING --run true"; then
1681   am_missing_run="$MISSING --run "
1682 else
1683   am_missing_run=
1684   { echo "$as_me:$LINENO: WARNING: \`missing' script is too old or missing" >&5
1685 echo "$as_me: WARNING: \`missing' script is too old or missing" >&2;}
1686 fi
1687
1688 if mkdir -p --version . >/dev/null 2>&1 && test ! -d ./--version; then
1689   # We used to keeping the `.' as first argument, in order to
1690   # allow $(mkdir_p) to be used without argument.  As in
1691   #   $(mkdir_p) $(somedir)
1692   # where $(somedir) is conditionally defined.  However this is wrong
1693   # for two reasons:
1694   #  1. if the package is installed by a user who cannot write `.'
1695   #     make install will fail,
1696   #  2. the above comment should most certainly read
1697   #     $(mkdir_p) $(DESTDIR)$(somedir)
1698   #     so it does not work when $(somedir) is undefined and
1699   #     $(DESTDIR) is not.
1700   #  To support the latter case, we have to write
1701   #     test -z "$(somedir)" || $(mkdir_p) $(DESTDIR)$(somedir),
1702   #  so the `.' trick is pointless.
1703   mkdir_p='mkdir -p --'
1704 else
1705   # On NextStep and OpenStep, the `mkdir' command does not
1706   # recognize any option.  It will interpret all options as
1707   # directories to create, and then abort because `.' already
1708   # exists.
1709   for d in ./-p ./--version;
1710   do
1711     test -d $d && rmdir $d
1712   done
1713   # $(mkinstalldirs) is defined by Automake if mkinstalldirs exists.
1714   if test -f "$ac_aux_dir/mkinstalldirs"; then
1715     mkdir_p='$(mkinstalldirs)'
1716   else
1717     mkdir_p='$(install_sh) -d'
1718   fi
1719 fi
1720
1721 for ac_prog in gawk mawk nawk awk
1722 do
1723   # Extract the first word of "$ac_prog", so it can be a program name with args.
1724 set dummy $ac_prog; ac_word=$2
1725 echo "$as_me:$LINENO: checking for $ac_word" >&5
1726 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1727 if test "${ac_cv_prog_AWK+set}" = set; then
1728   echo $ECHO_N "(cached) $ECHO_C" >&6
1729 else
1730   if test -n "$AWK"; then
1731   ac_cv_prog_AWK="$AWK" # Let the user override the test.
1732 else
1733 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1734 for as_dir in $PATH
1735 do
1736   IFS=$as_save_IFS
1737   test -z "$as_dir" && as_dir=.
1738   for ac_exec_ext in '' $ac_executable_extensions; do
1739   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1740     ac_cv_prog_AWK="$ac_prog"
1741     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1742     break 2
1743   fi
1744 done
1745 done
1746
1747 fi
1748 fi
1749 AWK=$ac_cv_prog_AWK
1750 if test -n "$AWK"; then
1751   echo "$as_me:$LINENO: result: $AWK" >&5
1752 echo "${ECHO_T}$AWK" >&6
1753 else
1754   echo "$as_me:$LINENO: result: no" >&5
1755 echo "${ECHO_T}no" >&6
1756 fi
1757
1758   test -n "$AWK" && break
1759 done
1760
1761 echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
1762 echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
1763 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
1764 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
1765   echo $ECHO_N "(cached) $ECHO_C" >&6
1766 else
1767   cat >conftest.make <<\_ACEOF
1768 all:
1769         @echo 'ac_maketemp="$(MAKE)"'
1770 _ACEOF
1771 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
1772 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
1773 if test -n "$ac_maketemp"; then
1774   eval ac_cv_prog_make_${ac_make}_set=yes
1775 else
1776   eval ac_cv_prog_make_${ac_make}_set=no
1777 fi
1778 rm -f conftest.make
1779 fi
1780 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
1781   echo "$as_me:$LINENO: result: yes" >&5
1782 echo "${ECHO_T}yes" >&6
1783   SET_MAKE=
1784 else
1785   echo "$as_me:$LINENO: result: no" >&5
1786 echo "${ECHO_T}no" >&6
1787   SET_MAKE="MAKE=${MAKE-make}"
1788 fi
1789
1790 rm -rf .tst 2>/dev/null
1791 mkdir .tst 2>/dev/null
1792 if test -d .tst; then
1793   am__leading_dot=.
1794 else
1795   am__leading_dot=_
1796 fi
1797 rmdir .tst 2>/dev/null
1798
1799 # test to see if srcdir already configured
1800 if test "`cd $srcdir && pwd`" != "`pwd`" &&
1801    test -f $srcdir/config.status; then
1802   { { echo "$as_me:$LINENO: error: source directory already configured; run \"make distclean\" there first" >&5
1803 echo "$as_me: error: source directory already configured; run \"make distclean\" there first" >&2;}
1804    { (exit 1); exit 1; }; }
1805 fi
1806
1807 # test whether we have cygpath
1808 if test -z "$CYGPATH_W"; then
1809   if (cygpath --version) >/dev/null 2>/dev/null; then
1810     CYGPATH_W='cygpath -w'
1811   else
1812     CYGPATH_W=echo
1813   fi
1814 fi
1815
1816
1817 # Define the identity of the package.
1818  PACKAGE='libgfortran'
1819  VERSION='0.3'
1820
1821
1822 # Some tools Automake needs.
1823
1824 ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}
1825
1826
1827 AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}
1828
1829
1830 AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}
1831
1832
1833 AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}
1834
1835
1836 MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
1837
1838 install_sh=${install_sh-"$am_aux_dir/install-sh"}
1839
1840 # Installed binaries are usually stripped using `strip' when the user
1841 # run `make install-strip'.  However `strip' might not be the right
1842 # tool to use in cross-compilation environments, therefore Automake
1843 # will honor the `STRIP' environment variable to overrule this program.
1844 if test "$cross_compiling" != no; then
1845   if test -n "$ac_tool_prefix"; then
1846   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
1847 set dummy ${ac_tool_prefix}strip; ac_word=$2
1848 echo "$as_me:$LINENO: checking for $ac_word" >&5
1849 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1850 if test "${ac_cv_prog_STRIP+set}" = set; then
1851   echo $ECHO_N "(cached) $ECHO_C" >&6
1852 else
1853   if test -n "$STRIP"; then
1854   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
1855 else
1856 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1857 for as_dir in $PATH
1858 do
1859   IFS=$as_save_IFS
1860   test -z "$as_dir" && as_dir=.
1861   for ac_exec_ext in '' $ac_executable_extensions; do
1862   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1863     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
1864     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1865     break 2
1866   fi
1867 done
1868 done
1869
1870 fi
1871 fi
1872 STRIP=$ac_cv_prog_STRIP
1873 if test -n "$STRIP"; then
1874   echo "$as_me:$LINENO: result: $STRIP" >&5
1875 echo "${ECHO_T}$STRIP" >&6
1876 else
1877   echo "$as_me:$LINENO: result: no" >&5
1878 echo "${ECHO_T}no" >&6
1879 fi
1880
1881 fi
1882 if test -z "$ac_cv_prog_STRIP"; then
1883   ac_ct_STRIP=$STRIP
1884   # Extract the first word of "strip", so it can be a program name with args.
1885 set dummy strip; ac_word=$2
1886 echo "$as_me:$LINENO: checking for $ac_word" >&5
1887 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1888 if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
1889   echo $ECHO_N "(cached) $ECHO_C" >&6
1890 else
1891   if test -n "$ac_ct_STRIP"; then
1892   ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
1893 else
1894 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1895 for as_dir in $PATH
1896 do
1897   IFS=$as_save_IFS
1898   test -z "$as_dir" && as_dir=.
1899   for ac_exec_ext in '' $ac_executable_extensions; do
1900   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1901     ac_cv_prog_ac_ct_STRIP="strip"
1902     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1903     break 2
1904   fi
1905 done
1906 done
1907
1908   test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
1909 fi
1910 fi
1911 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
1912 if test -n "$ac_ct_STRIP"; then
1913   echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
1914 echo "${ECHO_T}$ac_ct_STRIP" >&6
1915 else
1916   echo "$as_me:$LINENO: result: no" >&5
1917 echo "${ECHO_T}no" >&6
1918 fi
1919
1920   STRIP=$ac_ct_STRIP
1921 else
1922   STRIP="$ac_cv_prog_STRIP"
1923 fi
1924
1925 fi
1926 INSTALL_STRIP_PROGRAM="\${SHELL} \$(install_sh) -c -s"
1927
1928 # We need awk for the "check" target.  The system "awk" is bad on
1929 # some platforms.
1930 # Always define AMTAR for backward compatibility.
1931
1932 AMTAR=${AMTAR-"${am_missing_run}tar"}
1933
1934 am__tar='${AMTAR} chof - "$$tardir"'; am__untar='${AMTAR} xf -'
1935
1936
1937
1938
1939
1940
1941 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
1942 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
1943     # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
1944 if test "${enable_maintainer_mode+set}" = set; then
1945   enableval="$enable_maintainer_mode"
1946   USE_MAINTAINER_MODE=$enableval
1947 else
1948   USE_MAINTAINER_MODE=no
1949 fi;
1950   echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
1951 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
1952
1953
1954 if test $USE_MAINTAINER_MODE = yes; then
1955   MAINTAINER_MODE_TRUE=
1956   MAINTAINER_MODE_FALSE='#'
1957 else
1958   MAINTAINER_MODE_TRUE='#'
1959   MAINTAINER_MODE_FALSE=
1960 fi
1961
1962   MAINT=$MAINTAINER_MODE_TRUE
1963
1964
1965 # Default to --enable-multilib
1966 # Check whether --enable-multilib or --disable-multilib was given.
1967 if test "${enable_multilib+set}" = set; then
1968   enableval="$enable_multilib"
1969   case "$enableval" in
1970   yes) multilib=yes ;;
1971   no)  multilib=no ;;
1972   *)   { { echo "$as_me:$LINENO: error: bad value $enableval for multilib option" >&5
1973 echo "$as_me: error: bad value $enableval for multilib option" >&2;}
1974    { (exit 1); exit 1; }; } ;;
1975  esac
1976 else
1977   multilib=yes
1978 fi;
1979
1980 # We may get other options which we leave undocumented:
1981 # --with-target-subdir, --with-multisrctop, --with-multisubdir
1982 # See config-ml.in if you want the gory details.
1983
1984 if test "$srcdir" = "."; then
1985   if test "$with_target_subdir" != "."; then
1986     multi_basedir="$srcdir/$with_multisrctop../.."
1987   else
1988     multi_basedir="$srcdir/$with_multisrctop.."
1989   fi
1990 else
1991   multi_basedir="$srcdir/.."
1992 fi
1993
1994
1995 # Even if the default multilib is not a cross compilation,
1996 # it may be that some of the other multilibs are.
1997 if test $cross_compiling = no && test $multilib = yes \
1998    && test "x${with_multisubdir}" != x ; then
1999    cross_compiling=maybe
2000 fi
2001
2002           ac_config_commands="$ac_config_commands default-1"
2003
2004
2005 # Handy for debugging:
2006 #AC_MSG_NOTICE($build / $host / $target / $host_alias / $target_alias); sleep 5
2007
2008 # Are we being configured with some form of cross compiler?
2009 # NB: We don't actually need to know this just now, but when, say, a test
2010 #     suite is included, we'll have to know.
2011 if test "$build" != "$host"; then
2012   LIBGFOR_IS_NATIVE=false
2013
2014 else
2015   LIBGFOR_IS_NATIVE=true
2016 fi
2017
2018 # Calculate toolexeclibdir
2019 # Also toolexecdir, though it's only used in toolexeclibdir
2020 case ${version_specific_libs} in
2021   yes)
2022     # Need the gcc compiler version to know where to install libraries
2023     # and header files if --enable-version-specific-runtime-libs option
2024     # is selected.
2025     toolexecdir='$(libdir)/gcc/$(target_alias)'
2026     toolexeclibdir='$(toolexecdir)/$(gcc_version)$(MULTISUBDIR)'
2027     ;;
2028   no)
2029     if test -n "$with_cross_host" &&
2030        test x"$with_cross_host" != x"no"; then
2031       # Install a library built with a cross compiler in tooldir, not libdir.
2032       toolexecdir='$(exec_prefix)/$(target_alias)'
2033       toolexeclibdir='$(toolexecdir)/lib'
2034     else
2035       toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
2036       toolexeclibdir='$(libdir)'
2037     fi
2038     multi_os_directory=`$CC -print-multi-os-directory`
2039     case $multi_os_directory in
2040       .) ;; # Avoid trailing /.
2041       *) toolexeclibdir=$toolexeclibdir/$multi_os_directory ;;
2042     esac
2043     ;;
2044 esac
2045
2046
2047
2048 # Check the compiler.
2049 # The same as in boehm-gc and libstdc++. Have to borrow it from there.
2050 # We must force CC to /not/ be precious variables; otherwise
2051 # the wrong, non-multilib-adjusted value will be used in multilibs.
2052 # As a side effect, we have to subst CFLAGS ourselves.
2053
2054
2055
2056 ac_ext=c
2057 ac_cpp='$CPP $CPPFLAGS'
2058 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2059 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2060 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2061 if test -n "$ac_tool_prefix"; then
2062   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2063 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2064 echo "$as_me:$LINENO: checking for $ac_word" >&5
2065 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2066 if test "${ac_cv_prog_CC+set}" = set; then
2067   echo $ECHO_N "(cached) $ECHO_C" >&6
2068 else
2069   if test -n "$CC"; then
2070   ac_cv_prog_CC="$CC" # Let the user override the test.
2071 else
2072 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2073 for as_dir in $PATH
2074 do
2075   IFS=$as_save_IFS
2076   test -z "$as_dir" && as_dir=.
2077   for ac_exec_ext in '' $ac_executable_extensions; do
2078   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2079     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2080     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2081     break 2
2082   fi
2083 done
2084 done
2085
2086 fi
2087 fi
2088 CC=$ac_cv_prog_CC
2089 if test -n "$CC"; then
2090   echo "$as_me:$LINENO: result: $CC" >&5
2091 echo "${ECHO_T}$CC" >&6
2092 else
2093   echo "$as_me:$LINENO: result: no" >&5
2094 echo "${ECHO_T}no" >&6
2095 fi
2096
2097 fi
2098 if test -z "$ac_cv_prog_CC"; then
2099   ac_ct_CC=$CC
2100   # Extract the first word of "gcc", so it can be a program name with args.
2101 set dummy gcc; ac_word=$2
2102 echo "$as_me:$LINENO: checking for $ac_word" >&5
2103 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2104 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2105   echo $ECHO_N "(cached) $ECHO_C" >&6
2106 else
2107   if test -n "$ac_ct_CC"; then
2108   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2109 else
2110 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2111 for as_dir in $PATH
2112 do
2113   IFS=$as_save_IFS
2114   test -z "$as_dir" && as_dir=.
2115   for ac_exec_ext in '' $ac_executable_extensions; do
2116   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2117     ac_cv_prog_ac_ct_CC="gcc"
2118     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2119     break 2
2120   fi
2121 done
2122 done
2123
2124 fi
2125 fi
2126 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2127 if test -n "$ac_ct_CC"; then
2128   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2129 echo "${ECHO_T}$ac_ct_CC" >&6
2130 else
2131   echo "$as_me:$LINENO: result: no" >&5
2132 echo "${ECHO_T}no" >&6
2133 fi
2134
2135   CC=$ac_ct_CC
2136 else
2137   CC="$ac_cv_prog_CC"
2138 fi
2139
2140 if test -z "$CC"; then
2141   if test -n "$ac_tool_prefix"; then
2142   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2143 set dummy ${ac_tool_prefix}cc; ac_word=$2
2144 echo "$as_me:$LINENO: checking for $ac_word" >&5
2145 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2146 if test "${ac_cv_prog_CC+set}" = set; then
2147   echo $ECHO_N "(cached) $ECHO_C" >&6
2148 else
2149   if test -n "$CC"; then
2150   ac_cv_prog_CC="$CC" # Let the user override the test.
2151 else
2152 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2153 for as_dir in $PATH
2154 do
2155   IFS=$as_save_IFS
2156   test -z "$as_dir" && as_dir=.
2157   for ac_exec_ext in '' $ac_executable_extensions; do
2158   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2159     ac_cv_prog_CC="${ac_tool_prefix}cc"
2160     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2161     break 2
2162   fi
2163 done
2164 done
2165
2166 fi
2167 fi
2168 CC=$ac_cv_prog_CC
2169 if test -n "$CC"; then
2170   echo "$as_me:$LINENO: result: $CC" >&5
2171 echo "${ECHO_T}$CC" >&6
2172 else
2173   echo "$as_me:$LINENO: result: no" >&5
2174 echo "${ECHO_T}no" >&6
2175 fi
2176
2177 fi
2178 if test -z "$ac_cv_prog_CC"; then
2179   ac_ct_CC=$CC
2180   # Extract the first word of "cc", so it can be a program name with args.
2181 set dummy cc; ac_word=$2
2182 echo "$as_me:$LINENO: checking for $ac_word" >&5
2183 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2184 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2185   echo $ECHO_N "(cached) $ECHO_C" >&6
2186 else
2187   if test -n "$ac_ct_CC"; then
2188   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2189 else
2190 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2191 for as_dir in $PATH
2192 do
2193   IFS=$as_save_IFS
2194   test -z "$as_dir" && as_dir=.
2195   for ac_exec_ext in '' $ac_executable_extensions; do
2196   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2197     ac_cv_prog_ac_ct_CC="cc"
2198     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2199     break 2
2200   fi
2201 done
2202 done
2203
2204 fi
2205 fi
2206 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2207 if test -n "$ac_ct_CC"; then
2208   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2209 echo "${ECHO_T}$ac_ct_CC" >&6
2210 else
2211   echo "$as_me:$LINENO: result: no" >&5
2212 echo "${ECHO_T}no" >&6
2213 fi
2214
2215   CC=$ac_ct_CC
2216 else
2217   CC="$ac_cv_prog_CC"
2218 fi
2219
2220 fi
2221 if test -z "$CC"; then
2222   # Extract the first word of "cc", so it can be a program name with args.
2223 set dummy cc; ac_word=$2
2224 echo "$as_me:$LINENO: checking for $ac_word" >&5
2225 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2226 if test "${ac_cv_prog_CC+set}" = set; then
2227   echo $ECHO_N "(cached) $ECHO_C" >&6
2228 else
2229   if test -n "$CC"; then
2230   ac_cv_prog_CC="$CC" # Let the user override the test.
2231 else
2232   ac_prog_rejected=no
2233 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2234 for as_dir in $PATH
2235 do
2236   IFS=$as_save_IFS
2237   test -z "$as_dir" && as_dir=.
2238   for ac_exec_ext in '' $ac_executable_extensions; do
2239   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2240     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2241        ac_prog_rejected=yes
2242        continue
2243      fi
2244     ac_cv_prog_CC="cc"
2245     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2246     break 2
2247   fi
2248 done
2249 done
2250
2251 if test $ac_prog_rejected = yes; then
2252   # We found a bogon in the path, so make sure we never use it.
2253   set dummy $ac_cv_prog_CC
2254   shift
2255   if test $# != 0; then
2256     # We chose a different compiler from the bogus one.
2257     # However, it has the same basename, so the bogon will be chosen
2258     # first if we set CC to just the basename; use the full file name.
2259     shift
2260     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
2261   fi
2262 fi
2263 fi
2264 fi
2265 CC=$ac_cv_prog_CC
2266 if test -n "$CC"; then
2267   echo "$as_me:$LINENO: result: $CC" >&5
2268 echo "${ECHO_T}$CC" >&6
2269 else
2270   echo "$as_me:$LINENO: result: no" >&5
2271 echo "${ECHO_T}no" >&6
2272 fi
2273
2274 fi
2275 if test -z "$CC"; then
2276   if test -n "$ac_tool_prefix"; then
2277   for ac_prog in cl
2278   do
2279     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2280 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2281 echo "$as_me:$LINENO: checking for $ac_word" >&5
2282 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2283 if test "${ac_cv_prog_CC+set}" = set; then
2284   echo $ECHO_N "(cached) $ECHO_C" >&6
2285 else
2286   if test -n "$CC"; then
2287   ac_cv_prog_CC="$CC" # Let the user override the test.
2288 else
2289 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2290 for as_dir in $PATH
2291 do
2292   IFS=$as_save_IFS
2293   test -z "$as_dir" && as_dir=.
2294   for ac_exec_ext in '' $ac_executable_extensions; do
2295   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2296     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2297     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2298     break 2
2299   fi
2300 done
2301 done
2302
2303 fi
2304 fi
2305 CC=$ac_cv_prog_CC
2306 if test -n "$CC"; then
2307   echo "$as_me:$LINENO: result: $CC" >&5
2308 echo "${ECHO_T}$CC" >&6
2309 else
2310   echo "$as_me:$LINENO: result: no" >&5
2311 echo "${ECHO_T}no" >&6
2312 fi
2313
2314     test -n "$CC" && break
2315   done
2316 fi
2317 if test -z "$CC"; then
2318   ac_ct_CC=$CC
2319   for ac_prog in cl
2320 do
2321   # Extract the first word of "$ac_prog", so it can be a program name with args.
2322 set dummy $ac_prog; ac_word=$2
2323 echo "$as_me:$LINENO: checking for $ac_word" >&5
2324 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2325 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2326   echo $ECHO_N "(cached) $ECHO_C" >&6
2327 else
2328   if test -n "$ac_ct_CC"; then
2329   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2330 else
2331 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2332 for as_dir in $PATH
2333 do
2334   IFS=$as_save_IFS
2335   test -z "$as_dir" && as_dir=.
2336   for ac_exec_ext in '' $ac_executable_extensions; do
2337   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2338     ac_cv_prog_ac_ct_CC="$ac_prog"
2339     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2340     break 2
2341   fi
2342 done
2343 done
2344
2345 fi
2346 fi
2347 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2348 if test -n "$ac_ct_CC"; then
2349   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2350 echo "${ECHO_T}$ac_ct_CC" >&6
2351 else
2352   echo "$as_me:$LINENO: result: no" >&5
2353 echo "${ECHO_T}no" >&6
2354 fi
2355
2356   test -n "$ac_ct_CC" && break
2357 done
2358
2359   CC=$ac_ct_CC
2360 fi
2361
2362 fi
2363
2364
2365 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2366 See \`config.log' for more details." >&5
2367 echo "$as_me: error: no acceptable C compiler found in \$PATH
2368 See \`config.log' for more details." >&2;}
2369    { (exit 1); exit 1; }; }
2370
2371 # Provide some information about the compiler.
2372 echo "$as_me:$LINENO:" \
2373      "checking for C compiler version" >&5
2374 ac_compiler=`set X $ac_compile; echo $2`
2375 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2376   (eval $ac_compiler --version </dev/null >&5) 2>&5
2377   ac_status=$?
2378   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2379   (exit $ac_status); }
2380 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2381   (eval $ac_compiler -v </dev/null >&5) 2>&5
2382   ac_status=$?
2383   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2384   (exit $ac_status); }
2385 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2386   (eval $ac_compiler -V </dev/null >&5) 2>&5
2387   ac_status=$?
2388   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2389   (exit $ac_status); }
2390
2391 cat >conftest.$ac_ext <<_ACEOF
2392 /* confdefs.h.  */
2393 _ACEOF
2394 cat confdefs.h >>conftest.$ac_ext
2395 cat >>conftest.$ac_ext <<_ACEOF
2396 /* end confdefs.h.  */
2397
2398 int
2399 main ()
2400 {
2401
2402   ;
2403   return 0;
2404 }
2405 _ACEOF
2406 # FIXME: Cleanup?
2407 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
2408   (eval $ac_link) 2>&5
2409   ac_status=$?
2410   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2411   (exit $ac_status); }; then
2412   gcc_no_link=no
2413 else
2414   gcc_no_link=yes
2415 fi
2416
2417 if test x$gcc_no_link = xyes; then
2418   # Setting cross_compile will disable run tests; it will
2419   # also disable AC_CHECK_FILE but that's generally
2420   # correct if we can't link.
2421   cross_compiling=yes
2422   EXEEXT=
2423 else
2424   cat >conftest.$ac_ext <<_ACEOF
2425 /* confdefs.h.  */
2426 _ACEOF
2427 cat confdefs.h >>conftest.$ac_ext
2428 cat >>conftest.$ac_ext <<_ACEOF
2429 /* end confdefs.h.  */
2430
2431 int
2432 main ()
2433 {
2434
2435   ;
2436   return 0;
2437 }
2438 _ACEOF
2439 ac_clean_files_save=$ac_clean_files
2440 ac_clean_files="$ac_clean_files a.out a.exe b.out"
2441 # Try to create an executable without -o first, disregard a.out.
2442 # It will help us diagnose broken compilers, and finding out an intuition
2443 # of exeext.
2444 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
2445 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
2446 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
2447 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
2448   (eval $ac_link_default) 2>&5
2449   ac_status=$?
2450   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2451   (exit $ac_status); }; then
2452   # Find the output, starting from the most likely.  This scheme is
2453 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
2454 # resort.
2455
2456 # Be careful to initialize this variable, since it used to be cached.
2457 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
2458 ac_cv_exeext=
2459 # b.out is created by i960 compilers.
2460 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
2461 do
2462   test -f "$ac_file" || continue
2463   case $ac_file in
2464     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
2465         ;;
2466     conftest.$ac_ext )
2467         # This is the source file.
2468         ;;
2469     [ab].out )
2470         # We found the default executable, but exeext='' is most
2471         # certainly right.
2472         break;;
2473     *.* )
2474         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
2475         # FIXME: I believe we export ac_cv_exeext for Libtool,
2476         # but it would be cool to find out if it's true.  Does anybody
2477         # maintain Libtool? --akim.
2478         export ac_cv_exeext
2479         break;;
2480     * )
2481         break;;
2482   esac
2483 done
2484 else
2485   echo "$as_me: failed program was:" >&5
2486 sed 's/^/| /' conftest.$ac_ext >&5
2487
2488 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
2489 See \`config.log' for more details." >&5
2490 echo "$as_me: error: C compiler cannot create executables
2491 See \`config.log' for more details." >&2;}
2492    { (exit 77); exit 77; }; }
2493 fi
2494
2495 ac_exeext=$ac_cv_exeext
2496 echo "$as_me:$LINENO: result: $ac_file" >&5
2497 echo "${ECHO_T}$ac_file" >&6
2498
2499 # Check the compiler produces executables we can run.  If not, either
2500 # the compiler is broken, or we cross compile.
2501 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
2502 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
2503 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
2504 # If not cross compiling, check that we can run a simple program.
2505 if test "$cross_compiling" != yes; then
2506   if { ac_try='./$ac_file'
2507   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2508   (eval $ac_try) 2>&5
2509   ac_status=$?
2510   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2511   (exit $ac_status); }; }; then
2512     cross_compiling=no
2513   else
2514     if test "$cross_compiling" = maybe; then
2515         cross_compiling=yes
2516     else
2517         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
2518 If you meant to cross compile, use \`--host'.
2519 See \`config.log' for more details." >&5
2520 echo "$as_me: error: cannot run C compiled programs.
2521 If you meant to cross compile, use \`--host'.
2522 See \`config.log' for more details." >&2;}
2523    { (exit 1); exit 1; }; }
2524     fi
2525   fi
2526 fi
2527 echo "$as_me:$LINENO: result: yes" >&5
2528 echo "${ECHO_T}yes" >&6
2529
2530 rm -f a.out a.exe conftest$ac_cv_exeext b.out
2531 ac_clean_files=$ac_clean_files_save
2532 # Check the compiler produces executables we can run.  If not, either
2533 # the compiler is broken, or we cross compile.
2534 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
2535 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
2536 echo "$as_me:$LINENO: result: $cross_compiling" >&5
2537 echo "${ECHO_T}$cross_compiling" >&6
2538
2539 echo "$as_me:$LINENO: checking for suffix of executables" >&5
2540 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
2541 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
2542   (eval $ac_link) 2>&5
2543   ac_status=$?
2544   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2545   (exit $ac_status); }; then
2546   # If both `conftest.exe' and `conftest' are `present' (well, observable)
2547 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
2548 # work properly (i.e., refer to `conftest.exe'), while it won't with
2549 # `rm'.
2550 for ac_file in conftest.exe conftest conftest.*; do
2551   test -f "$ac_file" || continue
2552   case $ac_file in
2553     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
2554     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
2555           export ac_cv_exeext
2556           break;;
2557     * ) break;;
2558   esac
2559 done
2560 else
2561   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
2562 See \`config.log' for more details." >&5
2563 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
2564 See \`config.log' for more details." >&2;}
2565    { (exit 1); exit 1; }; }
2566 fi
2567
2568 rm -f conftest$ac_cv_exeext
2569 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
2570 echo "${ECHO_T}$ac_cv_exeext" >&6
2571
2572 rm -f conftest.$ac_ext
2573 EXEEXT=$ac_cv_exeext
2574 ac_exeext=$EXEEXT
2575 fi
2576 echo "$as_me:$LINENO: checking for suffix of object files" >&5
2577 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
2578 if test "${ac_cv_objext+set}" = set; then
2579   echo $ECHO_N "(cached) $ECHO_C" >&6
2580 else
2581   cat >conftest.$ac_ext <<_ACEOF
2582 /* confdefs.h.  */
2583 _ACEOF
2584 cat confdefs.h >>conftest.$ac_ext
2585 cat >>conftest.$ac_ext <<_ACEOF
2586 /* end confdefs.h.  */
2587
2588 int
2589 main ()
2590 {
2591
2592   ;
2593   return 0;
2594 }
2595 _ACEOF
2596 rm -f conftest.o conftest.obj
2597 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2598   (eval $ac_compile) 2>&5
2599   ac_status=$?
2600   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2601   (exit $ac_status); }; then
2602   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
2603   case $ac_file in
2604     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
2605     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
2606        break;;
2607   esac
2608 done
2609 else
2610   echo "$as_me: failed program was:" >&5
2611 sed 's/^/| /' conftest.$ac_ext >&5
2612
2613 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
2614 See \`config.log' for more details." >&5
2615 echo "$as_me: error: cannot compute suffix of object files: cannot compile
2616 See \`config.log' for more details." >&2;}
2617    { (exit 1); exit 1; }; }
2618 fi
2619
2620 rm -f conftest.$ac_cv_objext conftest.$ac_ext
2621 fi
2622 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
2623 echo "${ECHO_T}$ac_cv_objext" >&6
2624 OBJEXT=$ac_cv_objext
2625 ac_objext=$OBJEXT
2626 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2627 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2628 if test "${ac_cv_c_compiler_gnu+set}" = set; then
2629   echo $ECHO_N "(cached) $ECHO_C" >&6
2630 else
2631   cat >conftest.$ac_ext <<_ACEOF
2632 /* confdefs.h.  */
2633 _ACEOF
2634 cat confdefs.h >>conftest.$ac_ext
2635 cat >>conftest.$ac_ext <<_ACEOF
2636 /* end confdefs.h.  */
2637
2638 int
2639 main ()
2640 {
2641 #ifndef __GNUC__
2642        choke me
2643 #endif
2644
2645   ;
2646   return 0;
2647 }
2648 _ACEOF
2649 rm -f conftest.$ac_objext
2650 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2651   (eval $ac_compile) 2>conftest.er1
2652   ac_status=$?
2653   grep -v '^ *+' conftest.er1 >conftest.err
2654   rm -f conftest.er1
2655   cat conftest.err >&5
2656   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2657   (exit $ac_status); } &&
2658          { ac_try='test -z "$ac_c_werror_flag"
2659                          || test ! -s conftest.err'
2660   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2661   (eval $ac_try) 2>&5
2662   ac_status=$?
2663   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2664   (exit $ac_status); }; } &&
2665          { ac_try='test -s conftest.$ac_objext'
2666   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2667   (eval $ac_try) 2>&5
2668   ac_status=$?
2669   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2670   (exit $ac_status); }; }; then
2671   ac_compiler_gnu=yes
2672 else
2673   echo "$as_me: failed program was:" >&5
2674 sed 's/^/| /' conftest.$ac_ext >&5
2675
2676 ac_compiler_gnu=no
2677 fi
2678 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2679 ac_cv_c_compiler_gnu=$ac_compiler_gnu
2680
2681 fi
2682 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2683 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2684 GCC=`test $ac_compiler_gnu = yes && echo yes`
2685 ac_test_CFLAGS=${CFLAGS+set}
2686 ac_save_CFLAGS=$CFLAGS
2687 CFLAGS="-g"
2688 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2689 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2690 if test "${ac_cv_prog_cc_g+set}" = set; then
2691   echo $ECHO_N "(cached) $ECHO_C" >&6
2692 else
2693   cat >conftest.$ac_ext <<_ACEOF
2694 /* confdefs.h.  */
2695 _ACEOF
2696 cat confdefs.h >>conftest.$ac_ext
2697 cat >>conftest.$ac_ext <<_ACEOF
2698 /* end confdefs.h.  */
2699
2700 int
2701 main ()
2702 {
2703
2704   ;
2705   return 0;
2706 }
2707 _ACEOF
2708 rm -f conftest.$ac_objext
2709 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2710   (eval $ac_compile) 2>conftest.er1
2711   ac_status=$?
2712   grep -v '^ *+' conftest.er1 >conftest.err
2713   rm -f conftest.er1
2714   cat conftest.err >&5
2715   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2716   (exit $ac_status); } &&
2717          { ac_try='test -z "$ac_c_werror_flag"
2718                          || test ! -s conftest.err'
2719   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2720   (eval $ac_try) 2>&5
2721   ac_status=$?
2722   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2723   (exit $ac_status); }; } &&
2724          { ac_try='test -s conftest.$ac_objext'
2725   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2726   (eval $ac_try) 2>&5
2727   ac_status=$?
2728   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2729   (exit $ac_status); }; }; then
2730   ac_cv_prog_cc_g=yes
2731 else
2732   echo "$as_me: failed program was:" >&5
2733 sed 's/^/| /' conftest.$ac_ext >&5
2734
2735 ac_cv_prog_cc_g=no
2736 fi
2737 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2738 fi
2739 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2740 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2741 if test "$ac_test_CFLAGS" = set; then
2742   CFLAGS=$ac_save_CFLAGS
2743 elif test $ac_cv_prog_cc_g = yes; then
2744   if test "$GCC" = yes; then
2745     CFLAGS="-g -O2"
2746   else
2747     CFLAGS="-g"
2748   fi
2749 else
2750   if test "$GCC" = yes; then
2751     CFLAGS="-O2"
2752   else
2753     CFLAGS=
2754   fi
2755 fi
2756 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2757 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2758 if test "${ac_cv_prog_cc_stdc+set}" = set; then
2759   echo $ECHO_N "(cached) $ECHO_C" >&6
2760 else
2761   ac_cv_prog_cc_stdc=no
2762 ac_save_CC=$CC
2763 cat >conftest.$ac_ext <<_ACEOF
2764 /* confdefs.h.  */
2765 _ACEOF
2766 cat confdefs.h >>conftest.$ac_ext
2767 cat >>conftest.$ac_ext <<_ACEOF
2768 /* end confdefs.h.  */
2769 #include <stdarg.h>
2770 #include <stdio.h>
2771 #include <sys/types.h>
2772 #include <sys/stat.h>
2773 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2774 struct buf { int x; };
2775 FILE * (*rcsopen) (struct buf *, struct stat *, int);
2776 static char *e (p, i)
2777      char **p;
2778      int i;
2779 {
2780   return p[i];
2781 }
2782 static char *f (char * (*g) (char **, int), char **p, ...)
2783 {
2784   char *s;
2785   va_list v;
2786   va_start (v,p);
2787   s = g (p, va_arg (v,int));
2788   va_end (v);
2789   return s;
2790 }
2791
2792 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2793    function prototypes and stuff, but not '\xHH' hex character constants.
2794    These don't provoke an error unfortunately, instead are silently treated
2795    as 'x'.  The following induces an error, until -std1 is added to get
2796    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2797    array size at least.  It's necessary to write '\x00'==0 to get something
2798    that's true only with -std1.  */
2799 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2800
2801 int test (int i, double x);
2802 struct s1 {int (*f) (int a);};
2803 struct s2 {int (*f) (double a);};
2804 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2805 int argc;
2806 char **argv;
2807 int
2808 main ()
2809 {
2810 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2811   ;
2812   return 0;
2813 }
2814 _ACEOF
2815 # Don't try gcc -ansi; that turns off useful extensions and
2816 # breaks some systems' header files.
2817 # AIX                   -qlanglvl=ansi
2818 # Ultrix and OSF/1      -std1
2819 # HP-UX 10.20 and later -Ae
2820 # HP-UX older versions  -Aa -D_HPUX_SOURCE
2821 # SVR4                  -Xc -D__EXTENSIONS__
2822 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2823 do
2824   CC="$ac_save_CC $ac_arg"
2825   rm -f conftest.$ac_objext
2826 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2827   (eval $ac_compile) 2>conftest.er1
2828   ac_status=$?
2829   grep -v '^ *+' conftest.er1 >conftest.err
2830   rm -f conftest.er1
2831   cat conftest.err >&5
2832   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2833   (exit $ac_status); } &&
2834          { ac_try='test -z "$ac_c_werror_flag"
2835                          || test ! -s conftest.err'
2836   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2837   (eval $ac_try) 2>&5
2838   ac_status=$?
2839   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2840   (exit $ac_status); }; } &&
2841          { ac_try='test -s conftest.$ac_objext'
2842   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2843   (eval $ac_try) 2>&5
2844   ac_status=$?
2845   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2846   (exit $ac_status); }; }; then
2847   ac_cv_prog_cc_stdc=$ac_arg
2848 break
2849 else
2850   echo "$as_me: failed program was:" >&5
2851 sed 's/^/| /' conftest.$ac_ext >&5
2852
2853 fi
2854 rm -f conftest.err conftest.$ac_objext
2855 done
2856 rm -f conftest.$ac_ext conftest.$ac_objext
2857 CC=$ac_save_CC
2858
2859 fi
2860
2861 case "x$ac_cv_prog_cc_stdc" in
2862   x|xno)
2863     echo "$as_me:$LINENO: result: none needed" >&5
2864 echo "${ECHO_T}none needed" >&6 ;;
2865   *)
2866     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2867 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2868     CC="$CC $ac_cv_prog_cc_stdc" ;;
2869 esac
2870
2871 # Some people use a C++ compiler to compile C.  Since we use `exit',
2872 # in C++ we need to declare it.  In case someone uses the same compiler
2873 # for both compiling C and C++ we need to have the C++ compiler decide
2874 # the declaration of exit, since it's the most demanding environment.
2875 cat >conftest.$ac_ext <<_ACEOF
2876 #ifndef __cplusplus
2877   choke me
2878 #endif
2879 _ACEOF
2880 rm -f conftest.$ac_objext
2881 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2882   (eval $ac_compile) 2>conftest.er1
2883   ac_status=$?
2884   grep -v '^ *+' conftest.er1 >conftest.err
2885   rm -f conftest.er1
2886   cat conftest.err >&5
2887   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2888   (exit $ac_status); } &&
2889          { ac_try='test -z "$ac_c_werror_flag"
2890                          || test ! -s conftest.err'
2891   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2892   (eval $ac_try) 2>&5
2893   ac_status=$?
2894   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2895   (exit $ac_status); }; } &&
2896          { ac_try='test -s conftest.$ac_objext'
2897   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2898   (eval $ac_try) 2>&5
2899   ac_status=$?
2900   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2901   (exit $ac_status); }; }; then
2902   for ac_declaration in \
2903    '' \
2904    'extern "C" void std::exit (int) throw (); using std::exit;' \
2905    'extern "C" void std::exit (int); using std::exit;' \
2906    'extern "C" void exit (int) throw ();' \
2907    'extern "C" void exit (int);' \
2908    'void exit (int);'
2909 do
2910   cat >conftest.$ac_ext <<_ACEOF
2911 /* confdefs.h.  */
2912 _ACEOF
2913 cat confdefs.h >>conftest.$ac_ext
2914 cat >>conftest.$ac_ext <<_ACEOF
2915 /* end confdefs.h.  */
2916 $ac_declaration
2917 #include <stdlib.h>
2918 int
2919 main ()
2920 {
2921 exit (42);
2922   ;
2923   return 0;
2924 }
2925 _ACEOF
2926 rm -f conftest.$ac_objext
2927 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2928   (eval $ac_compile) 2>conftest.er1
2929   ac_status=$?
2930   grep -v '^ *+' conftest.er1 >conftest.err
2931   rm -f conftest.er1
2932   cat conftest.err >&5
2933   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2934   (exit $ac_status); } &&
2935          { ac_try='test -z "$ac_c_werror_flag"
2936                          || test ! -s conftest.err'
2937   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2938   (eval $ac_try) 2>&5
2939   ac_status=$?
2940   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2941   (exit $ac_status); }; } &&
2942          { ac_try='test -s conftest.$ac_objext'
2943   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2944   (eval $ac_try) 2>&5
2945   ac_status=$?
2946   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2947   (exit $ac_status); }; }; then
2948   :
2949 else
2950   echo "$as_me: failed program was:" >&5
2951 sed 's/^/| /' conftest.$ac_ext >&5
2952
2953 continue
2954 fi
2955 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2956   cat >conftest.$ac_ext <<_ACEOF
2957 /* confdefs.h.  */
2958 _ACEOF
2959 cat confdefs.h >>conftest.$ac_ext
2960 cat >>conftest.$ac_ext <<_ACEOF
2961 /* end confdefs.h.  */
2962 $ac_declaration
2963 int
2964 main ()
2965 {
2966 exit (42);
2967   ;
2968   return 0;
2969 }
2970 _ACEOF
2971 rm -f conftest.$ac_objext
2972 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2973   (eval $ac_compile) 2>conftest.er1
2974   ac_status=$?
2975   grep -v '^ *+' conftest.er1 >conftest.err
2976   rm -f conftest.er1
2977   cat conftest.err >&5
2978   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2979   (exit $ac_status); } &&
2980          { ac_try='test -z "$ac_c_werror_flag"
2981                          || test ! -s conftest.err'
2982   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2983   (eval $ac_try) 2>&5
2984   ac_status=$?
2985   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2986   (exit $ac_status); }; } &&
2987          { ac_try='test -s conftest.$ac_objext'
2988   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2989   (eval $ac_try) 2>&5
2990   ac_status=$?
2991   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2992   (exit $ac_status); }; }; then
2993   break
2994 else
2995   echo "$as_me: failed program was:" >&5
2996 sed 's/^/| /' conftest.$ac_ext >&5
2997
2998 fi
2999 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3000 done
3001 rm -f conftest*
3002 if test -n "$ac_declaration"; then
3003   echo '#ifdef __cplusplus' >>confdefs.h
3004   echo $ac_declaration      >>confdefs.h
3005   echo '#endif'             >>confdefs.h
3006 fi
3007
3008 else
3009   echo "$as_me: failed program was:" >&5
3010 sed 's/^/| /' conftest.$ac_ext >&5
3011
3012 fi
3013 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3014 ac_ext=c
3015 ac_cpp='$CPP $CPPFLAGS'
3016 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3017 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3018 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3019 DEPDIR="${am__leading_dot}deps"
3020
3021           ac_config_commands="$ac_config_commands depfiles"
3022
3023
3024 am_make=${MAKE-make}
3025 cat > confinc << 'END'
3026 am__doit:
3027         @echo done
3028 .PHONY: am__doit
3029 END
3030 # If we don't find an include directive, just comment out the code.
3031 echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
3032 echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6
3033 am__include="#"
3034 am__quote=
3035 _am_result=none
3036 # First try GNU make style include.
3037 echo "include confinc" > confmf
3038 # We grep out `Entering directory' and `Leaving directory'
3039 # messages which can occur if `w' ends up in MAKEFLAGS.
3040 # In particular we don't look at `^make:' because GNU make might
3041 # be invoked under some other name (usually "gmake"), in which
3042 # case it prints its new name instead of `make'.
3043 if test "`$am_make -s -f confmf 2> /dev/null | grep -v 'ing directory'`" = "done"; then
3044    am__include=include
3045    am__quote=
3046    _am_result=GNU
3047 fi
3048 # Now try BSD make style include.
3049 if test "$am__include" = "#"; then
3050    echo '.include "confinc"' > confmf
3051    if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then
3052       am__include=.include
3053       am__quote="\""
3054       _am_result=BSD
3055    fi
3056 fi
3057
3058
3059 echo "$as_me:$LINENO: result: $_am_result" >&5
3060 echo "${ECHO_T}$_am_result" >&6
3061 rm -f confinc confmf
3062
3063 # Check whether --enable-dependency-tracking or --disable-dependency-tracking was given.
3064 if test "${enable_dependency_tracking+set}" = set; then
3065   enableval="$enable_dependency_tracking"
3066
3067 fi;
3068 if test "x$enable_dependency_tracking" != xno; then
3069   am_depcomp="$ac_aux_dir/depcomp"
3070   AMDEPBACKSLASH='\'
3071 fi
3072
3073
3074 if test "x$enable_dependency_tracking" != xno; then
3075   AMDEP_TRUE=
3076   AMDEP_FALSE='#'
3077 else
3078   AMDEP_TRUE='#'
3079   AMDEP_FALSE=
3080 fi
3081
3082
3083
3084
3085 depcc="$CC"   am_compiler_list=
3086
3087 echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
3088 echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6
3089 if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then
3090   echo $ECHO_N "(cached) $ECHO_C" >&6
3091 else
3092   if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
3093   # We make a subdir and do the tests there.  Otherwise we can end up
3094   # making bogus files that we don't know about and never remove.  For
3095   # instance it was reported that on HP-UX the gcc test will end up
3096   # making a dummy file named `D' -- because `-MD' means `put the output
3097   # in D'.
3098   mkdir conftest.dir
3099   # Copy depcomp to subdir because otherwise we won't find it if we're
3100   # using a relative directory.
3101   cp "$am_depcomp" conftest.dir
3102   cd conftest.dir
3103   # We will build objects and dependencies in a subdirectory because
3104   # it helps to detect inapplicable dependency modes.  For instance
3105   # both Tru64's cc and ICC support -MD to output dependencies as a
3106   # side effect of compilation, but ICC will put the dependencies in
3107   # the current directory while Tru64 will put them in the object
3108   # directory.
3109   mkdir sub
3110
3111   am_cv_CC_dependencies_compiler_type=none
3112   if test "$am_compiler_list" = ""; then
3113      am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
3114   fi
3115   for depmode in $am_compiler_list; do
3116     # Setup a source with many dependencies, because some compilers
3117     # like to wrap large dependency lists on column 80 (with \), and
3118     # we should not choose a depcomp mode which is confused by this.
3119     #
3120     # We need to recreate these files for each test, as the compiler may
3121     # overwrite some of them when testing with obscure command lines.
3122     # This happens at least with the AIX C compiler.
3123     : > sub/conftest.c
3124     for i in 1 2 3 4 5 6; do
3125       echo '#include "conftst'$i'.h"' >> sub/conftest.c
3126       # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
3127       # Solaris 8's {/usr,}/bin/sh.
3128       touch sub/conftst$i.h
3129     done
3130     echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
3131
3132     case $depmode in
3133     nosideeffect)
3134       # after this tag, mechanisms are not by side-effect, so they'll
3135       # only be used when explicitly requested
3136       if test "x$enable_dependency_tracking" = xyes; then
3137         continue
3138       else
3139         break
3140       fi
3141       ;;
3142     none) break ;;
3143     esac
3144     # We check with `-c' and `-o' for the sake of the "dashmstdout"
3145     # mode.  It turns out that the SunPro C++ compiler does not properly
3146     # handle `-M -o', and we need to detect this.
3147     if depmode=$depmode \
3148        source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \
3149        depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
3150        $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \
3151          >/dev/null 2>conftest.err &&
3152        grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
3153        grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&
3154        ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
3155       # icc doesn't choke on unknown options, it will just issue warnings
3156       # or remarks (even with -Werror).  So we grep stderr for any message
3157       # that says an option was ignored or not supported.
3158       # When given -MP, icc 7.0 and 7.1 complain thusly:
3159       #   icc: Command line warning: ignoring option '-M'; no argument required
3160       # The diagnosis changed in icc 8.0:
3161       #   icc: Command line remark: option '-MP' not supported
3162       if (grep 'ignoring option' conftest.err ||
3163           grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
3164         am_cv_CC_dependencies_compiler_type=$depmode
3165         break
3166       fi
3167     fi
3168   done
3169
3170   cd ..
3171   rm -rf conftest.dir
3172 else
3173   am_cv_CC_dependencies_compiler_type=none
3174 fi
3175
3176 fi
3177 echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5
3178 echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6
3179 CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
3180
3181
3182
3183 if
3184   test "x$enable_dependency_tracking" != xno \
3185   && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
3186   am__fastdepCC_TRUE=
3187   am__fastdepCC_FALSE='#'
3188 else
3189   am__fastdepCC_TRUE='#'
3190   am__fastdepCC_FALSE=
3191 fi
3192
3193
3194
3195
3196 # Add -Wall -fno-repack-arrays -fno-underscoring if we are using GCC.
3197 if test "x$GCC" = "xyes"; then
3198   AM_FCFLAGS="-I . -Wall -fno-repack-arrays -fno-underscoring"
3199   ## We like to use C99 routines when available.  This makes sure that
3200   ## __STDC_VERSION__ is set such that libc includes make them available.
3201   AM_CFLAGS="-std=gnu99 -Wall -Wstrict-prototypes -Wmissing-prototypes -Wold-style-definition -Wextra -Wwrite-strings"
3202   ## Compile the following tests with the same system header contents
3203   ## that we'll encounter when compiling our own source files.
3204   CFLAGS="-std=gnu99 $CFLAGS"
3205 fi
3206
3207
3208
3209 # Find other programs we need.
3210 if test -n "$ac_tool_prefix"; then
3211   # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
3212 set dummy ${ac_tool_prefix}as; ac_word=$2
3213 echo "$as_me:$LINENO: checking for $ac_word" >&5
3214 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3215 if test "${ac_cv_prog_AS+set}" = set; then
3216   echo $ECHO_N "(cached) $ECHO_C" >&6
3217 else
3218   if test -n "$AS"; then
3219   ac_cv_prog_AS="$AS" # Let the user override the test.
3220 else
3221 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3222 for as_dir in $PATH
3223 do
3224   IFS=$as_save_IFS
3225   test -z "$as_dir" && as_dir=.
3226   for ac_exec_ext in '' $ac_executable_extensions; do
3227   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3228     ac_cv_prog_AS="${ac_tool_prefix}as"
3229     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3230     break 2
3231   fi
3232 done
3233 done
3234
3235 fi
3236 fi
3237 AS=$ac_cv_prog_AS
3238 if test -n "$AS"; then
3239   echo "$as_me:$LINENO: result: $AS" >&5
3240 echo "${ECHO_T}$AS" >&6
3241 else
3242   echo "$as_me:$LINENO: result: no" >&5
3243 echo "${ECHO_T}no" >&6
3244 fi
3245
3246 fi
3247 if test -z "$ac_cv_prog_AS"; then
3248   ac_ct_AS=$AS
3249   # Extract the first word of "as", so it can be a program name with args.
3250 set dummy as; ac_word=$2
3251 echo "$as_me:$LINENO: checking for $ac_word" >&5
3252 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3253 if test "${ac_cv_prog_ac_ct_AS+set}" = set; then
3254   echo $ECHO_N "(cached) $ECHO_C" >&6
3255 else
3256   if test -n "$ac_ct_AS"; then
3257   ac_cv_prog_ac_ct_AS="$ac_ct_AS" # Let the user override the test.
3258 else
3259 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3260 for as_dir in $PATH
3261 do
3262   IFS=$as_save_IFS
3263   test -z "$as_dir" && as_dir=.
3264   for ac_exec_ext in '' $ac_executable_extensions; do
3265   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3266     ac_cv_prog_ac_ct_AS="as"
3267     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3268     break 2
3269   fi
3270 done
3271 done
3272
3273 fi
3274 fi
3275 ac_ct_AS=$ac_cv_prog_ac_ct_AS
3276 if test -n "$ac_ct_AS"; then
3277   echo "$as_me:$LINENO: result: $ac_ct_AS" >&5
3278 echo "${ECHO_T}$ac_ct_AS" >&6
3279 else
3280   echo "$as_me:$LINENO: result: no" >&5
3281 echo "${ECHO_T}no" >&6
3282 fi
3283
3284   AS=$ac_ct_AS
3285 else
3286   AS="$ac_cv_prog_AS"
3287 fi
3288
3289 if test -n "$ac_tool_prefix"; then
3290   # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
3291 set dummy ${ac_tool_prefix}ar; ac_word=$2
3292 echo "$as_me:$LINENO: checking for $ac_word" >&5
3293 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3294 if test "${ac_cv_prog_AR+set}" = set; then
3295   echo $ECHO_N "(cached) $ECHO_C" >&6
3296 else
3297   if test -n "$AR"; then
3298   ac_cv_prog_AR="$AR" # Let the user override the test.
3299 else
3300 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3301 for as_dir in $PATH
3302 do
3303   IFS=$as_save_IFS
3304   test -z "$as_dir" && as_dir=.
3305   for ac_exec_ext in '' $ac_executable_extensions; do
3306   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3307     ac_cv_prog_AR="${ac_tool_prefix}ar"
3308     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3309     break 2
3310   fi
3311 done
3312 done
3313
3314 fi
3315 fi
3316 AR=$ac_cv_prog_AR
3317 if test -n "$AR"; then
3318   echo "$as_me:$LINENO: result: $AR" >&5
3319 echo "${ECHO_T}$AR" >&6
3320 else
3321   echo "$as_me:$LINENO: result: no" >&5
3322 echo "${ECHO_T}no" >&6
3323 fi
3324
3325 fi
3326 if test -z "$ac_cv_prog_AR"; then
3327   ac_ct_AR=$AR
3328   # Extract the first word of "ar", so it can be a program name with args.
3329 set dummy ar; ac_word=$2
3330 echo "$as_me:$LINENO: checking for $ac_word" >&5
3331 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3332 if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
3333   echo $ECHO_N "(cached) $ECHO_C" >&6
3334 else
3335   if test -n "$ac_ct_AR"; then
3336   ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
3337 else
3338 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3339 for as_dir in $PATH
3340 do
3341   IFS=$as_save_IFS
3342   test -z "$as_dir" && as_dir=.
3343   for ac_exec_ext in '' $ac_executable_extensions; do
3344   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3345     ac_cv_prog_ac_ct_AR="ar"
3346     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3347     break 2
3348   fi
3349 done
3350 done
3351
3352 fi
3353 fi
3354 ac_ct_AR=$ac_cv_prog_ac_ct_AR
3355 if test -n "$ac_ct_AR"; then
3356   echo "$as_me:$LINENO: result: $ac_ct_AR" >&5
3357 echo "${ECHO_T}$ac_ct_AR" >&6
3358 else
3359   echo "$as_me:$LINENO: result: no" >&5
3360 echo "${ECHO_T}no" >&6
3361 fi
3362
3363   AR=$ac_ct_AR
3364 else
3365   AR="$ac_cv_prog_AR"
3366 fi
3367
3368 if test -n "$ac_tool_prefix"; then
3369   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3370 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3371 echo "$as_me:$LINENO: checking for $ac_word" >&5
3372 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3373 if test "${ac_cv_prog_RANLIB+set}" = set; then
3374   echo $ECHO_N "(cached) $ECHO_C" >&6
3375 else
3376   if test -n "$RANLIB"; then
3377   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3378 else
3379 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3380 for as_dir in $PATH
3381 do
3382   IFS=$as_save_IFS
3383   test -z "$as_dir" && as_dir=.
3384   for ac_exec_ext in '' $ac_executable_extensions; do
3385   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3386     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3387     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3388     break 2
3389   fi
3390 done
3391 done
3392
3393 fi
3394 fi
3395 RANLIB=$ac_cv_prog_RANLIB
3396 if test -n "$RANLIB"; then
3397   echo "$as_me:$LINENO: result: $RANLIB" >&5
3398 echo "${ECHO_T}$RANLIB" >&6
3399 else
3400   echo "$as_me:$LINENO: result: no" >&5
3401 echo "${ECHO_T}no" >&6
3402 fi
3403
3404 fi
3405 if test -z "$ac_cv_prog_RANLIB"; then
3406   ac_ct_RANLIB=$RANLIB
3407   # Extract the first word of "ranlib", so it can be a program name with args.
3408 set dummy ranlib; ac_word=$2
3409 echo "$as_me:$LINENO: checking for $ac_word" >&5
3410 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3411 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3412   echo $ECHO_N "(cached) $ECHO_C" >&6
3413 else
3414   if test -n "$ac_ct_RANLIB"; then
3415   ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3416 else
3417 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3418 for as_dir in $PATH
3419 do
3420   IFS=$as_save_IFS
3421   test -z "$as_dir" && as_dir=.
3422   for ac_exec_ext in '' $ac_executable_extensions; do
3423   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3424     ac_cv_prog_ac_ct_RANLIB="ranlib"
3425     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3426     break 2
3427   fi
3428 done
3429 done
3430
3431   test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB="ranlib-not-found-in-path-error"
3432 fi
3433 fi
3434 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3435 if test -n "$ac_ct_RANLIB"; then
3436   echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3437 echo "${ECHO_T}$ac_ct_RANLIB" >&6
3438 else
3439   echo "$as_me:$LINENO: result: no" >&5
3440 echo "${ECHO_T}no" >&6
3441 fi
3442
3443   RANLIB=$ac_ct_RANLIB
3444 else
3445   RANLIB="$ac_cv_prog_RANLIB"
3446 fi
3447
3448 echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3449 echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3450 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3451 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3452   echo $ECHO_N "(cached) $ECHO_C" >&6
3453 else
3454   cat >conftest.make <<\_ACEOF
3455 all:
3456         @echo 'ac_maketemp="$(MAKE)"'
3457 _ACEOF
3458 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3459 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3460 if test -n "$ac_maketemp"; then
3461   eval ac_cv_prog_make_${ac_make}_set=yes
3462 else
3463   eval ac_cv_prog_make_${ac_make}_set=no
3464 fi
3465 rm -f conftest.make
3466 fi
3467 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3468   echo "$as_me:$LINENO: result: yes" >&5
3469 echo "${ECHO_T}yes" >&6
3470   SET_MAKE=
3471 else
3472   echo "$as_me:$LINENO: result: no" >&5
3473 echo "${ECHO_T}no" >&6
3474   SET_MAKE="MAKE=${MAKE-make}"
3475 fi
3476
3477 # Find a good install program.  We prefer a C program (faster),
3478 # so one script is as good as another.  But avoid the broken or
3479 # incompatible versions:
3480 # SysV /etc/install, /usr/sbin/install
3481 # SunOS /usr/etc/install
3482 # IRIX /sbin/install
3483 # AIX /bin/install
3484 # AmigaOS /C/install, which installs bootblocks on floppy discs
3485 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3486 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3487 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3488 # OS/2's system install, which has a completely different semantic
3489 # ./install, which can be erroneously created by make from ./install.sh.
3490 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3491 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3492 if test -z "$INSTALL"; then
3493 if test "${ac_cv_path_install+set}" = set; then
3494   echo $ECHO_N "(cached) $ECHO_C" >&6
3495 else
3496   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3497 for as_dir in $PATH
3498 do
3499   IFS=$as_save_IFS
3500   test -z "$as_dir" && as_dir=.
3501   # Account for people who put trailing slashes in PATH elements.
3502 case $as_dir/ in
3503   ./ | .// | /cC/* | \
3504   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3505   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3506   /usr/ucb/* ) ;;
3507   *)
3508     # OSF1 and SCO ODT 3.0 have their own names for install.
3509     # Don't use installbsd from OSF since it installs stuff as root
3510     # by default.
3511     for ac_prog in ginstall scoinst install; do
3512       for ac_exec_ext in '' $ac_executable_extensions; do
3513         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3514           if test $ac_prog = install &&
3515             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3516             # AIX install.  It has an incompatible calling convention.
3517             :
3518           elif test $ac_prog = install &&
3519             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3520             # program-specific install script used by HP pwplus--don't use.
3521             :
3522           else
3523             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3524             break 3
3525           fi
3526         fi
3527       done
3528     done
3529     ;;
3530 esac
3531 done
3532
3533
3534 fi
3535   if test "${ac_cv_path_install+set}" = set; then
3536     INSTALL=$ac_cv_path_install
3537   else
3538     # As a last resort, use the slow shell script.  We don't cache a
3539     # path for INSTALL within a source directory, because that will
3540     # break other packages using the cache if that directory is
3541     # removed, or if the path is relative.
3542     INSTALL=$ac_install_sh
3543   fi
3544 fi
3545 echo "$as_me:$LINENO: result: $INSTALL" >&5
3546 echo "${ECHO_T}$INSTALL" >&6
3547
3548 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3549 # It thinks the first close brace ends the variable substitution.
3550 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3551
3552 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3553
3554 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3555
3556
3557 # Configure libtool
3558 #AC_MSG_NOTICE([====== Starting libtool configuration])
3559
3560 # Check whether --enable-shared or --disable-shared was given.
3561 if test "${enable_shared+set}" = set; then
3562   enableval="$enable_shared"
3563   p=${PACKAGE-default}
3564 case $enableval in
3565 yes) enable_shared=yes ;;
3566 no) enable_shared=no ;;
3567 *)
3568   enable_shared=no
3569   # Look at the argument we got.  We use all the common list separators.
3570   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3571   for pkg in $enableval; do
3572     if test "X$pkg" = "X$p"; then
3573       enable_shared=yes
3574     fi
3575   done
3576   IFS="$ac_save_ifs"
3577   ;;
3578 esac
3579 else
3580   enable_shared=yes
3581 fi;
3582 # Check whether --enable-static or --disable-static was given.
3583 if test "${enable_static+set}" = set; then
3584   enableval="$enable_static"
3585   p=${PACKAGE-default}
3586 case $enableval in
3587 yes) enable_static=yes ;;
3588 no) enable_static=no ;;
3589 *)
3590   enable_static=no
3591   # Look at the argument we got.  We use all the common list separators.
3592   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3593   for pkg in $enableval; do
3594     if test "X$pkg" = "X$p"; then
3595       enable_static=yes
3596     fi
3597   done
3598   IFS="$ac_save_ifs"
3599   ;;
3600 esac
3601 else
3602   enable_static=yes
3603 fi;
3604 # Check whether --enable-fast-install or --disable-fast-install was given.
3605 if test "${enable_fast_install+set}" = set; then
3606   enableval="$enable_fast_install"
3607   p=${PACKAGE-default}
3608 case $enableval in
3609 yes) enable_fast_install=yes ;;
3610 no) enable_fast_install=no ;;
3611 *)
3612   enable_fast_install=no
3613   # Look at the argument we got.  We use all the common list separators.
3614   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3615   for pkg in $enableval; do
3616     if test "X$pkg" = "X$p"; then
3617       enable_fast_install=yes
3618     fi
3619   done
3620   IFS="$ac_save_ifs"
3621   ;;
3622 esac
3623 else
3624   enable_fast_install=yes
3625 fi;
3626
3627 # Check whether --with-gnu-ld or --without-gnu-ld was given.
3628 if test "${with_gnu_ld+set}" = set; then
3629   withval="$with_gnu_ld"
3630   test "$withval" = no || with_gnu_ld=yes
3631 else
3632   with_gnu_ld=no
3633 fi;
3634 ac_prog=ld
3635 if test "$GCC" = yes; then
3636   # Check if gcc -print-prog-name=ld gives a path.
3637   echo "$as_me:$LINENO: checking for ld used by GCC" >&5
3638 echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6
3639   case $host in
3640   *-*-mingw*)
3641     # gcc leaves a trailing carriage return which upsets mingw
3642     ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
3643   *)
3644     ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
3645   esac
3646   case $ac_prog in
3647     # Accept absolute paths.
3648     [\\/]* | [A-Za-z]:[\\/]*)
3649       re_direlt='/[^/][^/]*/\.\./'
3650       # Canonicalize the path of ld
3651       ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
3652       while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
3653         ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
3654       done
3655       test -z "$LD" && LD="$ac_prog"
3656       ;;
3657   "")
3658     # If it fails, then pretend we aren't using GCC.
3659     ac_prog=ld
3660     ;;
3661   *)
3662     # If it is relative, then search for the first ld in PATH.
3663     with_gnu_ld=unknown
3664     ;;
3665   esac
3666 elif test "$with_gnu_ld" = yes; then
3667   echo "$as_me:$LINENO: checking for GNU ld" >&5
3668 echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6
3669 else
3670   echo "$as_me:$LINENO: checking for non-GNU ld" >&5
3671 echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6
3672 fi
3673 if test "${lt_cv_path_LD+set}" = set; then
3674   echo $ECHO_N "(cached) $ECHO_C" >&6
3675 else
3676   if test -z "$LD"; then
3677   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
3678   for ac_dir in $PATH; do
3679     test -z "$ac_dir" && ac_dir=.
3680     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
3681       lt_cv_path_LD="$ac_dir/$ac_prog"
3682       # Check to see if the program is GNU ld.  I'd rather use --version,
3683       # but apparently some GNU ld's only accept -v.
3684       # Break only if it was the GNU/non-GNU ld that we prefer.
3685       if "$lt_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
3686         test "$with_gnu_ld" != no && break
3687       else
3688         test "$with_gnu_ld" != yes && break
3689       fi
3690     fi
3691   done
3692   IFS="$ac_save_ifs"
3693 else
3694   lt_cv_path_LD="$LD" # Let the user override the test with a path.
3695 fi
3696 fi
3697
3698 LD="$lt_cv_path_LD"
3699 if test -n "$LD"; then
3700   echo "$as_me:$LINENO: result: $LD" >&5
3701 echo "${ECHO_T}$LD" >&6
3702 else
3703   echo "$as_me:$LINENO: result: no" >&5
3704 echo "${ECHO_T}no" >&6
3705 fi
3706 test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5
3707 echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}
3708    { (exit 1); exit 1; }; }
3709 echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
3710 echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6
3711 if test "${lt_cv_prog_gnu_ld+set}" = set; then
3712   echo $ECHO_N "(cached) $ECHO_C" >&6
3713 else
3714   # I'd rather use --version here, but apparently some GNU ld's only accept -v.
3715 if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
3716   lt_cv_prog_gnu_ld=yes
3717 else
3718   lt_cv_prog_gnu_ld=no
3719 fi
3720 fi
3721 echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
3722 echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6
3723 with_gnu_ld=$lt_cv_prog_gnu_ld
3724
3725
3726 echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
3727 echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6
3728 if test "${lt_cv_ld_reload_flag+set}" = set; then
3729   echo $ECHO_N "(cached) $ECHO_C" >&6
3730 else
3731   lt_cv_ld_reload_flag='-r'
3732 fi
3733 echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
3734 echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6
3735 reload_flag=$lt_cv_ld_reload_flag
3736 test -n "$reload_flag" && reload_flag=" $reload_flag"
3737
3738 echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
3739 echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6
3740 if test "${lt_cv_path_NM+set}" = set; then
3741   echo $ECHO_N "(cached) $ECHO_C" >&6
3742 else
3743   if test -n "$NM"; then
3744   # Let the user override the test.
3745   lt_cv_path_NM="$NM"
3746 else
3747   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
3748   for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
3749     test -z "$ac_dir" && ac_dir=.
3750     tmp_nm=$ac_dir/${ac_tool_prefix}nm
3751     if test -f $tmp_nm || test -f $tmp_nm$ac_exeext ; then
3752       # Check to see if the nm accepts a BSD-compat flag.
3753       # Adding the `sed 1q' prevents false positives on HP-UX, which says:
3754       #   nm: unknown option "B" ignored
3755       # Tru64's nm complains that /dev/null is an invalid object file
3756       if ($tmp_nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep '(/dev/null|Invalid file or object type)' >/dev/null; then
3757         lt_cv_path_NM="$tmp_nm -B"
3758         break
3759       elif ($tmp_nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
3760         lt_cv_path_NM="$tmp_nm -p"
3761         break
3762       else
3763         lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
3764         continue # so that we can try to find one that supports BSD flags
3765       fi
3766     fi
3767   done
3768   IFS="$ac_save_ifs"
3769   test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm
3770 fi
3771 fi
3772
3773 NM="$lt_cv_path_NM"
3774 echo "$as_me:$LINENO: result: $NM" >&5
3775 echo "${ECHO_T}$NM" >&6
3776
3777 echo "$as_me:$LINENO: checking whether ln -s works" >&5
3778 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3779 LN_S=$as_ln_s
3780 if test "$LN_S" = "ln -s"; then
3781   echo "$as_me:$LINENO: result: yes" >&5
3782 echo "${ECHO_T}yes" >&6
3783 else
3784   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3785 echo "${ECHO_T}no, using $LN_S" >&6
3786 fi
3787
3788 echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5
3789 echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6
3790 if test "${lt_cv_deplibs_check_method+set}" = set; then
3791   echo $ECHO_N "(cached) $ECHO_C" >&6
3792 else
3793   lt_cv_file_magic_cmd='$MAGIC_CMD'
3794 lt_cv_file_magic_test_file=
3795 lt_cv_deplibs_check_method='unknown'
3796 # Need to set the preceding variable on all platforms that support
3797 # interlibrary dependencies.
3798 # 'none' -- dependencies not supported.
3799 # `unknown' -- same as none, but documents that we really don't know.
3800 # 'pass_all' -- all dependencies passed with no checks.
3801 # 'test_compile' -- check by making test program.
3802 # 'file_magic [regex]' -- check by looking for files in library path
3803 # which responds to the $file_magic_cmd with a given egrep regex.
3804 # If you have `file' or equivalent on your system and you're not sure
3805 # whether `pass_all' will *always* work, you probably want this one.
3806
3807 case $host_os in
3808 aix*)
3809   lt_cv_deplibs_check_method=pass_all
3810   ;;
3811
3812 beos*)
3813   lt_cv_deplibs_check_method=pass_all
3814   ;;
3815
3816 bsdi4*)
3817   lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
3818   lt_cv_file_magic_cmd='/usr/bin/file -L'
3819   lt_cv_file_magic_test_file=/shlib/libc.so
3820   ;;
3821
3822 cygwin* | mingw* |pw32*)
3823   lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
3824   lt_cv_file_magic_cmd='$OBJDUMP -f'
3825   ;;
3826
3827 darwin* | rhapsody*)
3828   # this will be overwritten by pass_all, but leave it in just in case
3829   lt_cv_deplibs_check_method='file_magic Mach-O dynamically linked shared library'
3830   lt_cv_file_magic_cmd='/usr/bin/file -L'
3831   case "$host_os" in
3832   rhapsody* | darwin1.012)
3833     lt_cv_file_magic_test_file='/System/Library/Frameworks/System.framework/System'
3834     ;;
3835   *) # Darwin 1.3 on
3836     lt_cv_file_magic_test_file='/usr/lib/libSystem.dylib'
3837     ;;
3838   esac
3839   lt_cv_deplibs_check_method=pass_all
3840   ;;
3841
3842 freebsd* | kfreebsd*-gnu)
3843   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
3844     case $host_cpu in
3845     i*86 )
3846       # Not sure whether the presence of OpenBSD here was a mistake.
3847       # Let's accept both of them until this is cleared up.
3848       lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[3-9]86 (compact )?demand paged shared library'
3849       lt_cv_file_magic_cmd=/usr/bin/file
3850       lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
3851       ;;
3852     esac
3853   else
3854     lt_cv_deplibs_check_method=pass_all
3855   fi
3856   ;;
3857
3858 gnu*)
3859   lt_cv_deplibs_check_method=pass_all
3860   ;;
3861
3862 hpux10.20*|hpux11*)
3863   case $host_cpu in
3864   hppa*)
3865     lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library'
3866     lt_cv_file_magic_cmd=/usr/bin/file
3867     lt_cv_file_magic_test_file=/usr/lib/libc.sl
3868     ;;
3869   ia64*)
3870     lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
3871     lt_cv_file_magic_cmd=/usr/bin/file
3872     lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
3873     ;;
3874   esac
3875   ;;
3876
3877 irix5* | irix6*)
3878   case $host_os in
3879   irix5*)
3880     # this will be overridden with pass_all, but let us keep it just in case
3881     lt_cv_deplibs_check_method="file_magic ELF 32-bit MSB dynamic lib MIPS - version 1"
3882     ;;
3883   *)
3884     case $LD in
3885     *-32|*"-32 ") libmagic=32-bit;;
3886     *-n32|*"-n32 ") libmagic=N32;;
3887     *-64|*"-64 ") libmagic=64-bit;;
3888     *) libmagic=never-match;;
3889     esac
3890     # this will be overridden with pass_all, but let us keep it just in case
3891     lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[1234] dynamic lib MIPS - version 1"
3892     ;;
3893   esac
3894   lt_cv_file_magic_test_file=`echo /lib${libsuff}/libc.so*`
3895   lt_cv_deplibs_check_method=pass_all
3896   ;;
3897
3898 # This must be Linux ELF.
3899 linux-gnu*)
3900   lt_cv_deplibs_check_method=pass_all
3901   ;;
3902
3903 netbsd* | knetbsd*-gnu)
3904   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
3905     lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so\.[0-9]+\.[0-9]+$'
3906   else
3907     lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so$'
3908   fi
3909   ;;
3910
3911 newsos6)
3912   lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'
3913   lt_cv_file_magic_cmd=/usr/bin/file
3914   lt_cv_file_magic_test_file=/usr/lib/libnls.so
3915   ;;
3916
3917 osf3* | osf4* | osf5*)
3918   # this will be overridden with pass_all, but let us keep it just in case
3919   lt_cv_deplibs_check_method='file_magic COFF format alpha shared library'
3920   lt_cv_file_magic_test_file=/shlib/libc.so
3921   lt_cv_deplibs_check_method=pass_all
3922   ;;
3923
3924 sco3.2v5*)
3925   lt_cv_deplibs_check_method=pass_all
3926   ;;
3927
3928 solaris*)
3929   lt_cv_deplibs_check_method=pass_all
3930   lt_cv_file_magic_test_file=/lib/libc.so
3931   ;;
3932
3933 sysv5uw[78]* | sysv4*uw2*)
3934   lt_cv_deplibs_check_method=pass_all
3935   ;;
3936
3937 sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
3938   case $host_vendor in
3939   ncr)
3940     lt_cv_deplibs_check_method=pass_all
3941     ;;
3942   motorola)
3943     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]'
3944     lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
3945     ;;
3946   esac
3947   ;;
3948 esac
3949
3950 fi
3951 echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
3952 echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6
3953 file_magic_cmd=$lt_cv_file_magic_cmd
3954 deplibs_check_method=$lt_cv_deplibs_check_method
3955
3956
3957
3958
3959
3960 # Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
3961
3962 # find the maximum length of command line arguments
3963 echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
3964 echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6
3965 if test "${lt_cv_sys_max_cmd_len+set}" = set; then
3966   echo $ECHO_N "(cached) $ECHO_C" >&6
3967 else
3968     i=0
3969   teststring="ABCD"
3970
3971   case $build_os in
3972   msdosdjgpp*)
3973     # On DJGPP, this test can blow up pretty badly due to problems in libc
3974     # (any single argument exceeding 2000 bytes causes a buffer overrun
3975     # during glob expansion).  Even if it were fixed, the result of this
3976     # check would be larger than it should be.
3977     lt_cv_sys_max_cmd_len=12288;    # 12K is about right
3978     ;;
3979
3980   cygwin* | mingw*)
3981     # On Win9x/ME, this test blows up -- it succeeds, but takes
3982     # about 5 minutes as the teststring grows exponentially.
3983     # Worse, since 9x/ME are not pre-emptively multitasking,
3984     # you end up with a "frozen" computer, even though with patience
3985     # the test eventually succeeds (with a max line length of 256k).
3986     # Instead, let's just punt: use the minimum linelength reported by
3987     # all of the supported platforms: 8192 (on NT/2K/XP).
3988     lt_cv_sys_max_cmd_len=8192;
3989     ;;
3990
3991   amigaos*)
3992     # On AmigaOS with pdksh, this test takes hours, literally.
3993     # So we just punt and use a minimum line length of 8192.
3994     lt_cv_sys_max_cmd_len=8192;
3995     ;;
3996
3997   netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
3998     # This has been around since 386BSD, at least.  Likely further.
3999     if test -x /sbin/sysctl; then
4000       lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
4001     elif test -x /usr/sbin/sysctl; then
4002       lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
4003     else
4004       lt_cv_sys_max_cmd_len=65536 # usable default for *BSD
4005     fi
4006     # And add a safety zone
4007     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
4008     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
4009     ;;
4010   esac
4011
4012 fi
4013
4014 if test -n "$lt_cv_sys_max_cmd_len" ; then
4015   echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
4016 echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6
4017 else
4018   echo "$as_me:$LINENO: result: none" >&5
4019 echo "${ECHO_T}none" >&6
4020 fi
4021
4022
4023 # Only perform the check for file, if the check method requires it
4024 case $deplibs_check_method in
4025 file_magic*)
4026   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
4027     echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
4028 echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6
4029 if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
4030   echo $ECHO_N "(cached) $ECHO_C" >&6
4031 else
4032   case $MAGIC_CMD in
4033   /*)
4034   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
4035   ;;
4036   ?:/*)
4037   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
4038   ;;
4039   *)
4040   ac_save_MAGIC_CMD="$MAGIC_CMD"
4041   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4042   ac_dummy="/usr/bin:$PATH"
4043   for ac_dir in $ac_dummy; do
4044     test -z "$ac_dir" && ac_dir=.
4045     if test -f $ac_dir/${ac_tool_prefix}file; then
4046       lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
4047       if test -n "$file_magic_test_file"; then
4048         case $deplibs_check_method in
4049         "file_magic "*)
4050           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
4051           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
4052           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
4053             egrep "$file_magic_regex" > /dev/null; then
4054             :
4055           else
4056             cat <<EOF 1>&2
4057
4058 *** Warning: the command libtool uses to detect shared libraries,
4059 *** $file_magic_cmd, produces output that libtool cannot recognize.
4060 *** The result is that libtool may fail to recognize shared libraries
4061 *** as such.  This will affect the creation of libtool libraries that
4062 *** depend on shared libraries, but programs linked with such libtool
4063 *** libraries will work regardless of this problem.  Nevertheless, you
4064 *** may want to report the problem to your system manager and/or to
4065 *** bug-libtool@gnu.org
4066
4067 EOF
4068           fi ;;
4069         esac
4070       fi
4071       break
4072     fi
4073   done
4074   IFS="$ac_save_ifs"
4075   MAGIC_CMD="$ac_save_MAGIC_CMD"
4076   ;;
4077 esac
4078 fi
4079
4080 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
4081 if test -n "$MAGIC_CMD"; then
4082   echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
4083 echo "${ECHO_T}$MAGIC_CMD" >&6
4084 else
4085   echo "$as_me:$LINENO: result: no" >&5
4086 echo "${ECHO_T}no" >&6
4087 fi
4088
4089 if test -z "$lt_cv_path_MAGIC_CMD"; then
4090   if test -n "$ac_tool_prefix"; then
4091     echo "$as_me:$LINENO: checking for file" >&5
4092 echo $ECHO_N "checking for file... $ECHO_C" >&6
4093 if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
4094   echo $ECHO_N "(cached) $ECHO_C" >&6
4095 else
4096   case $MAGIC_CMD in
4097   /*)
4098   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
4099   ;;
4100   ?:/*)
4101   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
4102   ;;
4103   *)
4104   ac_save_MAGIC_CMD="$MAGIC_CMD"
4105   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4106   ac_dummy="/usr/bin:$PATH"
4107   for ac_dir in $ac_dummy; do
4108     test -z "$ac_dir" && ac_dir=.
4109     if test -f $ac_dir/file; then
4110       lt_cv_path_MAGIC_CMD="$ac_dir/file"
4111       if test -n "$file_magic_test_file"; then
4112         case $deplibs_check_method in
4113         "file_magic "*)
4114           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
4115           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
4116           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
4117             egrep "$file_magic_regex" > /dev/null; then
4118             :
4119           else
4120             cat <<EOF 1>&2
4121
4122 *** Warning: the command libtool uses to detect shared libraries,
4123 *** $file_magic_cmd, produces output that libtool cannot recognize.
4124 *** The result is that libtool may fail to recognize shared libraries
4125 *** as such.  This will affect the creation of libtool libraries that
4126 *** depend on shared libraries, but programs linked with such libtool
4127 *** libraries will work regardless of this problem.  Nevertheless, you
4128 *** may want to report the problem to your system manager and/or to
4129 *** bug-libtool@gnu.org
4130
4131 EOF
4132           fi ;;
4133         esac
4134       fi
4135       break
4136     fi
4137   done
4138   IFS="$ac_save_ifs"
4139   MAGIC_CMD="$ac_save_MAGIC_CMD"
4140   ;;
4141 esac
4142 fi
4143
4144 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
4145 if test -n "$MAGIC_CMD"; then
4146   echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
4147 echo "${ECHO_T}$MAGIC_CMD" >&6
4148 else
4149   echo "$as_me:$LINENO: result: no" >&5
4150 echo "${ECHO_T}no" >&6
4151 fi
4152
4153   else
4154     MAGIC_CMD=:
4155   fi
4156 fi
4157
4158   fi
4159   ;;
4160 esac
4161
4162 if test -n "$ac_tool_prefix"; then
4163   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
4164 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
4165 echo "$as_me:$LINENO: checking for $ac_word" >&5
4166 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4167 if test "${ac_cv_prog_RANLIB+set}" = set; then
4168   echo $ECHO_N "(cached) $ECHO_C" >&6
4169 else
4170   if test -n "$RANLIB"; then
4171   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
4172 else
4173 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4174 for as_dir in $PATH
4175 do
4176   IFS=$as_save_IFS
4177   test -z "$as_dir" && as_dir=.
4178   for ac_exec_ext in '' $ac_executable_extensions; do
4179   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4180     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
4181     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4182     break 2
4183   fi
4184 done
4185 done
4186
4187 fi
4188 fi
4189 RANLIB=$ac_cv_prog_RANLIB
4190 if test -n "$RANLIB"; then
4191   echo "$as_me:$LINENO: result: $RANLIB" >&5
4192 echo "${ECHO_T}$RANLIB" >&6
4193 else
4194   echo "$as_me:$LINENO: result: no" >&5
4195 echo "${ECHO_T}no" >&6
4196 fi
4197
4198 fi
4199 if test -z "$ac_cv_prog_RANLIB"; then
4200   ac_ct_RANLIB=$RANLIB
4201   # Extract the first word of "ranlib", so it can be a program name with args.
4202 set dummy ranlib; ac_word=$2
4203 echo "$as_me:$LINENO: checking for $ac_word" >&5
4204 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4205 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
4206   echo $ECHO_N "(cached) $ECHO_C" >&6
4207 else
4208   if test -n "$ac_ct_RANLIB"; then
4209   ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
4210 else
4211 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4212 for as_dir in $PATH
4213 do
4214   IFS=$as_save_IFS
4215   test -z "$as_dir" && as_dir=.
4216   for ac_exec_ext in '' $ac_executable_extensions; do
4217   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4218     ac_cv_prog_ac_ct_RANLIB="ranlib"
4219     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4220     break 2
4221   fi
4222 done
4223 done
4224
4225   test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
4226 fi
4227 fi
4228 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
4229 if test -n "$ac_ct_RANLIB"; then
4230   echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
4231 echo "${ECHO_T}$ac_ct_RANLIB" >&6
4232 else
4233   echo "$as_me:$LINENO: result: no" >&5
4234 echo "${ECHO_T}no" >&6
4235 fi
4236
4237   RANLIB=$ac_ct_RANLIB
4238 else
4239   RANLIB="$ac_cv_prog_RANLIB"
4240 fi
4241
4242 if test -n "$ac_tool_prefix"; then
4243   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
4244 set dummy ${ac_tool_prefix}strip; ac_word=$2
4245 echo "$as_me:$LINENO: checking for $ac_word" >&5
4246 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4247 if test "${ac_cv_prog_STRIP+set}" = set; then
4248   echo $ECHO_N "(cached) $ECHO_C" >&6
4249 else
4250   if test -n "$STRIP"; then
4251   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
4252 else
4253 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4254 for as_dir in $PATH
4255 do
4256   IFS=$as_save_IFS
4257   test -z "$as_dir" && as_dir=.
4258   for ac_exec_ext in '' $ac_executable_extensions; do
4259   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4260     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
4261     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4262     break 2
4263   fi
4264 done
4265 done
4266
4267 fi
4268 fi
4269 STRIP=$ac_cv_prog_STRIP
4270 if test -n "$STRIP"; then
4271   echo "$as_me:$LINENO: result: $STRIP" >&5
4272 echo "${ECHO_T}$STRIP" >&6
4273 else
4274   echo "$as_me:$LINENO: result: no" >&5
4275 echo "${ECHO_T}no" >&6
4276 fi
4277
4278 fi
4279 if test -z "$ac_cv_prog_STRIP"; then
4280   ac_ct_STRIP=$STRIP
4281   # Extract the first word of "strip", so it can be a program name with args.
4282 set dummy strip; ac_word=$2
4283 echo "$as_me:$LINENO: checking for $ac_word" >&5
4284 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4285 if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
4286   echo $ECHO_N "(cached) $ECHO_C" >&6
4287 else
4288   if test -n "$ac_ct_STRIP"; then
4289   ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
4290 else
4291 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4292 for as_dir in $PATH
4293 do
4294   IFS=$as_save_IFS
4295   test -z "$as_dir" && as_dir=.
4296   for ac_exec_ext in '' $ac_executable_extensions; do
4297   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4298     ac_cv_prog_ac_ct_STRIP="strip"
4299     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4300     break 2
4301   fi
4302 done
4303 done
4304
4305   test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
4306 fi
4307 fi
4308 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
4309 if test -n "$ac_ct_STRIP"; then
4310   echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
4311 echo "${ECHO_T}$ac_ct_STRIP" >&6
4312 else
4313   echo "$as_me:$LINENO: result: no" >&5
4314 echo "${ECHO_T}no" >&6
4315 fi
4316
4317   STRIP=$ac_ct_STRIP
4318 else
4319   STRIP="$ac_cv_prog_STRIP"
4320 fi
4321
4322
4323 # Check for any special flags to pass to ltconfig.
4324 libtool_flags="--cache-file=$cache_file"
4325 test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
4326 test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
4327 test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
4328 test "$GCC" = yes && libtool_flags="$libtool_flags --with-gcc"
4329 test "$lt_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
4330
4331
4332 # Check whether --enable-libtool-lock or --disable-libtool-lock was given.
4333 if test "${enable_libtool_lock+set}" = set; then
4334   enableval="$enable_libtool_lock"
4335
4336 fi;
4337 test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
4338 test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
4339
4340
4341 # Check whether --with-pic or --without-pic was given.
4342 if test "${with_pic+set}" = set; then
4343   withval="$with_pic"
4344   pic_mode="$withval"
4345 else
4346   pic_mode=default
4347 fi;
4348 test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic"
4349 test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
4350
4351 # Some flags need to be propagated to the compiler or linker for good
4352 # libtool support.
4353 case $host in
4354 *-*-irix6*)
4355   # Find out which ABI we are using.
4356   echo '#line 4356 "configure"' > conftest.$ac_ext
4357   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4358   (eval $ac_compile) 2>&5
4359   ac_status=$?
4360   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4361   (exit $ac_status); }; then
4362    if test "$lt_cv_prog_gnu_ld" = yes; then
4363     case `/usr/bin/file conftest.$ac_objext` in
4364     *32-bit*)
4365       LD="${LD-ld} -melf32bsmip"
4366       ;;
4367     *N32*)
4368       LD="${LD-ld} -melf32bmipn32"
4369       ;;
4370     *64-bit*)
4371       LD="${LD-ld} -melf64bmip"
4372       ;;
4373     esac
4374    else
4375     case `/usr/bin/file conftest.$ac_objext` in
4376     *32-bit*)
4377       LD="${LD-ld} -32"
4378       ;;
4379     *N32*)
4380       LD="${LD-ld} -n32"
4381       ;;
4382     *64-bit*)
4383       LD="${LD-ld} -64"
4384       ;;
4385     esac
4386    fi
4387   fi
4388   rm -rf conftest*
4389   ;;
4390
4391 ia64-*-hpux*)
4392   # Find out which ABI we are using.
4393   echo 'int i;' > conftest.$ac_ext
4394   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4395   (eval $ac_compile) 2>&5
4396   ac_status=$?
4397   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4398   (exit $ac_status); }; then
4399     case "`/usr/bin/file conftest.o`" in
4400     *ELF-32*)
4401       HPUX_IA64_MODE="32"
4402       ;;
4403     *ELF-64*)
4404       HPUX_IA64_MODE="64"
4405       ;;
4406     esac
4407   fi
4408   rm -rf conftest*
4409   ;;
4410
4411 x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*)
4412   # Find out which ABI we are using.
4413   echo 'int i;' > conftest.$ac_ext
4414   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4415   (eval $ac_compile) 2>&5
4416   ac_status=$?
4417   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4418   (exit $ac_status); }; then
4419     case "`/usr/bin/file conftest.o`" in
4420     *32-bit*)
4421       case $host in
4422         x86_64-*linux*)
4423           LD="${LD-ld} -m elf_i386"
4424           ;;
4425         ppc64-*linux*|powerpc64-*linux*)
4426           LD="${LD-ld} -m elf32ppclinux"
4427           ;;
4428         s390x-*linux*)
4429           LD="${LD-ld} -m elf_s390"
4430           ;;
4431         sparc64-*linux*)
4432           LD="${LD-ld} -m elf32_sparc"
4433           ;;
4434       esac
4435       ;;
4436     *64-bit*)
4437       case $host in
4438         x86_64-*linux*)
4439           LD="${LD-ld} -m elf_x86_64"
4440           ;;
4441         ppc*-*linux*|powerpc*-*linux*)
4442           LD="${LD-ld} -m elf64ppc"
4443           ;;
4444         s390*-*linux*)
4445           LD="${LD-ld} -m elf64_s390"
4446           ;;
4447         sparc*-*linux*)
4448           LD="${LD-ld} -m elf64_sparc"
4449           ;;
4450       esac
4451       ;;
4452     esac
4453   fi
4454   rm -rf conftest*
4455   ;;
4456
4457 *-*-sco3.2v5*)
4458   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
4459   SAVE_CFLAGS="$CFLAGS"
4460   CFLAGS="$CFLAGS -belf"
4461   echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
4462 echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6
4463 if test "${lt_cv_cc_needs_belf+set}" = set; then
4464   echo $ECHO_N "(cached) $ECHO_C" >&6
4465 else
4466
4467
4468      ac_ext=c
4469 ac_cpp='$CPP $CPPFLAGS'
4470 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4471 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4472 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4473
4474      if test x$gcc_no_link = xyes; then
4475   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
4476 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
4477    { (exit 1); exit 1; }; }
4478 fi
4479 cat >conftest.$ac_ext <<_ACEOF
4480 /* confdefs.h.  */
4481 _ACEOF
4482 cat confdefs.h >>conftest.$ac_ext
4483 cat >>conftest.$ac_ext <<_ACEOF
4484 /* end confdefs.h.  */
4485
4486 int
4487 main ()
4488 {
4489
4490   ;
4491   return 0;
4492 }
4493 _ACEOF
4494 rm -f conftest.$ac_objext conftest$ac_exeext
4495 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4496   (eval $ac_link) 2>conftest.er1
4497   ac_status=$?
4498   grep -v '^ *+' conftest.er1 >conftest.err
4499   rm -f conftest.er1
4500   cat conftest.err >&5
4501   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4502   (exit $ac_status); } &&
4503          { ac_try='test -z "$ac_c_werror_flag"
4504                          || test ! -s conftest.err'
4505   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4506   (eval $ac_try) 2>&5
4507   ac_status=$?
4508   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4509   (exit $ac_status); }; } &&
4510          { ac_try='test -s conftest$ac_exeext'
4511   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4512   (eval $ac_try) 2>&5
4513   ac_status=$?
4514   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4515   (exit $ac_status); }; }; then
4516   lt_cv_cc_needs_belf=yes
4517 else
4518   echo "$as_me: failed program was:" >&5
4519 sed 's/^/| /' conftest.$ac_ext >&5
4520
4521 lt_cv_cc_needs_belf=no
4522 fi
4523 rm -f conftest.err conftest.$ac_objext \
4524       conftest$ac_exeext conftest.$ac_ext
4525      ac_ext=c
4526 ac_cpp='$CPP $CPPFLAGS'
4527 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4528 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4529 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4530
4531 fi
4532 echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
4533 echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6
4534   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
4535     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
4536     CFLAGS="$SAVE_CFLAGS"
4537   fi
4538   ;;
4539
4540
4541 esac
4542
4543
4544 # Save cache, so that ltconfig can load it
4545 cat >confcache <<\_ACEOF
4546 # This file is a shell script that caches the results of configure
4547 # tests run on this system so they can be shared between configure
4548 # scripts and configure runs, see configure's option --config-cache.
4549 # It is not useful on other systems.  If it contains results you don't
4550 # want to keep, you may remove or edit it.
4551 #
4552 # config.status only pays attention to the cache file if you give it
4553 # the --recheck option to rerun configure.
4554 #
4555 # `ac_cv_env_foo' variables (set or unset) will be overridden when
4556 # loading this file, other *unset* `ac_cv_foo' will be assigned the
4557 # following values.
4558
4559 _ACEOF
4560
4561 # The following way of writing the cache mishandles newlines in values,
4562 # but we know of no workaround that is simple, portable, and efficient.
4563 # So, don't put newlines in cache variables' values.
4564 # Ultrix sh set writes to stderr and can't be redirected directly,
4565 # and sets the high bit in the cache file unless we assign to the vars.
4566 {
4567   (set) 2>&1 |
4568     case `(ac_space=' '; set | grep ac_space) 2>&1` in
4569     *ac_space=\ *)
4570       # `set' does not quote correctly, so add quotes (double-quote
4571       # substitution turns \\\\ into \\, and sed turns \\ into \).
4572       sed -n \
4573         "s/'/'\\\\''/g;
4574           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
4575       ;;
4576     *)
4577       # `set' quotes correctly as required by POSIX, so do not add quotes.
4578       sed -n \
4579         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
4580       ;;
4581     esac;
4582 } |
4583   sed '
4584      t clear
4585      : clear
4586      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
4587      t end
4588      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
4589      : end' >>confcache
4590 if diff $cache_file confcache >/dev/null 2>&1; then :; else
4591   if test -w $cache_file; then
4592     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
4593     cat confcache >$cache_file
4594   else
4595     echo "not updating unwritable cache $cache_file"
4596   fi
4597 fi
4598 rm -f confcache
4599
4600 # Actually configure libtool.  ac_aux_dir is where install-sh is found.
4601 AR="$AR" LTCC="$CC" CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
4602 MAGIC_CMD="$MAGIC_CMD" LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
4603 LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \
4604 AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \
4605 objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \
4606 deplibs_check_method="$deplibs_check_method" file_magic_cmd="$file_magic_cmd" \
4607 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
4608 $libtool_flags --no-verify --build="$build" $ac_aux_dir/ltmain.sh $host \
4609 || { { echo "$as_me:$LINENO: error: libtool configure failed" >&5
4610 echo "$as_me: error: libtool configure failed" >&2;}
4611    { (exit 1); exit 1; }; }
4612
4613 # Reload cache, that may have been modified by ltconfig
4614 if test -r "$cache_file"; then
4615   # Some versions of bash will fail to source /dev/null (special
4616   # files actually), so we avoid doing that.
4617   if test -f "$cache_file"; then
4618     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
4619 echo "$as_me: loading cache $cache_file" >&6;}
4620     case $cache_file in
4621       [\\/]* | ?:[\\/]* ) . $cache_file;;
4622       *)                      . ./$cache_file;;
4623     esac
4624   fi
4625 else
4626   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
4627 echo "$as_me: creating cache $cache_file" >&6;}
4628   >$cache_file
4629 fi
4630
4631
4632 # This can be used to rebuild libtool when needed
4633 LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh $ac_aux_dir/ltcf-c.sh"
4634
4635 # Always use our own libtool.
4636 LIBTOOL='$(SHELL) $(top_builddir)/libtool'
4637
4638 # Redirect the config.log output again, so that the ltconfig log is not
4639 # clobbered by the next message.
4640 exec 5>>./config.log
4641
4642
4643
4644
4645
4646
4647
4648
4649 #AC_MSG_NOTICE([====== Finished libtool configuration]) ; sleep 10
4650
4651 # We need gfortran to compile parts of the library
4652 #AC_PROG_FC(gfortran)
4653 FC="$GFORTRAN"
4654 ac_ext=${FC_SRCEXT-f}
4655 ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4656 ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4657 ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4658 if test -n "$ac_tool_prefix"; then
4659   for ac_prog in gfortran
4660   do
4661     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4662 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4663 echo "$as_me:$LINENO: checking for $ac_word" >&5
4664 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4665 if test "${ac_cv_prog_FC+set}" = set; then
4666   echo $ECHO_N "(cached) $ECHO_C" >&6
4667 else
4668   if test -n "$FC"; then
4669   ac_cv_prog_FC="$FC" # Let the user override the test.
4670 else
4671 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4672 for as_dir in $PATH
4673 do
4674   IFS=$as_save_IFS
4675   test -z "$as_dir" && as_dir=.
4676   for ac_exec_ext in '' $ac_executable_extensions; do
4677   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4678     ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
4679     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4680     break 2
4681   fi
4682 done
4683 done
4684
4685 fi
4686 fi
4687 FC=$ac_cv_prog_FC
4688 if test -n "$FC"; then
4689   echo "$as_me:$LINENO: result: $FC" >&5
4690 echo "${ECHO_T}$FC" >&6
4691 else
4692   echo "$as_me:$LINENO: result: no" >&5
4693 echo "${ECHO_T}no" >&6
4694 fi
4695
4696     test -n "$FC" && break
4697   done
4698 fi
4699 if test -z "$FC"; then
4700   ac_ct_FC=$FC
4701   for ac_prog in gfortran
4702 do
4703   # Extract the first word of "$ac_prog", so it can be a program name with args.
4704 set dummy $ac_prog; ac_word=$2
4705 echo "$as_me:$LINENO: checking for $ac_word" >&5
4706 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4707 if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
4708   echo $ECHO_N "(cached) $ECHO_C" >&6
4709 else
4710   if test -n "$ac_ct_FC"; then
4711   ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
4712 else
4713 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4714 for as_dir in $PATH
4715 do
4716   IFS=$as_save_IFS
4717   test -z "$as_dir" && as_dir=.
4718   for ac_exec_ext in '' $ac_executable_extensions; do
4719   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4720     ac_cv_prog_ac_ct_FC="$ac_prog"
4721     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4722     break 2
4723   fi
4724 done
4725 done
4726
4727 fi
4728 fi
4729 ac_ct_FC=$ac_cv_prog_ac_ct_FC
4730 if test -n "$ac_ct_FC"; then
4731   echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
4732 echo "${ECHO_T}$ac_ct_FC" >&6
4733 else
4734   echo "$as_me:$LINENO: result: no" >&5
4735 echo "${ECHO_T}no" >&6
4736 fi
4737
4738   test -n "$ac_ct_FC" && break
4739 done
4740
4741   FC=$ac_ct_FC
4742 fi
4743
4744
4745 # Provide some information about the compiler.
4746 echo "$as_me:4746:" \
4747      "checking for Fortran compiler version" >&5
4748 ac_compiler=`set X $ac_compile; echo $2`
4749 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
4750   (eval $ac_compiler --version </dev/null >&5) 2>&5
4751   ac_status=$?
4752   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4753   (exit $ac_status); }
4754 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
4755   (eval $ac_compiler -v </dev/null >&5) 2>&5
4756   ac_status=$?
4757   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4758   (exit $ac_status); }
4759 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
4760   (eval $ac_compiler -V </dev/null >&5) 2>&5
4761   ac_status=$?
4762   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4763   (exit $ac_status); }
4764 rm -f a.out
4765
4766 # If we don't use `.F' as extension, the preprocessor is not run on the
4767 # input file.  (Note that this only needs to work for GNU compilers.)
4768 ac_save_ext=$ac_ext
4769 ac_ext=F
4770 echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
4771 echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
4772 if test "${ac_cv_fc_compiler_gnu+set}" = set; then
4773   echo $ECHO_N "(cached) $ECHO_C" >&6
4774 else
4775   cat >conftest.$ac_ext <<_ACEOF
4776       program main
4777 #ifndef __GNUC__
4778        choke me
4779 #endif
4780
4781       end
4782 _ACEOF
4783 rm -f conftest.$ac_objext
4784 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4785   (eval $ac_compile) 2>conftest.er1
4786   ac_status=$?
4787   grep -v '^ *+' conftest.er1 >conftest.err
4788   rm -f conftest.er1
4789   cat conftest.err >&5
4790   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4791   (exit $ac_status); } &&
4792          { ac_try='test -z "$ac_fc_werror_flag"
4793                          || test ! -s conftest.err'
4794   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4795   (eval $ac_try) 2>&5
4796   ac_status=$?
4797   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4798   (exit $ac_status); }; } &&
4799          { ac_try='test -s conftest.$ac_objext'
4800   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4801   (eval $ac_try) 2>&5
4802   ac_status=$?
4803   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4804   (exit $ac_status); }; }; then
4805   ac_compiler_gnu=yes
4806 else
4807   echo "$as_me: failed program was:" >&5
4808 sed 's/^/| /' conftest.$ac_ext >&5
4809
4810 ac_compiler_gnu=no
4811 fi
4812 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4813 ac_cv_fc_compiler_gnu=$ac_compiler_gnu
4814
4815 fi
4816 echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
4817 echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
4818 ac_ext=$ac_save_ext
4819 ac_test_FFLAGS=${FCFLAGS+set}
4820 ac_save_FFLAGS=$FCFLAGS
4821 FCFLAGS=
4822 echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
4823 echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
4824 if test "${ac_cv_prog_fc_g+set}" = set; then
4825   echo $ECHO_N "(cached) $ECHO_C" >&6
4826 else
4827   FCFLAGS=-g
4828 cat >conftest.$ac_ext <<_ACEOF
4829       program main
4830
4831       end
4832 _ACEOF
4833 rm -f conftest.$ac_objext
4834 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4835   (eval $ac_compile) 2>conftest.er1
4836   ac_status=$?
4837   grep -v '^ *+' conftest.er1 >conftest.err
4838   rm -f conftest.er1
4839   cat conftest.err >&5
4840   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4841   (exit $ac_status); } &&
4842          { ac_try='test -z "$ac_fc_werror_flag"
4843                          || test ! -s conftest.err'
4844   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4845   (eval $ac_try) 2>&5
4846   ac_status=$?
4847   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4848   (exit $ac_status); }; } &&
4849          { ac_try='test -s conftest.$ac_objext'
4850   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4851   (eval $ac_try) 2>&5
4852   ac_status=$?
4853   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4854   (exit $ac_status); }; }; then
4855   ac_cv_prog_fc_g=yes
4856 else
4857   echo "$as_me: failed program was:" >&5
4858 sed 's/^/| /' conftest.$ac_ext >&5
4859
4860 ac_cv_prog_fc_g=no
4861 fi
4862 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4863
4864 fi
4865 echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
4866 echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
4867 if test "$ac_test_FFLAGS" = set; then
4868   FCFLAGS=$ac_save_FFLAGS
4869 elif test $ac_cv_prog_fc_g = yes; then
4870   if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4871     FCFLAGS="-g -O2"
4872   else
4873     FCFLAGS="-g"
4874   fi
4875 else
4876   if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4877     FCFLAGS="-O2"
4878   else
4879     FCFLAGS=
4880   fi
4881 fi
4882
4883 ac_ext=c
4884 ac_cpp='$CPP $CPPFLAGS'
4885 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4886 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4887 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4888
4889
4890 # extra LD Flags which are required for targets
4891 case "${host}" in
4892   *-darwin*)
4893     # Darwin needs -single_module when linking libgfortran
4894     extra_ldflags_libgfortran=-Wl,-single_module
4895     ;;
4896 esac
4897
4898
4899 # We need a working compiler at that point, otherwise give a clear
4900 # error message and bail out.
4901
4902
4903 echo "$as_me:$LINENO: checking whether the GNU Fortran compiler is working" >&5
4904 echo $ECHO_N "checking whether the GNU Fortran compiler is working... $ECHO_C" >&6
4905 ac_ext=${FC_SRCEXT-f}
4906 ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4907 ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4908 ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4909
4910 cat >conftest.$ac_ext <<_ACEOF
4911
4912       program foo
4913       real, parameter :: bar = sin (12.34 / 2.5)
4914       end program foo
4915 _ACEOF
4916 rm -f conftest.$ac_objext
4917 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4918   (eval $ac_compile) 2>conftest.er1
4919   ac_status=$?
4920   grep -v '^ *+' conftest.er1 >conftest.err
4921   rm -f conftest.er1
4922   cat conftest.err >&5
4923   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4924   (exit $ac_status); } &&
4925          { ac_try='test -z "$ac_fc_werror_flag"
4926                          || test ! -s conftest.err'
4927   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4928   (eval $ac_try) 2>&5
4929   ac_status=$?
4930   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4931   (exit $ac_status); }; } &&
4932          { ac_try='test -s conftest.$ac_objext'
4933   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4934   (eval $ac_try) 2>&5
4935   ac_status=$?
4936   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4937   (exit $ac_status); }; }; then
4938   echo "$as_me:$LINENO: result: yes" >&5
4939 echo "${ECHO_T}yes" >&6
4940 else
4941   echo "$as_me: failed program was:" >&5
4942 sed 's/^/| /' conftest.$ac_ext >&5
4943
4944 echo "$as_me:$LINENO: result: no" >&5
4945 echo "${ECHO_T}no" >&6
4946      { { echo "$as_me:$LINENO: error: GNU Fortran is not working; please report a bug in http://gcc.gnu.org/bugzilla, attaching $PWD/config.log" >&5
4947 echo "$as_me: error: GNU Fortran is not working; please report a bug in http://gcc.gnu.org/bugzilla, attaching $PWD/config.log" >&2;}
4948    { (exit 1); exit 1; }; }
4949
4950 fi
4951 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4952 ac_ext=c
4953 ac_cpp='$CPP $CPPFLAGS'
4954 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4955 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4956 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4957
4958
4959
4960 # Check whether --enable-largefile or --disable-largefile was given.
4961 if test "${enable_largefile+set}" = set; then
4962   enableval="$enable_largefile"
4963
4964 fi;
4965 if test "$enable_largefile" != no; then
4966
4967   echo "$as_me:$LINENO: checking for special C compiler options needed for large files" >&5
4968 echo $ECHO_N "checking for special C compiler options needed for large files... $ECHO_C" >&6
4969 if test "${ac_cv_sys_largefile_CC+set}" = set; then
4970   echo $ECHO_N "(cached) $ECHO_C" >&6
4971 else
4972   ac_cv_sys_largefile_CC=no
4973      if test "$GCC" != yes; then
4974        ac_save_CC=$CC
4975        while :; do
4976          # IRIX 6.2 and later do not support large files by default,
4977          # so use the C compiler's -n32 option if that helps.
4978          cat >conftest.$ac_ext <<_ACEOF
4979 /* confdefs.h.  */
4980 _ACEOF
4981 cat confdefs.h >>conftest.$ac_ext
4982 cat >>conftest.$ac_ext <<_ACEOF
4983 /* end confdefs.h.  */
4984 #include <sys/types.h>
4985  /* Check that off_t can represent 2**63 - 1 correctly.
4986     We can't simply define LARGE_OFF_T to be 9223372036854775807,
4987     since some C++ compilers masquerading as C compilers
4988     incorrectly reject 9223372036854775807.  */
4989 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4990   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4991                        && LARGE_OFF_T % 2147483647 == 1)
4992                       ? 1 : -1];
4993 int
4994 main ()
4995 {
4996
4997   ;
4998   return 0;
4999 }
5000 _ACEOF
5001          rm -f conftest.$ac_objext
5002 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5003   (eval $ac_compile) 2>conftest.er1
5004   ac_status=$?
5005   grep -v '^ *+' conftest.er1 >conftest.err
5006   rm -f conftest.er1
5007   cat conftest.err >&5
5008   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5009   (exit $ac_status); } &&
5010          { ac_try='test -z "$ac_c_werror_flag"
5011                          || test ! -s conftest.err'
5012   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5013   (eval $ac_try) 2>&5
5014   ac_status=$?
5015   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5016   (exit $ac_status); }; } &&
5017          { ac_try='test -s conftest.$ac_objext'
5018   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5019   (eval $ac_try) 2>&5
5020   ac_status=$?
5021   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5022   (exit $ac_status); }; }; then
5023   break
5024 else
5025   echo "$as_me: failed program was:" >&5
5026 sed 's/^/| /' conftest.$ac_ext >&5
5027
5028 fi
5029 rm -f conftest.err conftest.$ac_objext
5030          CC="$CC -n32"
5031          rm -f conftest.$ac_objext
5032 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5033   (eval $ac_compile) 2>conftest.er1
5034   ac_status=$?
5035   grep -v '^ *+' conftest.er1 >conftest.err
5036   rm -f conftest.er1
5037   cat conftest.err >&5
5038   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5039   (exit $ac_status); } &&
5040          { ac_try='test -z "$ac_c_werror_flag"
5041                          || test ! -s conftest.err'
5042   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5043   (eval $ac_try) 2>&5
5044   ac_status=$?
5045   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5046   (exit $ac_status); }; } &&
5047          { ac_try='test -s conftest.$ac_objext'
5048   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5049   (eval $ac_try) 2>&5
5050   ac_status=$?
5051   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5052   (exit $ac_status); }; }; then
5053   ac_cv_sys_largefile_CC=' -n32'; break
5054 else
5055   echo "$as_me: failed program was:" >&5
5056 sed 's/^/| /' conftest.$ac_ext >&5
5057
5058 fi
5059 rm -f conftest.err conftest.$ac_objext
5060          break
5061        done
5062        CC=$ac_save_CC
5063        rm -f conftest.$ac_ext
5064     fi
5065 fi
5066 echo "$as_me:$LINENO: result: $ac_cv_sys_largefile_CC" >&5
5067 echo "${ECHO_T}$ac_cv_sys_largefile_CC" >&6
5068   if test "$ac_cv_sys_largefile_CC" != no; then
5069     CC=$CC$ac_cv_sys_largefile_CC
5070   fi
5071
5072   echo "$as_me:$LINENO: checking for _FILE_OFFSET_BITS value needed for large files" >&5
5073 echo $ECHO_N "checking for _FILE_OFFSET_BITS value needed for large files... $ECHO_C" >&6
5074 if test "${ac_cv_sys_file_offset_bits+set}" = set; then
5075   echo $ECHO_N "(cached) $ECHO_C" >&6
5076 else
5077   while :; do
5078   ac_cv_sys_file_offset_bits=no
5079   cat >conftest.$ac_ext <<_ACEOF
5080 /* confdefs.h.  */
5081 _ACEOF
5082 cat confdefs.h >>conftest.$ac_ext
5083 cat >>conftest.$ac_ext <<_ACEOF
5084 /* end confdefs.h.  */
5085 #include <sys/types.h>
5086  /* Check that off_t can represent 2**63 - 1 correctly.
5087     We can't simply define LARGE_OFF_T to be 9223372036854775807,
5088     since some C++ compilers masquerading as C compilers
5089     incorrectly reject 9223372036854775807.  */
5090 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5091   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5092                        && LARGE_OFF_T % 2147483647 == 1)
5093                       ? 1 : -1];
5094 int
5095 main ()
5096 {
5097
5098   ;
5099   return 0;
5100 }
5101 _ACEOF
5102 rm -f conftest.$ac_objext
5103 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5104   (eval $ac_compile) 2>conftest.er1
5105   ac_status=$?
5106   grep -v '^ *+' conftest.er1 >conftest.err
5107   rm -f conftest.er1
5108   cat conftest.err >&5
5109   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5110   (exit $ac_status); } &&
5111          { ac_try='test -z "$ac_c_werror_flag"
5112                          || test ! -s conftest.err'
5113   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5114   (eval $ac_try) 2>&5
5115   ac_status=$?
5116   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5117   (exit $ac_status); }; } &&
5118          { ac_try='test -s conftest.$ac_objext'
5119   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5120   (eval $ac_try) 2>&5
5121   ac_status=$?
5122   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5123   (exit $ac_status); }; }; then
5124   break
5125 else
5126   echo "$as_me: failed program was:" >&5
5127 sed 's/^/| /' conftest.$ac_ext >&5
5128
5129 fi
5130 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5131   cat >conftest.$ac_ext <<_ACEOF
5132 /* confdefs.h.  */
5133 _ACEOF
5134 cat confdefs.h >>conftest.$ac_ext
5135 cat >>conftest.$ac_ext <<_ACEOF
5136 /* end confdefs.h.  */
5137 #define _FILE_OFFSET_BITS 64
5138 #include <sys/types.h>
5139  /* Check that off_t can represent 2**63 - 1 correctly.
5140     We can't simply define LARGE_OFF_T to be 9223372036854775807,
5141     since some C++ compilers masquerading as C compilers
5142     incorrectly reject 9223372036854775807.  */
5143 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5144   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5145                        && LARGE_OFF_T % 2147483647 == 1)
5146                       ? 1 : -1];
5147 int
5148 main ()
5149 {
5150
5151   ;
5152   return 0;
5153 }
5154 _ACEOF
5155 rm -f conftest.$ac_objext
5156 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5157   (eval $ac_compile) 2>conftest.er1
5158   ac_status=$?
5159   grep -v '^ *+' conftest.er1 >conftest.err
5160   rm -f conftest.er1
5161   cat conftest.err >&5
5162   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5163   (exit $ac_status); } &&
5164          { ac_try='test -z "$ac_c_werror_flag"
5165                          || test ! -s conftest.err'
5166   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5167   (eval $ac_try) 2>&5
5168   ac_status=$?
5169   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5170   (exit $ac_status); }; } &&
5171          { ac_try='test -s conftest.$ac_objext'
5172   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5173   (eval $ac_try) 2>&5
5174   ac_status=$?
5175   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5176   (exit $ac_status); }; }; then
5177   ac_cv_sys_file_offset_bits=64; break
5178 else
5179   echo "$as_me: failed program was:" >&5
5180 sed 's/^/| /' conftest.$ac_ext >&5
5181
5182 fi
5183 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5184   break
5185 done
5186 fi
5187 echo "$as_me:$LINENO: result: $ac_cv_sys_file_offset_bits" >&5
5188 echo "${ECHO_T}$ac_cv_sys_file_offset_bits" >&6
5189 if test "$ac_cv_sys_file_offset_bits" != no; then
5190
5191 cat >>confdefs.h <<_ACEOF
5192 #define _FILE_OFFSET_BITS $ac_cv_sys_file_offset_bits
5193 _ACEOF
5194
5195 fi
5196 rm -f conftest*
5197   echo "$as_me:$LINENO: checking for _LARGE_FILES value needed for large files" >&5
5198 echo $ECHO_N "checking for _LARGE_FILES value needed for large files... $ECHO_C" >&6
5199 if test "${ac_cv_sys_large_files+set}" = set; then
5200   echo $ECHO_N "(cached) $ECHO_C" >&6
5201 else
5202   while :; do
5203   ac_cv_sys_large_files=no
5204   cat >conftest.$ac_ext <<_ACEOF
5205 /* confdefs.h.  */
5206 _ACEOF
5207 cat confdefs.h >>conftest.$ac_ext
5208 cat >>conftest.$ac_ext <<_ACEOF
5209 /* end confdefs.h.  */
5210 #include <sys/types.h>
5211  /* Check that off_t can represent 2**63 - 1 correctly.
5212     We can't simply define LARGE_OFF_T to be 9223372036854775807,
5213     since some C++ compilers masquerading as C compilers
5214     incorrectly reject 9223372036854775807.  */
5215 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5216   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5217                        && LARGE_OFF_T % 2147483647 == 1)
5218                       ? 1 : -1];
5219 int
5220 main ()
5221 {
5222
5223   ;
5224   return 0;
5225 }
5226 _ACEOF
5227 rm -f conftest.$ac_objext
5228 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5229   (eval $ac_compile) 2>conftest.er1
5230   ac_status=$?
5231   grep -v '^ *+' conftest.er1 >conftest.err
5232   rm -f conftest.er1
5233   cat conftest.err >&5
5234   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5235   (exit $ac_status); } &&
5236          { ac_try='test -z "$ac_c_werror_flag"
5237                          || test ! -s conftest.err'
5238   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5239   (eval $ac_try) 2>&5
5240   ac_status=$?
5241   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5242   (exit $ac_status); }; } &&
5243          { ac_try='test -s conftest.$ac_objext'
5244   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5245   (eval $ac_try) 2>&5
5246   ac_status=$?
5247   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5248   (exit $ac_status); }; }; then
5249   break
5250 else
5251   echo "$as_me: failed program was:" >&5
5252 sed 's/^/| /' conftest.$ac_ext >&5
5253
5254 fi
5255 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5256   cat >conftest.$ac_ext <<_ACEOF
5257 /* confdefs.h.  */
5258 _ACEOF
5259 cat confdefs.h >>conftest.$ac_ext
5260 cat >>conftest.$ac_ext <<_ACEOF
5261 /* end confdefs.h.  */
5262 #define _LARGE_FILES 1
5263 #include <sys/types.h>
5264  /* Check that off_t can represent 2**63 - 1 correctly.
5265     We can't simply define LARGE_OFF_T to be 9223372036854775807,
5266     since some C++ compilers masquerading as C compilers
5267     incorrectly reject 9223372036854775807.  */
5268 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5269   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5270                        && LARGE_OFF_T % 2147483647 == 1)
5271                       ? 1 : -1];
5272 int
5273 main ()
5274 {
5275
5276   ;
5277   return 0;
5278 }
5279 _ACEOF
5280 rm -f conftest.$ac_objext
5281 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5282   (eval $ac_compile) 2>conftest.er1
5283   ac_status=$?
5284   grep -v '^ *+' conftest.er1 >conftest.err
5285   rm -f conftest.er1
5286   cat conftest.err >&5
5287   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5288   (exit $ac_status); } &&
5289          { ac_try='test -z "$ac_c_werror_flag"
5290                          || test ! -s conftest.err'
5291   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5292   (eval $ac_try) 2>&5
5293   ac_status=$?
5294   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5295   (exit $ac_status); }; } &&
5296          { ac_try='test -s conftest.$ac_objext'
5297   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5298   (eval $ac_try) 2>&5
5299   ac_status=$?
5300   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5301   (exit $ac_status); }; }; then
5302   ac_cv_sys_large_files=1; break
5303 else
5304   echo "$as_me: failed program was:" >&5
5305 sed 's/^/| /' conftest.$ac_ext >&5
5306
5307 fi
5308 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5309   break
5310 done
5311 fi
5312 echo "$as_me:$LINENO: result: $ac_cv_sys_large_files" >&5
5313 echo "${ECHO_T}$ac_cv_sys_large_files" >&6
5314 if test "$ac_cv_sys_large_files" != no; then
5315
5316 cat >>confdefs.h <<_ACEOF
5317 #define _LARGE_FILES $ac_cv_sys_large_files
5318 _ACEOF
5319
5320 fi
5321 rm -f conftest*
5322 fi
5323
5324 ac_ext=c
5325 ac_cpp='$CPP $CPPFLAGS'
5326 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5327 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5328 ac_compiler_gnu=$ac_cv_c_compiler_gnu
5329 echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
5330 echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
5331 # On Suns, sometimes $CPP names a directory.
5332 if test -n "$CPP" && test -d "$CPP"; then
5333   CPP=
5334 fi
5335 if test -z "$CPP"; then
5336   if test "${ac_cv_prog_CPP+set}" = set; then
5337   echo $ECHO_N "(cached) $ECHO_C" >&6
5338 else
5339       # Double quotes because CPP needs to be expanded
5340     for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
5341     do
5342       ac_preproc_ok=false
5343 for ac_c_preproc_warn_flag in '' yes
5344 do
5345   # Use a header file that comes with gcc, so configuring glibc
5346   # with a fresh cross-compiler works.
5347   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5348   # <limits.h> exists even on freestanding compilers.
5349   # On the NeXT, cc -E runs the code through the compiler's parser,
5350   # not just through cpp. "Syntax error" is here to catch this case.
5351   cat >conftest.$ac_ext <<_ACEOF
5352 /* confdefs.h.  */
5353 _ACEOF
5354 cat confdefs.h >>conftest.$ac_ext
5355 cat >>conftest.$ac_ext <<_ACEOF
5356 /* end confdefs.h.  */
5357 #ifdef __STDC__
5358 # include <limits.h>
5359 #else
5360 # include <assert.h>
5361 #endif
5362                      Syntax error
5363 _ACEOF
5364 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5365   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5366   ac_status=$?
5367   grep -v '^ *+' conftest.er1 >conftest.err
5368   rm -f conftest.er1
5369   cat conftest.err >&5
5370   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5371   (exit $ac_status); } >/dev/null; then
5372   if test -s conftest.err; then
5373     ac_cpp_err=$ac_c_preproc_warn_flag
5374     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5375   else
5376     ac_cpp_err=
5377   fi
5378 else
5379   ac_cpp_err=yes
5380 fi
5381 if test -z "$ac_cpp_err"; then
5382   :
5383 else
5384   echo "$as_me: failed program was:" >&5
5385 sed 's/^/| /' conftest.$ac_ext >&5
5386
5387   # Broken: fails on valid input.
5388 continue
5389 fi
5390 rm -f conftest.err conftest.$ac_ext
5391
5392   # OK, works on sane cases.  Now check whether non-existent headers
5393   # can be detected and how.
5394   cat >conftest.$ac_ext <<_ACEOF
5395 /* confdefs.h.  */
5396 _ACEOF
5397 cat confdefs.h >>conftest.$ac_ext
5398 cat >>conftest.$ac_ext <<_ACEOF
5399 /* end confdefs.h.  */
5400 #include <ac_nonexistent.h>
5401 _ACEOF
5402 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5403   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5404   ac_status=$?
5405   grep -v '^ *+' conftest.er1 >conftest.err
5406   rm -f conftest.er1
5407   cat conftest.err >&5
5408   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5409   (exit $ac_status); } >/dev/null; then
5410   if test -s conftest.err; then
5411     ac_cpp_err=$ac_c_preproc_warn_flag
5412     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5413   else
5414     ac_cpp_err=
5415   fi
5416 else
5417   ac_cpp_err=yes
5418 fi
5419 if test -z "$ac_cpp_err"; then
5420   # Broken: success on invalid input.
5421 continue
5422 else
5423   echo "$as_me: failed program was:" >&5
5424 sed 's/^/| /' conftest.$ac_ext >&5
5425
5426   # Passes both tests.
5427 ac_preproc_ok=:
5428 break
5429 fi
5430 rm -f conftest.err conftest.$ac_ext
5431
5432 done
5433 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5434 rm -f conftest.err conftest.$ac_ext
5435 if $ac_preproc_ok; then
5436   break
5437 fi
5438
5439     done
5440     ac_cv_prog_CPP=$CPP
5441
5442 fi
5443   CPP=$ac_cv_prog_CPP
5444 else
5445   ac_cv_prog_CPP=$CPP
5446 fi
5447 echo "$as_me:$LINENO: result: $CPP" >&5
5448 echo "${ECHO_T}$CPP" >&6
5449 ac_preproc_ok=false
5450 for ac_c_preproc_warn_flag in '' yes
5451 do
5452   # Use a header file that comes with gcc, so configuring glibc
5453   # with a fresh cross-compiler works.
5454   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5455   # <limits.h> exists even on freestanding compilers.
5456   # On the NeXT, cc -E runs the code through the compiler's parser,
5457   # not just through cpp. "Syntax error" is here to catch this case.
5458   cat >conftest.$ac_ext <<_ACEOF
5459 /* confdefs.h.  */
5460 _ACEOF
5461 cat confdefs.h >>conftest.$ac_ext
5462 cat >>conftest.$ac_ext <<_ACEOF
5463 /* end confdefs.h.  */
5464 #ifdef __STDC__
5465 # include <limits.h>
5466 #else
5467 # include <assert.h>
5468 #endif
5469                      Syntax error
5470 _ACEOF
5471 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5472   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5473   ac_status=$?
5474   grep -v '^ *+' conftest.er1 >conftest.err
5475   rm -f conftest.er1
5476   cat conftest.err >&5
5477   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5478   (exit $ac_status); } >/dev/null; then
5479   if test -s conftest.err; then
5480     ac_cpp_err=$ac_c_preproc_warn_flag
5481     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5482   else
5483     ac_cpp_err=
5484   fi
5485 else
5486   ac_cpp_err=yes
5487 fi
5488 if test -z "$ac_cpp_err"; then
5489   :
5490 else
5491   echo "$as_me: failed program was:" >&5
5492 sed 's/^/| /' conftest.$ac_ext >&5
5493
5494   # Broken: fails on valid input.
5495 continue
5496 fi
5497 rm -f conftest.err conftest.$ac_ext
5498
5499   # OK, works on sane cases.  Now check whether non-existent headers
5500   # can be detected and how.
5501   cat >conftest.$ac_ext <<_ACEOF
5502 /* confdefs.h.  */
5503 _ACEOF
5504 cat confdefs.h >>conftest.$ac_ext
5505 cat >>conftest.$ac_ext <<_ACEOF
5506 /* end confdefs.h.  */
5507 #include <ac_nonexistent.h>
5508 _ACEOF
5509 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5510   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5511   ac_status=$?
5512   grep -v '^ *+' conftest.er1 >conftest.err
5513   rm -f conftest.er1
5514   cat conftest.err >&5
5515   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5516   (exit $ac_status); } >/dev/null; then
5517   if test -s conftest.err; then
5518     ac_cpp_err=$ac_c_preproc_warn_flag
5519     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5520   else
5521     ac_cpp_err=
5522   fi
5523 else
5524   ac_cpp_err=yes
5525 fi
5526 if test -z "$ac_cpp_err"; then
5527   # Broken: success on invalid input.
5528 continue
5529 else
5530   echo "$as_me: failed program was:" >&5
5531 sed 's/^/| /' conftest.$ac_ext >&5
5532
5533   # Passes both tests.
5534 ac_preproc_ok=:
5535 break
5536 fi
5537 rm -f conftest.err conftest.$ac_ext
5538
5539 done
5540 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5541 rm -f conftest.err conftest.$ac_ext
5542 if $ac_preproc_ok; then
5543   :
5544 else
5545   { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
5546 See \`config.log' for more details." >&5
5547 echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
5548 See \`config.log' for more details." >&2;}
5549    { (exit 1); exit 1; }; }
5550 fi
5551
5552 ac_ext=c
5553 ac_cpp='$CPP $CPPFLAGS'
5554 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5555 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5556 ac_compiler_gnu=$ac_cv_c_compiler_gnu
5557
5558
5559 echo "$as_me:$LINENO: checking for egrep" >&5
5560 echo $ECHO_N "checking for egrep... $ECHO_C" >&6
5561 if test "${ac_cv_prog_egrep+set}" = set; then
5562   echo $ECHO_N "(cached) $ECHO_C" >&6
5563 else
5564   if echo a | (grep -E '(a|b)') >/dev/null 2>&1
5565     then ac_cv_prog_egrep='grep -E'
5566     else ac_cv_prog_egrep='egrep'
5567     fi
5568 fi
5569 echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
5570 echo "${ECHO_T}$ac_cv_prog_egrep" >&6
5571  EGREP=$ac_cv_prog_egrep
5572
5573
5574 echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5575 echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5576 if test "${ac_cv_header_stdc+set}" = set; then
5577   echo $ECHO_N "(cached) $ECHO_C" >&6
5578 else
5579   cat >conftest.$ac_ext <<_ACEOF
5580 /* confdefs.h.  */
5581 _ACEOF
5582 cat confdefs.h >>conftest.$ac_ext
5583 cat >>conftest.$ac_ext <<_ACEOF
5584 /* end confdefs.h.  */
5585 #include <stdlib.h>
5586 #include <stdarg.h>
5587 #include <string.h>
5588 #include <float.h>
5589
5590 int
5591 main ()
5592 {
5593
5594   ;
5595   return 0;
5596 }
5597 _ACEOF
5598 rm -f conftest.$ac_objext
5599 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5600   (eval $ac_compile) 2>conftest.er1
5601   ac_status=$?
5602   grep -v '^ *+' conftest.er1 >conftest.err
5603   rm -f conftest.er1
5604   cat conftest.err >&5
5605   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5606   (exit $ac_status); } &&
5607          { ac_try='test -z "$ac_c_werror_flag"
5608                          || test ! -s conftest.err'
5609   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5610   (eval $ac_try) 2>&5
5611   ac_status=$?
5612   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5613   (exit $ac_status); }; } &&
5614          { ac_try='test -s conftest.$ac_objext'
5615   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5616   (eval $ac_try) 2>&5
5617   ac_status=$?
5618   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5619   (exit $ac_status); }; }; then
5620   ac_cv_header_stdc=yes
5621 else
5622   echo "$as_me: failed program was:" >&5
5623 sed 's/^/| /' conftest.$ac_ext >&5
5624
5625 ac_cv_header_stdc=no
5626 fi
5627 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5628
5629 if test $ac_cv_header_stdc = yes; then
5630   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5631   cat >conftest.$ac_ext <<_ACEOF
5632 /* confdefs.h.  */
5633 _ACEOF
5634 cat confdefs.h >>conftest.$ac_ext
5635 cat >>conftest.$ac_ext <<_ACEOF
5636 /* end confdefs.h.  */
5637 #include <string.h>
5638
5639 _ACEOF
5640 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5641   $EGREP "memchr" >/dev/null 2>&1; then
5642   :
5643 else
5644   ac_cv_header_stdc=no
5645 fi
5646 rm -f conftest*
5647
5648 fi
5649
5650 if test $ac_cv_header_stdc = yes; then
5651   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5652   cat >conftest.$ac_ext <<_ACEOF
5653 /* confdefs.h.  */
5654 _ACEOF
5655 cat confdefs.h >>conftest.$ac_ext
5656 cat >>conftest.$ac_ext <<_ACEOF
5657 /* end confdefs.h.  */
5658 #include <stdlib.h>
5659
5660 _ACEOF
5661 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5662   $EGREP "free" >/dev/null 2>&1; then
5663   :
5664 else
5665   ac_cv_header_stdc=no
5666 fi
5667 rm -f conftest*
5668
5669 fi
5670
5671 if test $ac_cv_header_stdc = yes; then
5672   # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5673   if test "$cross_compiling" = yes; then
5674   :
5675 else
5676   cat >conftest.$ac_ext <<_ACEOF
5677 /* confdefs.h.  */
5678 _ACEOF
5679 cat confdefs.h >>conftest.$ac_ext
5680 cat >>conftest.$ac_ext <<_ACEOF
5681 /* end confdefs.h.  */
5682 #include <ctype.h>
5683 #if ((' ' & 0x0FF) == 0x020)
5684 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5685 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5686 #else
5687 # define ISLOWER(c) \
5688                    (('a' <= (c) && (c) <= 'i') \
5689                      || ('j' <= (c) && (c) <= 'r') \
5690                      || ('s' <= (c) && (c) <= 'z'))
5691 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5692 #endif
5693
5694 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5695 int
5696 main ()
5697 {
5698   int i;
5699   for (i = 0; i < 256; i++)
5700     if (XOR (islower (i), ISLOWER (i))
5701         || toupper (i) != TOUPPER (i))
5702       exit(2);
5703   exit (0);
5704 }
5705 _ACEOF
5706 rm -f conftest$ac_exeext
5707 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5708   (eval $ac_link) 2>&5
5709   ac_status=$?
5710   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5711   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5712   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5713   (eval $ac_try) 2>&5
5714   ac_status=$?
5715   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5716   (exit $ac_status); }; }; then
5717   :
5718 else
5719   echo "$as_me: program exited with status $ac_status" >&5
5720 echo "$as_me: failed program was:" >&5
5721 sed 's/^/| /' conftest.$ac_ext >&5
5722
5723 ( exit $ac_status )
5724 ac_cv_header_stdc=no
5725 fi
5726 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5727 fi
5728 fi
5729 fi
5730 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5731 echo "${ECHO_T}$ac_cv_header_stdc" >&6
5732 if test $ac_cv_header_stdc = yes; then
5733
5734 cat >>confdefs.h <<\_ACEOF
5735 #define STDC_HEADERS 1
5736 _ACEOF
5737
5738 fi
5739
5740 # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5741
5742
5743
5744
5745
5746
5747
5748
5749
5750 for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5751                   inttypes.h stdint.h unistd.h
5752 do
5753 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5754 echo "$as_me:$LINENO: checking for $ac_header" >&5
5755 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5756 if eval "test \"\${$as_ac_Header+set}\" = set"; then
5757   echo $ECHO_N "(cached) $ECHO_C" >&6
5758 else
5759   cat >conftest.$ac_ext <<_ACEOF
5760 /* confdefs.h.  */
5761 _ACEOF
5762 cat confdefs.h >>conftest.$ac_ext
5763 cat >>conftest.$ac_ext <<_ACEOF
5764 /* end confdefs.h.  */
5765 $ac_includes_default
5766
5767 #include <$ac_header>
5768 _ACEOF
5769 rm -f conftest.$ac_objext
5770 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5771   (eval $ac_compile) 2>conftest.er1
5772   ac_status=$?
5773   grep -v '^ *+' conftest.er1 >conftest.err
5774   rm -f conftest.er1
5775   cat conftest.err >&5
5776   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5777   (exit $ac_status); } &&
5778          { ac_try='test -z "$ac_c_werror_flag"
5779                          || test ! -s conftest.err'
5780   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5781   (eval $ac_try) 2>&5
5782   ac_status=$?
5783   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5784   (exit $ac_status); }; } &&
5785          { ac_try='test -s conftest.$ac_objext'
5786   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5787   (eval $ac_try) 2>&5
5788   ac_status=$?
5789   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5790   (exit $ac_status); }; }; then
5791   eval "$as_ac_Header=yes"
5792 else
5793   echo "$as_me: failed program was:" >&5
5794 sed 's/^/| /' conftest.$ac_ext >&5
5795
5796 eval "$as_ac_Header=no"
5797 fi
5798 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5799 fi
5800 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5801 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5802 if test `eval echo '${'$as_ac_Header'}'` = yes; then
5803   cat >>confdefs.h <<_ACEOF
5804 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5805 _ACEOF
5806
5807 fi
5808
5809 done
5810
5811
5812 echo "$as_me:$LINENO: checking for off_t" >&5
5813 echo $ECHO_N "checking for off_t... $ECHO_C" >&6
5814 if test "${ac_cv_type_off_t+set}" = set; then
5815   echo $ECHO_N "(cached) $ECHO_C" >&6
5816 else
5817   cat >conftest.$ac_ext <<_ACEOF
5818 /* confdefs.h.  */
5819 _ACEOF
5820 cat confdefs.h >>conftest.$ac_ext
5821 cat >>conftest.$ac_ext <<_ACEOF
5822 /* end confdefs.h.  */
5823 $ac_includes_default
5824 int
5825 main ()
5826 {
5827 if ((off_t *) 0)
5828   return 0;
5829 if (sizeof (off_t))
5830   return 0;
5831   ;
5832   return 0;
5833 }
5834 _ACEOF
5835 rm -f conftest.$ac_objext
5836 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5837   (eval $ac_compile) 2>conftest.er1
5838   ac_status=$?
5839   grep -v '^ *+' conftest.er1 >conftest.err
5840   rm -f conftest.er1
5841   cat conftest.err >&5
5842   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5843   (exit $ac_status); } &&
5844          { ac_try='test -z "$ac_c_werror_flag"
5845                          || test ! -s conftest.err'
5846   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5847   (eval $ac_try) 2>&5
5848   ac_status=$?
5849   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5850   (exit $ac_status); }; } &&
5851          { ac_try='test -s conftest.$ac_objext'
5852   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5853   (eval $ac_try) 2>&5
5854   ac_status=$?
5855   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5856   (exit $ac_status); }; }; then
5857   ac_cv_type_off_t=yes
5858 else
5859   echo "$as_me: failed program was:" >&5
5860 sed 's/^/| /' conftest.$ac_ext >&5
5861
5862 ac_cv_type_off_t=no
5863 fi
5864 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5865 fi
5866 echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5
5867 echo "${ECHO_T}$ac_cv_type_off_t" >&6
5868 if test $ac_cv_type_off_t = yes; then
5869   :
5870 else
5871
5872 cat >>confdefs.h <<_ACEOF
5873 #define off_t long
5874 _ACEOF
5875
5876 fi
5877
5878
5879 # check header files
5880 echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5881 echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5882 if test "${ac_cv_header_stdc+set}" = set; then
5883   echo $ECHO_N "(cached) $ECHO_C" >&6
5884 else
5885   cat >conftest.$ac_ext <<_ACEOF
5886 /* confdefs.h.  */
5887 _ACEOF
5888 cat confdefs.h >>conftest.$ac_ext
5889 cat >>conftest.$ac_ext <<_ACEOF
5890 /* end confdefs.h.  */
5891 #include <stdlib.h>
5892 #include <stdarg.h>
5893 #include <string.h>
5894 #include <float.h>
5895
5896 int
5897 main ()
5898 {
5899
5900   ;
5901   return 0;
5902 }
5903 _ACEOF
5904 rm -f conftest.$ac_objext
5905 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5906   (eval $ac_compile) 2>conftest.er1
5907   ac_status=$?
5908   grep -v '^ *+' conftest.er1 >conftest.err
5909   rm -f conftest.er1
5910   cat conftest.err >&5
5911   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5912   (exit $ac_status); } &&
5913          { ac_try='test -z "$ac_c_werror_flag"
5914                          || test ! -s conftest.err'
5915   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5916   (eval $ac_try) 2>&5
5917   ac_status=$?
5918   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5919   (exit $ac_status); }; } &&
5920          { ac_try='test -s conftest.$ac_objext'
5921   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5922   (eval $ac_try) 2>&5
5923   ac_status=$?
5924   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5925   (exit $ac_status); }; }; then
5926   ac_cv_header_stdc=yes
5927 else
5928   echo "$as_me: failed program was:" >&5
5929 sed 's/^/| /' conftest.$ac_ext >&5
5930
5931 ac_cv_header_stdc=no
5932 fi
5933 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5934
5935 if test $ac_cv_header_stdc = yes; then
5936   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5937   cat >conftest.$ac_ext <<_ACEOF
5938 /* confdefs.h.  */
5939 _ACEOF
5940 cat confdefs.h >>conftest.$ac_ext
5941 cat >>conftest.$ac_ext <<_ACEOF
5942 /* end confdefs.h.  */
5943 #include <string.h>
5944
5945 _ACEOF
5946 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5947   $EGREP "memchr" >/dev/null 2>&1; then
5948   :
5949 else
5950   ac_cv_header_stdc=no
5951 fi
5952 rm -f conftest*
5953
5954 fi
5955
5956 if test $ac_cv_header_stdc = yes; then
5957   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5958   cat >conftest.$ac_ext <<_ACEOF
5959 /* confdefs.h.  */
5960 _ACEOF
5961 cat confdefs.h >>conftest.$ac_ext
5962 cat >>conftest.$ac_ext <<_ACEOF
5963 /* end confdefs.h.  */
5964 #include <stdlib.h>
5965
5966 _ACEOF
5967 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5968   $EGREP "free" >/dev/null 2>&1; then
5969   :
5970 else
5971   ac_cv_header_stdc=no
5972 fi
5973 rm -f conftest*
5974
5975 fi
5976
5977 if test $ac_cv_header_stdc = yes; then
5978   # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5979   if test "$cross_compiling" = yes; then
5980   :
5981 else
5982   cat >conftest.$ac_ext <<_ACEOF
5983 /* confdefs.h.  */
5984 _ACEOF
5985 cat confdefs.h >>conftest.$ac_ext
5986 cat >>conftest.$ac_ext <<_ACEOF
5987 /* end confdefs.h.  */
5988 #include <ctype.h>
5989 #if ((' ' & 0x0FF) == 0x020)
5990 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5991 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5992 #else
5993 # define ISLOWER(c) \
5994                    (('a' <= (c) && (c) <= 'i') \
5995                      || ('j' <= (c) && (c) <= 'r') \
5996                      || ('s' <= (c) && (c) <= 'z'))
5997 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5998 #endif
5999
6000 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
6001 int
6002 main ()
6003 {
6004   int i;
6005   for (i = 0; i < 256; i++)
6006     if (XOR (islower (i), ISLOWER (i))
6007         || toupper (i) != TOUPPER (i))
6008       exit(2);
6009   exit (0);
6010 }
6011 _ACEOF
6012 rm -f conftest$ac_exeext
6013 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6014   (eval $ac_link) 2>&5
6015   ac_status=$?
6016   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6017   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
6018   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6019   (eval $ac_try) 2>&5
6020   ac_status=$?
6021   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6022   (exit $ac_status); }; }; then
6023   :
6024 else
6025   echo "$as_me: program exited with status $ac_status" >&5
6026 echo "$as_me: failed program was:" >&5
6027 sed 's/^/| /' conftest.$ac_ext >&5
6028
6029 ( exit $ac_status )
6030 ac_cv_header_stdc=no
6031 fi
6032 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
6033 fi
6034 fi
6035 fi
6036 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
6037 echo "${ECHO_T}$ac_cv_header_stdc" >&6
6038 if test $ac_cv_header_stdc = yes; then
6039
6040 cat >>confdefs.h <<\_ACEOF
6041 #define STDC_HEADERS 1
6042 _ACEOF
6043
6044 fi
6045
6046 echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
6047 echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
6048 if test "${ac_cv_header_time+set}" = set; then
6049   echo $ECHO_N "(cached) $ECHO_C" >&6
6050 else
6051   cat >conftest.$ac_ext <<_ACEOF
6052 /* confdefs.h.  */
6053 _ACEOF
6054 cat confdefs.h >>conftest.$ac_ext
6055 cat >>conftest.$ac_ext <<_ACEOF
6056 /* end confdefs.h.  */
6057 #include <sys/types.h>
6058 #include <sys/time.h>
6059 #include <time.h>
6060
6061 int
6062 main ()
6063 {
6064 if ((struct tm *) 0)
6065 return 0;
6066   ;
6067   return 0;
6068 }
6069 _ACEOF
6070 rm -f conftest.$ac_objext
6071 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6072   (eval $ac_compile) 2>conftest.er1
6073   ac_status=$?
6074   grep -v '^ *+' conftest.er1 >conftest.err
6075   rm -f conftest.er1
6076   cat conftest.err >&5
6077   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6078   (exit $ac_status); } &&
6079          { ac_try='test -z "$ac_c_werror_flag"
6080                          || test ! -s conftest.err'
6081   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6082   (eval $ac_try) 2>&5
6083   ac_status=$?
6084   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6085   (exit $ac_status); }; } &&
6086          { ac_try='test -s conftest.$ac_objext'
6087   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6088   (eval $ac_try) 2>&5
6089   ac_status=$?
6090   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6091   (exit $ac_status); }; }; then
6092   ac_cv_header_time=yes
6093 else
6094   echo "$as_me: failed program was:" >&5
6095 sed 's/^/| /' conftest.$ac_ext >&5
6096
6097 ac_cv_header_time=no
6098 fi
6099 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6100 fi
6101 echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
6102 echo "${ECHO_T}$ac_cv_header_time" >&6
6103 if test $ac_cv_header_time = yes; then
6104
6105 cat >>confdefs.h <<\_ACEOF
6106 #define TIME_WITH_SYS_TIME 1
6107 _ACEOF
6108
6109 fi
6110
6111
6112
6113
6114
6115
6116
6117
6118 for ac_header in stdlib.h stdio.h string.h stddef.h math.h unistd.h signal.h
6119 do
6120 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6121 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6122   echo "$as_me:$LINENO: checking for $ac_header" >&5
6123 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6124 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6125   echo $ECHO_N "(cached) $ECHO_C" >&6
6126 fi
6127 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6128 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6129 else
6130   # Is the header compilable?
6131 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6132 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6133 cat >conftest.$ac_ext <<_ACEOF
6134 /* confdefs.h.  */
6135 _ACEOF
6136 cat confdefs.h >>conftest.$ac_ext
6137 cat >>conftest.$ac_ext <<_ACEOF
6138 /* end confdefs.h.  */
6139 $ac_includes_default
6140 #include <$ac_header>
6141 _ACEOF
6142 rm -f conftest.$ac_objext
6143 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6144   (eval $ac_compile) 2>conftest.er1
6145   ac_status=$?
6146   grep -v '^ *+' conftest.er1 >conftest.err
6147   rm -f conftest.er1
6148   cat conftest.err >&5
6149   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6150   (exit $ac_status); } &&
6151          { ac_try='test -z "$ac_c_werror_flag"
6152                          || test ! -s conftest.err'
6153   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6154   (eval $ac_try) 2>&5
6155   ac_status=$?
6156   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6157   (exit $ac_status); }; } &&
6158          { ac_try='test -s conftest.$ac_objext'
6159   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6160   (eval $ac_try) 2>&5
6161   ac_status=$?
6162   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6163   (exit $ac_status); }; }; then
6164   ac_header_compiler=yes
6165 else
6166   echo "$as_me: failed program was:" >&5
6167 sed 's/^/| /' conftest.$ac_ext >&5
6168
6169 ac_header_compiler=no
6170 fi
6171 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6172 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6173 echo "${ECHO_T}$ac_header_compiler" >&6
6174
6175 # Is the header present?
6176 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6177 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6178 cat >conftest.$ac_ext <<_ACEOF
6179 /* confdefs.h.  */
6180 _ACEOF
6181 cat confdefs.h >>conftest.$ac_ext
6182 cat >>conftest.$ac_ext <<_ACEOF
6183 /* end confdefs.h.  */
6184 #include <$ac_header>
6185 _ACEOF
6186 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6187   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6188   ac_status=$?
6189   grep -v '^ *+' conftest.er1 >conftest.err
6190   rm -f conftest.er1
6191   cat conftest.err >&5
6192   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6193   (exit $ac_status); } >/dev/null; then
6194   if test -s conftest.err; then
6195     ac_cpp_err=$ac_c_preproc_warn_flag
6196     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6197   else
6198     ac_cpp_err=
6199   fi
6200 else
6201   ac_cpp_err=yes
6202 fi
6203 if test -z "$ac_cpp_err"; then
6204   ac_header_preproc=yes
6205 else
6206   echo "$as_me: failed program was:" >&5
6207 sed 's/^/| /' conftest.$ac_ext >&5
6208
6209   ac_header_preproc=no
6210 fi
6211 rm -f conftest.err conftest.$ac_ext
6212 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6213 echo "${ECHO_T}$ac_header_preproc" >&6
6214
6215 # So?  What about this header?
6216 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6217   yes:no: )
6218     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6219 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6220     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6221 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6222     ac_header_preproc=yes
6223     ;;
6224   no:yes:* )
6225     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6226 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6227     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6228 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6229     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6230 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6231     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6232 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6233     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6234 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6235     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6236 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6237     (
6238       cat <<\_ASBOX
6239 ## ------------------------------------------------------ ##
6240 ## Report this to the GNU Fortran Runtime Library lists.  ##
6241 ## ------------------------------------------------------ ##
6242 _ASBOX
6243     ) |
6244       sed "s/^/$as_me: WARNING:     /" >&2
6245     ;;
6246 esac
6247 echo "$as_me:$LINENO: checking for $ac_header" >&5
6248 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6249 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6250   echo $ECHO_N "(cached) $ECHO_C" >&6
6251 else
6252   eval "$as_ac_Header=\$ac_header_preproc"
6253 fi
6254 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6255 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6256
6257 fi
6258 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6259   cat >>confdefs.h <<_ACEOF
6260 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6261 _ACEOF
6262
6263 fi
6264
6265 done
6266
6267
6268
6269
6270
6271
6272 for ac_header in time.h sys/params.h sys/time.h sys/times.h sys/resource.h
6273 do
6274 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6275 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6276   echo "$as_me:$LINENO: checking for $ac_header" >&5
6277 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6278 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6279   echo $ECHO_N "(cached) $ECHO_C" >&6
6280 fi
6281 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6282 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6283 else
6284   # Is the header compilable?
6285 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6286 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6287 cat >conftest.$ac_ext <<_ACEOF
6288 /* confdefs.h.  */
6289 _ACEOF
6290 cat confdefs.h >>conftest.$ac_ext
6291 cat >>conftest.$ac_ext <<_ACEOF
6292 /* end confdefs.h.  */
6293 $ac_includes_default
6294 #include <$ac_header>
6295 _ACEOF
6296 rm -f conftest.$ac_objext
6297 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6298   (eval $ac_compile) 2>conftest.er1
6299   ac_status=$?
6300   grep -v '^ *+' conftest.er1 >conftest.err
6301   rm -f conftest.er1
6302   cat conftest.err >&5
6303   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6304   (exit $ac_status); } &&
6305          { ac_try='test -z "$ac_c_werror_flag"
6306                          || test ! -s conftest.err'
6307   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6308   (eval $ac_try) 2>&5
6309   ac_status=$?
6310   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6311   (exit $ac_status); }; } &&
6312          { ac_try='test -s conftest.$ac_objext'
6313   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6314   (eval $ac_try) 2>&5
6315   ac_status=$?
6316   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6317   (exit $ac_status); }; }; then
6318   ac_header_compiler=yes
6319 else
6320   echo "$as_me: failed program was:" >&5
6321 sed 's/^/| /' conftest.$ac_ext >&5
6322
6323 ac_header_compiler=no
6324 fi
6325 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6326 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6327 echo "${ECHO_T}$ac_header_compiler" >&6
6328
6329 # Is the header present?
6330 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6331 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6332 cat >conftest.$ac_ext <<_ACEOF
6333 /* confdefs.h.  */
6334 _ACEOF
6335 cat confdefs.h >>conftest.$ac_ext
6336 cat >>conftest.$ac_ext <<_ACEOF
6337 /* end confdefs.h.  */
6338 #include <$ac_header>
6339 _ACEOF
6340 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6341   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6342   ac_status=$?
6343   grep -v '^ *+' conftest.er1 >conftest.err
6344   rm -f conftest.er1
6345   cat conftest.err >&5
6346   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6347   (exit $ac_status); } >/dev/null; then
6348   if test -s conftest.err; then
6349     ac_cpp_err=$ac_c_preproc_warn_flag
6350     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6351   else
6352     ac_cpp_err=
6353   fi
6354 else
6355   ac_cpp_err=yes
6356 fi
6357 if test -z "$ac_cpp_err"; then
6358   ac_header_preproc=yes
6359 else
6360   echo "$as_me: failed program was:" >&5
6361 sed 's/^/| /' conftest.$ac_ext >&5
6362
6363   ac_header_preproc=no
6364 fi
6365 rm -f conftest.err conftest.$ac_ext
6366 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6367 echo "${ECHO_T}$ac_header_preproc" >&6
6368
6369 # So?  What about this header?
6370 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6371   yes:no: )
6372     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6373 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6374     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6375 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6376     ac_header_preproc=yes
6377     ;;
6378   no:yes:* )
6379     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6380 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6381     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6382 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6383     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6384 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6385     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6386 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6387     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6388 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6389     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6390 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6391     (
6392       cat <<\_ASBOX
6393 ## ------------------------------------------------------ ##
6394 ## Report this to the GNU Fortran Runtime Library lists.  ##
6395 ## ------------------------------------------------------ ##
6396 _ASBOX
6397     ) |
6398       sed "s/^/$as_me: WARNING:     /" >&2
6399     ;;
6400 esac
6401 echo "$as_me:$LINENO: checking for $ac_header" >&5
6402 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6403 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6404   echo $ECHO_N "(cached) $ECHO_C" >&6
6405 else
6406   eval "$as_ac_Header=\$ac_header_preproc"
6407 fi
6408 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6409 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6410
6411 fi
6412 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6413   cat >>confdefs.h <<_ACEOF
6414 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6415 _ACEOF
6416
6417 fi
6418
6419 done
6420
6421
6422
6423
6424
6425
6426 for ac_header in sys/types.h sys/stat.h sys/wait.h floatingpoint.h ieeefp.h
6427 do
6428 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6429 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6430   echo "$as_me:$LINENO: checking for $ac_header" >&5
6431 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6432 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6433   echo $ECHO_N "(cached) $ECHO_C" >&6
6434 fi
6435 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6436 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6437 else
6438   # Is the header compilable?
6439 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6440 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6441 cat >conftest.$ac_ext <<_ACEOF
6442 /* confdefs.h.  */
6443 _ACEOF
6444 cat confdefs.h >>conftest.$ac_ext
6445 cat >>conftest.$ac_ext <<_ACEOF
6446 /* end confdefs.h.  */
6447 $ac_includes_default
6448 #include <$ac_header>
6449 _ACEOF
6450 rm -f conftest.$ac_objext
6451 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6452   (eval $ac_compile) 2>conftest.er1
6453   ac_status=$?
6454   grep -v '^ *+' conftest.er1 >conftest.err
6455   rm -f conftest.er1
6456   cat conftest.err >&5
6457   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6458   (exit $ac_status); } &&
6459          { ac_try='test -z "$ac_c_werror_flag"
6460                          || test ! -s conftest.err'
6461   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6462   (eval $ac_try) 2>&5
6463   ac_status=$?
6464   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6465   (exit $ac_status); }; } &&
6466          { ac_try='test -s conftest.$ac_objext'
6467   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6468   (eval $ac_try) 2>&5
6469   ac_status=$?
6470   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6471   (exit $ac_status); }; }; then
6472   ac_header_compiler=yes
6473 else
6474   echo "$as_me: failed program was:" >&5
6475 sed 's/^/| /' conftest.$ac_ext >&5
6476
6477 ac_header_compiler=no
6478 fi
6479 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6480 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6481 echo "${ECHO_T}$ac_header_compiler" >&6
6482
6483 # Is the header present?
6484 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6485 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6486 cat >conftest.$ac_ext <<_ACEOF
6487 /* confdefs.h.  */
6488 _ACEOF
6489 cat confdefs.h >>conftest.$ac_ext
6490 cat >>conftest.$ac_ext <<_ACEOF
6491 /* end confdefs.h.  */
6492 #include <$ac_header>
6493 _ACEOF
6494 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6495   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6496   ac_status=$?
6497   grep -v '^ *+' conftest.er1 >conftest.err
6498   rm -f conftest.er1
6499   cat conftest.err >&5
6500   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6501   (exit $ac_status); } >/dev/null; then
6502   if test -s conftest.err; then
6503     ac_cpp_err=$ac_c_preproc_warn_flag
6504     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6505   else
6506     ac_cpp_err=
6507   fi
6508 else
6509   ac_cpp_err=yes
6510 fi
6511 if test -z "$ac_cpp_err"; then
6512   ac_header_preproc=yes
6513 else
6514   echo "$as_me: failed program was:" >&5
6515 sed 's/^/| /' conftest.$ac_ext >&5
6516
6517   ac_header_preproc=no
6518 fi
6519 rm -f conftest.err conftest.$ac_ext
6520 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6521 echo "${ECHO_T}$ac_header_preproc" >&6
6522
6523 # So?  What about this header?
6524 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6525   yes:no: )
6526     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6527 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6528     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6529 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6530     ac_header_preproc=yes
6531     ;;
6532   no:yes:* )
6533     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6534 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6535     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6536 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6537     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6538 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6539     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6540 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6541     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6542 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6543     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6544 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6545     (
6546       cat <<\_ASBOX
6547 ## ------------------------------------------------------ ##
6548 ## Report this to the GNU Fortran Runtime Library lists.  ##
6549 ## ------------------------------------------------------ ##
6550 _ASBOX
6551     ) |
6552       sed "s/^/$as_me: WARNING:     /" >&2
6553     ;;
6554 esac
6555 echo "$as_me:$LINENO: checking for $ac_header" >&5
6556 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6557 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6558   echo $ECHO_N "(cached) $ECHO_C" >&6
6559 else
6560   eval "$as_ac_Header=\$ac_header_preproc"
6561 fi
6562 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6563 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6564
6565 fi
6566 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6567   cat >>confdefs.h <<_ACEOF
6568 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6569 _ACEOF
6570
6571 fi
6572
6573 done
6574
6575
6576
6577
6578
6579 for ac_header in fenv.h fptrap.h float.h execinfo.h
6580 do
6581 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6582 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6583   echo "$as_me:$LINENO: checking for $ac_header" >&5
6584 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6585 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6586   echo $ECHO_N "(cached) $ECHO_C" >&6
6587 fi
6588 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6589 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6590 else
6591   # Is the header compilable?
6592 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6593 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6594 cat >conftest.$ac_ext <<_ACEOF
6595 /* confdefs.h.  */
6596 _ACEOF
6597 cat confdefs.h >>conftest.$ac_ext
6598 cat >>conftest.$ac_ext <<_ACEOF
6599 /* end confdefs.h.  */
6600 $ac_includes_default
6601 #include <$ac_header>
6602 _ACEOF
6603 rm -f conftest.$ac_objext
6604 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6605   (eval $ac_compile) 2>conftest.er1
6606   ac_status=$?
6607   grep -v '^ *+' conftest.er1 >conftest.err
6608   rm -f conftest.er1
6609   cat conftest.err >&5
6610   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6611   (exit $ac_status); } &&
6612          { ac_try='test -z "$ac_c_werror_flag"
6613                          || test ! -s conftest.err'
6614   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6615   (eval $ac_try) 2>&5
6616   ac_status=$?
6617   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6618   (exit $ac_status); }; } &&
6619          { ac_try='test -s conftest.$ac_objext'
6620   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6621   (eval $ac_try) 2>&5
6622   ac_status=$?
6623   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6624   (exit $ac_status); }; }; then
6625   ac_header_compiler=yes
6626 else
6627   echo "$as_me: failed program was:" >&5
6628 sed 's/^/| /' conftest.$ac_ext >&5
6629
6630 ac_header_compiler=no
6631 fi
6632 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6633 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6634 echo "${ECHO_T}$ac_header_compiler" >&6
6635
6636 # Is the header present?
6637 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6638 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6639 cat >conftest.$ac_ext <<_ACEOF
6640 /* confdefs.h.  */
6641 _ACEOF
6642 cat confdefs.h >>conftest.$ac_ext
6643 cat >>conftest.$ac_ext <<_ACEOF
6644 /* end confdefs.h.  */
6645 #include <$ac_header>
6646 _ACEOF
6647 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6648   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6649   ac_status=$?
6650   grep -v '^ *+' conftest.er1 >conftest.err
6651   rm -f conftest.er1
6652   cat conftest.err >&5
6653   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6654   (exit $ac_status); } >/dev/null; then
6655   if test -s conftest.err; then
6656     ac_cpp_err=$ac_c_preproc_warn_flag
6657     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6658   else
6659     ac_cpp_err=
6660   fi
6661 else
6662   ac_cpp_err=yes
6663 fi
6664 if test -z "$ac_cpp_err"; then
6665   ac_header_preproc=yes
6666 else
6667   echo "$as_me: failed program was:" >&5
6668 sed 's/^/| /' conftest.$ac_ext >&5
6669
6670   ac_header_preproc=no
6671 fi
6672 rm -f conftest.err conftest.$ac_ext
6673 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6674 echo "${ECHO_T}$ac_header_preproc" >&6
6675
6676 # So?  What about this header?
6677 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6678   yes:no: )
6679     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6680 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6681     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6682 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6683     ac_header_preproc=yes
6684     ;;
6685   no:yes:* )
6686     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6687 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6688     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6689 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6690     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6691 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6692     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6693 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6694     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6695 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6696     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6697 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6698     (
6699       cat <<\_ASBOX
6700 ## ------------------------------------------------------ ##
6701 ## Report this to the GNU Fortran Runtime Library lists.  ##
6702 ## ------------------------------------------------------ ##
6703 _ASBOX
6704     ) |
6705       sed "s/^/$as_me: WARNING:     /" >&2
6706     ;;
6707 esac
6708 echo "$as_me:$LINENO: checking for $ac_header" >&5
6709 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6710 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6711   echo $ECHO_N "(cached) $ECHO_C" >&6
6712 else
6713   eval "$as_ac_Header=\$ac_header_preproc"
6714 fi
6715 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6716 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6717
6718 fi
6719 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6720   cat >>confdefs.h <<_ACEOF
6721 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6722 _ACEOF
6723
6724 fi
6725
6726 done
6727
6728 if test "${ac_cv_header_complex_h+set}" = set; then
6729   echo "$as_me:$LINENO: checking for complex.h" >&5
6730 echo $ECHO_N "checking for complex.h... $ECHO_C" >&6
6731 if test "${ac_cv_header_complex_h+set}" = set; then
6732   echo $ECHO_N "(cached) $ECHO_C" >&6
6733 fi
6734 echo "$as_me:$LINENO: result: $ac_cv_header_complex_h" >&5
6735 echo "${ECHO_T}$ac_cv_header_complex_h" >&6
6736 else
6737   # Is the header compilable?
6738 echo "$as_me:$LINENO: checking complex.h usability" >&5
6739 echo $ECHO_N "checking complex.h usability... $ECHO_C" >&6
6740 cat >conftest.$ac_ext <<_ACEOF
6741 /* confdefs.h.  */
6742 _ACEOF
6743 cat confdefs.h >>conftest.$ac_ext
6744 cat >>conftest.$ac_ext <<_ACEOF
6745 /* end confdefs.h.  */
6746 $ac_includes_default
6747 #include <complex.h>
6748 _ACEOF
6749 rm -f conftest.$ac_objext
6750 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6751   (eval $ac_compile) 2>conftest.er1
6752   ac_status=$?
6753   grep -v '^ *+' conftest.er1 >conftest.err
6754   rm -f conftest.er1
6755   cat conftest.err >&5
6756   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6757   (exit $ac_status); } &&
6758          { ac_try='test -z "$ac_c_werror_flag"
6759                          || test ! -s conftest.err'
6760   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6761   (eval $ac_try) 2>&5
6762   ac_status=$?
6763   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6764   (exit $ac_status); }; } &&
6765          { ac_try='test -s conftest.$ac_objext'
6766   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6767   (eval $ac_try) 2>&5
6768   ac_status=$?
6769   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6770   (exit $ac_status); }; }; then
6771   ac_header_compiler=yes
6772 else
6773   echo "$as_me: failed program was:" >&5
6774 sed 's/^/| /' conftest.$ac_ext >&5
6775
6776 ac_header_compiler=no
6777 fi
6778 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6779 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6780 echo "${ECHO_T}$ac_header_compiler" >&6
6781
6782 # Is the header present?
6783 echo "$as_me:$LINENO: checking complex.h presence" >&5
6784 echo $ECHO_N "checking complex.h presence... $ECHO_C" >&6
6785 cat >conftest.$ac_ext <<_ACEOF
6786 /* confdefs.h.  */
6787 _ACEOF
6788 cat confdefs.h >>conftest.$ac_ext
6789 cat >>conftest.$ac_ext <<_ACEOF
6790 /* end confdefs.h.  */
6791 #include <complex.h>
6792 _ACEOF
6793 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6794   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6795   ac_status=$?
6796   grep -v '^ *+' conftest.er1 >conftest.err
6797   rm -f conftest.er1
6798   cat conftest.err >&5
6799   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6800   (exit $ac_status); } >/dev/null; then
6801   if test -s conftest.err; then
6802     ac_cpp_err=$ac_c_preproc_warn_flag
6803     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6804   else
6805     ac_cpp_err=
6806   fi
6807 else
6808   ac_cpp_err=yes
6809 fi
6810 if test -z "$ac_cpp_err"; then
6811   ac_header_preproc=yes
6812 else
6813   echo "$as_me: failed program was:" >&5
6814 sed 's/^/| /' conftest.$ac_ext >&5
6815
6816   ac_header_preproc=no
6817 fi
6818 rm -f conftest.err conftest.$ac_ext
6819 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6820 echo "${ECHO_T}$ac_header_preproc" >&6
6821
6822 # So?  What about this header?
6823 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6824   yes:no: )
6825     { echo "$as_me:$LINENO: WARNING: complex.h: accepted by the compiler, rejected by the preprocessor!" >&5
6826 echo "$as_me: WARNING: complex.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6827     { echo "$as_me:$LINENO: WARNING: complex.h: proceeding with the compiler's result" >&5
6828 echo "$as_me: WARNING: complex.h: proceeding with the compiler's result" >&2;}
6829     ac_header_preproc=yes
6830     ;;
6831   no:yes:* )
6832     { echo "$as_me:$LINENO: WARNING: complex.h: present but cannot be compiled" >&5
6833 echo "$as_me: WARNING: complex.h: present but cannot be compiled" >&2;}
6834     { echo "$as_me:$LINENO: WARNING: complex.h:     check for missing prerequisite headers?" >&5
6835 echo "$as_me: WARNING: complex.h:     check for missing prerequisite headers?" >&2;}
6836     { echo "$as_me:$LINENO: WARNING: complex.h: see the Autoconf documentation" >&5
6837 echo "$as_me: WARNING: complex.h: see the Autoconf documentation" >&2;}
6838     { echo "$as_me:$LINENO: WARNING: complex.h:     section \"Present But Cannot Be Compiled\"" >&5
6839 echo "$as_me: WARNING: complex.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6840     { echo "$as_me:$LINENO: WARNING: complex.h: proceeding with the preprocessor's result" >&5
6841 echo "$as_me: WARNING: complex.h: proceeding with the preprocessor's result" >&2;}
6842     { echo "$as_me:$LINENO: WARNING: complex.h: in the future, the compiler will take precedence" >&5
6843 echo "$as_me: WARNING: complex.h: in the future, the compiler will take precedence" >&2;}
6844     (
6845       cat <<\_ASBOX
6846 ## ------------------------------------------------------ ##
6847 ## Report this to the GNU Fortran Runtime Library lists.  ##
6848 ## ------------------------------------------------------ ##
6849 _ASBOX
6850     ) |
6851       sed "s/^/$as_me: WARNING:     /" >&2
6852     ;;
6853 esac
6854 echo "$as_me:$LINENO: checking for complex.h" >&5
6855 echo $ECHO_N "checking for complex.h... $ECHO_C" >&6
6856 if test "${ac_cv_header_complex_h+set}" = set; then
6857   echo $ECHO_N "(cached) $ECHO_C" >&6
6858 else
6859   ac_cv_header_complex_h=$ac_header_preproc
6860 fi
6861 echo "$as_me:$LINENO: result: $ac_cv_header_complex_h" >&5
6862 echo "${ECHO_T}$ac_cv_header_complex_h" >&6
6863
6864 fi
6865 if test $ac_cv_header_complex_h = yes; then
6866
6867 cat >>confdefs.h <<\_ACEOF
6868 #define HAVE_COMPLEX_H 1
6869 _ACEOF
6870
6871 fi
6872
6873
6874
6875
6876 inttype_headers=`echo inttypes.h sys/inttypes.h  | sed -e 's/,/ /g'`
6877
6878 acx_cv_header_stdint=stddef.h
6879 acx_cv_header_stdint_kind="(already complete)"
6880 for i in stdint.h $inttype_headers; do
6881   unset ac_cv_type_uintptr_t
6882   unset ac_cv_type_uintmax_t
6883   unset ac_cv_type_int_least32_t
6884   unset ac_cv_type_int_fast32_t
6885   unset ac_cv_type_uint64_t
6886   echo $ECHO_N "looking for a compliant stdint.h in $i, $ECHO_C" >&6
6887   echo "$as_me:$LINENO: checking for uintmax_t" >&5
6888 echo $ECHO_N "checking for uintmax_t... $ECHO_C" >&6
6889 if test "${ac_cv_type_uintmax_t+set}" = set; then
6890   echo $ECHO_N "(cached) $ECHO_C" >&6
6891 else
6892   cat >conftest.$ac_ext <<_ACEOF
6893 /* confdefs.h.  */
6894 _ACEOF
6895 cat confdefs.h >>conftest.$ac_ext
6896 cat >>conftest.$ac_ext <<_ACEOF
6897 /* end confdefs.h.  */
6898 #include <sys/types.h>
6899 #include <$i>
6900
6901 int
6902 main ()
6903 {
6904 if ((uintmax_t *) 0)
6905   return 0;
6906 if (sizeof (uintmax_t))
6907   return 0;
6908   ;
6909   return 0;
6910 }
6911 _ACEOF
6912 rm -f conftest.$ac_objext
6913 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6914   (eval $ac_compile) 2>conftest.er1
6915   ac_status=$?
6916   grep -v '^ *+' conftest.er1 >conftest.err
6917   rm -f conftest.er1
6918   cat conftest.err >&5
6919   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6920   (exit $ac_status); } &&
6921          { ac_try='test -z "$ac_c_werror_flag"
6922                          || test ! -s conftest.err'
6923   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6924   (eval $ac_try) 2>&5
6925   ac_status=$?
6926   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6927   (exit $ac_status); }; } &&
6928          { ac_try='test -s conftest.$ac_objext'
6929   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6930   (eval $ac_try) 2>&5
6931   ac_status=$?
6932   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6933   (exit $ac_status); }; }; then
6934   ac_cv_type_uintmax_t=yes
6935 else
6936   echo "$as_me: failed program was:" >&5
6937 sed 's/^/| /' conftest.$ac_ext >&5
6938
6939 ac_cv_type_uintmax_t=no
6940 fi
6941 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6942 fi
6943 echo "$as_me:$LINENO: result: $ac_cv_type_uintmax_t" >&5
6944 echo "${ECHO_T}$ac_cv_type_uintmax_t" >&6
6945 if test $ac_cv_type_uintmax_t = yes; then
6946   acx_cv_header_stdint=$i
6947 else
6948   continue
6949 fi
6950
6951   echo "$as_me:$LINENO: checking for uintptr_t" >&5
6952 echo $ECHO_N "checking for uintptr_t... $ECHO_C" >&6
6953 if test "${ac_cv_type_uintptr_t+set}" = set; then
6954   echo $ECHO_N "(cached) $ECHO_C" >&6
6955 else
6956   cat >conftest.$ac_ext <<_ACEOF
6957 /* confdefs.h.  */
6958 _ACEOF
6959 cat confdefs.h >>conftest.$ac_ext
6960 cat >>conftest.$ac_ext <<_ACEOF
6961 /* end confdefs.h.  */
6962 #include <sys/types.h>
6963 #include <$i>
6964
6965 int
6966 main ()
6967 {
6968 if ((uintptr_t *) 0)
6969   return 0;
6970 if (sizeof (uintptr_t))
6971   return 0;
6972   ;
6973   return 0;
6974 }
6975 _ACEOF
6976 rm -f conftest.$ac_objext
6977 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6978   (eval $ac_compile) 2>conftest.er1
6979   ac_status=$?
6980   grep -v '^ *+' conftest.er1 >conftest.err
6981   rm -f conftest.er1
6982   cat conftest.err >&5
6983   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6984   (exit $ac_status); } &&
6985          { ac_try='test -z "$ac_c_werror_flag"
6986                          || test ! -s conftest.err'
6987   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6988   (eval $ac_try) 2>&5
6989   ac_status=$?
6990   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6991   (exit $ac_status); }; } &&
6992          { ac_try='test -s conftest.$ac_objext'
6993   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6994   (eval $ac_try) 2>&5
6995   ac_status=$?
6996   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6997   (exit $ac_status); }; }; then
6998   ac_cv_type_uintptr_t=yes
6999 else
7000   echo "$as_me: failed program was:" >&5
7001 sed 's/^/| /' conftest.$ac_ext >&5
7002
7003 ac_cv_type_uintptr_t=no
7004 fi
7005 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7006 fi
7007 echo "$as_me:$LINENO: result: $ac_cv_type_uintptr_t" >&5
7008 echo "${ECHO_T}$ac_cv_type_uintptr_t" >&6
7009 if test $ac_cv_type_uintptr_t = yes; then
7010   :
7011 else
7012   acx_cv_header_stdint_kind="(mostly complete)"
7013 fi
7014
7015   echo "$as_me:$LINENO: checking for int_least32_t" >&5
7016 echo $ECHO_N "checking for int_least32_t... $ECHO_C" >&6
7017 if test "${ac_cv_type_int_least32_t+set}" = set; then
7018   echo $ECHO_N "(cached) $ECHO_C" >&6
7019 else
7020   cat >conftest.$ac_ext <<_ACEOF
7021 /* confdefs.h.  */
7022 _ACEOF
7023 cat confdefs.h >>conftest.$ac_ext
7024 cat >>conftest.$ac_ext <<_ACEOF
7025 /* end confdefs.h.  */
7026 #include <sys/types.h>
7027 #include <$i>
7028
7029 int
7030 main ()
7031 {
7032 if ((int_least32_t *) 0)
7033   return 0;
7034 if (sizeof (int_least32_t))
7035   return 0;
7036   ;
7037   return 0;
7038 }
7039 _ACEOF
7040 rm -f conftest.$ac_objext
7041 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7042   (eval $ac_compile) 2>conftest.er1
7043   ac_status=$?
7044   grep -v '^ *+' conftest.er1 >conftest.err
7045   rm -f conftest.er1
7046   cat conftest.err >&5
7047   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7048   (exit $ac_status); } &&
7049          { ac_try='test -z "$ac_c_werror_flag"
7050                          || test ! -s conftest.err'
7051   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7052   (eval $ac_try) 2>&5
7053   ac_status=$?
7054   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7055   (exit $ac_status); }; } &&
7056          { ac_try='test -s conftest.$ac_objext'
7057   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7058   (eval $ac_try) 2>&5
7059   ac_status=$?
7060   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7061   (exit $ac_status); }; }; then
7062   ac_cv_type_int_least32_t=yes
7063 else
7064   echo "$as_me: failed program was:" >&5
7065 sed 's/^/| /' conftest.$ac_ext >&5
7066
7067 ac_cv_type_int_least32_t=no
7068 fi
7069 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7070 fi
7071 echo "$as_me:$LINENO: result: $ac_cv_type_int_least32_t" >&5
7072 echo "${ECHO_T}$ac_cv_type_int_least32_t" >&6
7073 if test $ac_cv_type_int_least32_t = yes; then
7074   :
7075 else
7076   acx_cv_header_stdint_kind="(mostly complete)"
7077 fi
7078
7079   echo "$as_me:$LINENO: checking for int_fast32_t" >&5
7080 echo $ECHO_N "checking for int_fast32_t... $ECHO_C" >&6
7081 if test "${ac_cv_type_int_fast32_t+set}" = set; then
7082   echo $ECHO_N "(cached) $ECHO_C" >&6
7083 else
7084   cat >conftest.$ac_ext <<_ACEOF
7085 /* confdefs.h.  */
7086 _ACEOF
7087 cat confdefs.h >>conftest.$ac_ext
7088 cat >>conftest.$ac_ext <<_ACEOF
7089 /* end confdefs.h.  */
7090 #include <sys/types.h>
7091 #include <$i>
7092
7093 int
7094 main ()
7095 {
7096 if ((int_fast32_t *) 0)
7097   return 0;
7098 if (sizeof (int_fast32_t))
7099   return 0;
7100   ;
7101   return 0;
7102 }
7103 _ACEOF
7104 rm -f conftest.$ac_objext
7105 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7106   (eval $ac_compile) 2>conftest.er1
7107   ac_status=$?
7108   grep -v '^ *+' conftest.er1 >conftest.err
7109   rm -f conftest.er1
7110   cat conftest.err >&5
7111   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7112   (exit $ac_status); } &&
7113          { ac_try='test -z "$ac_c_werror_flag"
7114                          || test ! -s conftest.err'
7115   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7116   (eval $ac_try) 2>&5
7117   ac_status=$?
7118   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7119   (exit $ac_status); }; } &&
7120          { ac_try='test -s conftest.$ac_objext'
7121   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7122   (eval $ac_try) 2>&5
7123   ac_status=$?
7124   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7125   (exit $ac_status); }; }; then
7126   ac_cv_type_int_fast32_t=yes
7127 else
7128   echo "$as_me: failed program was:" >&5
7129 sed 's/^/| /' conftest.$ac_ext >&5
7130
7131 ac_cv_type_int_fast32_t=no
7132 fi
7133 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7134 fi
7135 echo "$as_me:$LINENO: result: $ac_cv_type_int_fast32_t" >&5
7136 echo "${ECHO_T}$ac_cv_type_int_fast32_t" >&6
7137 if test $ac_cv_type_int_fast32_t = yes; then
7138   :
7139 else
7140   acx_cv_header_stdint_kind="(mostly complete)"
7141 fi
7142
7143   echo "$as_me:$LINENO: checking for uint64_t" >&5
7144 echo $ECHO_N "checking for uint64_t... $ECHO_C" >&6
7145 if test "${ac_cv_type_uint64_t+set}" = set; then
7146   echo $ECHO_N "(cached) $ECHO_C" >&6
7147 else
7148   cat >conftest.$ac_ext <<_ACEOF
7149 /* confdefs.h.  */
7150 _ACEOF
7151 cat confdefs.h >>conftest.$ac_ext
7152 cat >>conftest.$ac_ext <<_ACEOF
7153 /* end confdefs.h.  */
7154 #include <sys/types.h>
7155 #include <$i>
7156
7157 int
7158 main ()
7159 {
7160 if ((uint64_t *) 0)
7161   return 0;
7162 if (sizeof (uint64_t))
7163   return 0;
7164   ;
7165   return 0;
7166 }
7167 _ACEOF
7168 rm -f conftest.$ac_objext
7169 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7170   (eval $ac_compile) 2>conftest.er1
7171   ac_status=$?
7172   grep -v '^ *+' conftest.er1 >conftest.err
7173   rm -f conftest.er1
7174   cat conftest.err >&5
7175   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7176   (exit $ac_status); } &&
7177          { ac_try='test -z "$ac_c_werror_flag"
7178                          || test ! -s conftest.err'
7179   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7180   (eval $ac_try) 2>&5
7181   ac_status=$?
7182   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7183   (exit $ac_status); }; } &&
7184          { ac_try='test -s conftest.$ac_objext'
7185   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7186   (eval $ac_try) 2>&5
7187   ac_status=$?
7188   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7189   (exit $ac_status); }; }; then
7190   ac_cv_type_uint64_t=yes
7191 else
7192   echo "$as_me: failed program was:" >&5
7193 sed 's/^/| /' conftest.$ac_ext >&5
7194
7195 ac_cv_type_uint64_t=no
7196 fi
7197 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7198 fi
7199 echo "$as_me:$LINENO: result: $ac_cv_type_uint64_t" >&5
7200 echo "${ECHO_T}$ac_cv_type_uint64_t" >&6
7201 if test $ac_cv_type_uint64_t = yes; then
7202   :
7203 else
7204   acx_cv_header_stdint_kind="(lacks uint64_t)"
7205 fi
7206
7207   break
7208 done
7209 if test "$acx_cv_header_stdint" = stddef.h; then
7210   acx_cv_header_stdint_kind="(lacks uintmax_t)"
7211   for i in stdint.h $inttype_headers; do
7212     unset ac_cv_type_uintptr_t
7213     unset ac_cv_type_uint32_t
7214     unset ac_cv_type_uint64_t
7215     echo $ECHO_N "looking for an incomplete stdint.h in $i, $ECHO_C" >&6
7216     echo "$as_me:$LINENO: checking for uint32_t" >&5
7217 echo $ECHO_N "checking for uint32_t... $ECHO_C" >&6
7218 if test "${ac_cv_type_uint32_t+set}" = set; then
7219   echo $ECHO_N "(cached) $ECHO_C" >&6
7220 else
7221   cat >conftest.$ac_ext <<_ACEOF
7222 /* confdefs.h.  */
7223 _ACEOF
7224 cat confdefs.h >>conftest.$ac_ext
7225 cat >>conftest.$ac_ext <<_ACEOF
7226 /* end confdefs.h.  */
7227 #include <sys/types.h>
7228 #include <$i>
7229
7230 int
7231 main ()
7232 {
7233 if ((uint32_t *) 0)
7234   return 0;
7235 if (sizeof (uint32_t))
7236   return 0;
7237   ;
7238   return 0;
7239 }
7240 _ACEOF
7241 rm -f conftest.$ac_objext
7242 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7243   (eval $ac_compile) 2>conftest.er1
7244   ac_status=$?
7245   grep -v '^ *+' conftest.er1 >conftest.err
7246   rm -f conftest.er1
7247   cat conftest.err >&5
7248   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7249   (exit $ac_status); } &&
7250          { ac_try='test -z "$ac_c_werror_flag"
7251                          || test ! -s conftest.err'
7252   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7253   (eval $ac_try) 2>&5
7254   ac_status=$?
7255   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7256   (exit $ac_status); }; } &&
7257          { ac_try='test -s conftest.$ac_objext'
7258   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7259   (eval $ac_try) 2>&5
7260   ac_status=$?
7261   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7262   (exit $ac_status); }; }; then
7263   ac_cv_type_uint32_t=yes
7264 else
7265   echo "$as_me: failed program was:" >&5
7266 sed 's/^/| /' conftest.$ac_ext >&5
7267
7268 ac_cv_type_uint32_t=no
7269 fi
7270 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7271 fi
7272 echo "$as_me:$LINENO: result: $ac_cv_type_uint32_t" >&5
7273 echo "${ECHO_T}$ac_cv_type_uint32_t" >&6
7274 if test $ac_cv_type_uint32_t = yes; then
7275   acx_cv_header_stdint=$i
7276 else
7277   continue
7278 fi
7279
7280     echo "$as_me:$LINENO: checking for uint64_t" >&5
7281 echo $ECHO_N "checking for uint64_t... $ECHO_C" >&6
7282 if test "${ac_cv_type_uint64_t+set}" = set; then
7283   echo $ECHO_N "(cached) $ECHO_C" >&6
7284 else
7285   cat >conftest.$ac_ext <<_ACEOF
7286 /* confdefs.h.  */
7287 _ACEOF
7288 cat confdefs.h >>conftest.$ac_ext
7289 cat >>conftest.$ac_ext <<_ACEOF
7290 /* end confdefs.h.  */
7291 #include <sys/types.h>
7292 #include <$i>
7293
7294 int
7295 main ()
7296 {
7297 if ((uint64_t *) 0)
7298   return 0;
7299 if (sizeof (uint64_t))
7300   return 0;
7301   ;
7302   return 0;
7303 }
7304 _ACEOF
7305 rm -f conftest.$ac_objext
7306 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7307   (eval $ac_compile) 2>conftest.er1
7308   ac_status=$?
7309   grep -v '^ *+' conftest.er1 >conftest.err
7310   rm -f conftest.er1
7311   cat conftest.err >&5
7312   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7313   (exit $ac_status); } &&
7314          { ac_try='test -z "$ac_c_werror_flag"
7315                          || test ! -s conftest.err'
7316   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7317   (eval $ac_try) 2>&5
7318   ac_status=$?
7319   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7320   (exit $ac_status); }; } &&
7321          { ac_try='test -s conftest.$ac_objext'
7322   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7323   (eval $ac_try) 2>&5
7324   ac_status=$?
7325   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7326   (exit $ac_status); }; }; then
7327   ac_cv_type_uint64_t=yes
7328 else
7329   echo "$as_me: failed program was:" >&5
7330 sed 's/^/| /' conftest.$ac_ext >&5
7331
7332 ac_cv_type_uint64_t=no
7333 fi
7334 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7335 fi
7336 echo "$as_me:$LINENO: result: $ac_cv_type_uint64_t" >&5
7337 echo "${ECHO_T}$ac_cv_type_uint64_t" >&6
7338
7339     echo "$as_me:$LINENO: checking for uintptr_t" >&5
7340 echo $ECHO_N "checking for uintptr_t... $ECHO_C" >&6
7341 if test "${ac_cv_type_uintptr_t+set}" = set; then
7342   echo $ECHO_N "(cached) $ECHO_C" >&6
7343 else
7344   cat >conftest.$ac_ext <<_ACEOF
7345 /* confdefs.h.  */
7346 _ACEOF
7347 cat confdefs.h >>conftest.$ac_ext
7348 cat >>conftest.$ac_ext <<_ACEOF
7349 /* end confdefs.h.  */
7350 #include <sys/types.h>
7351 #include <$i>
7352
7353 int
7354 main ()
7355 {
7356 if ((uintptr_t *) 0)
7357   return 0;
7358 if (sizeof (uintptr_t))
7359   return 0;
7360   ;
7361   return 0;
7362 }
7363 _ACEOF
7364 rm -f conftest.$ac_objext
7365 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7366   (eval $ac_compile) 2>conftest.er1
7367   ac_status=$?
7368   grep -v '^ *+' conftest.er1 >conftest.err
7369   rm -f conftest.er1
7370   cat conftest.err >&5
7371   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7372   (exit $ac_status); } &&
7373          { ac_try='test -z "$ac_c_werror_flag"
7374                          || test ! -s conftest.err'
7375   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7376   (eval $ac_try) 2>&5
7377   ac_status=$?
7378   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7379   (exit $ac_status); }; } &&
7380          { ac_try='test -s conftest.$ac_objext'
7381   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7382   (eval $ac_try) 2>&5
7383   ac_status=$?
7384   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7385   (exit $ac_status); }; }; then
7386   ac_cv_type_uintptr_t=yes
7387 else
7388   echo "$as_me: failed program was:" >&5
7389 sed 's/^/| /' conftest.$ac_ext >&5
7390
7391 ac_cv_type_uintptr_t=no
7392 fi
7393 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7394 fi
7395 echo "$as_me:$LINENO: result: $ac_cv_type_uintptr_t" >&5
7396 echo "${ECHO_T}$ac_cv_type_uintptr_t" >&6
7397
7398     break
7399   done
7400 fi
7401 if test "$acx_cv_header_stdint" = stddef.h; then
7402   acx_cv_header_stdint_kind="(u_intXX_t style)"
7403   for i in sys/types.h $inttype_headers; do
7404     unset ac_cv_type_u_int32_t
7405     unset ac_cv_type_u_int64_t
7406     echo $ECHO_N "looking for u_intXX_t types in $i, $ECHO_C" >&6
7407     echo "$as_me:$LINENO: checking for u_int32_t" >&5
7408 echo $ECHO_N "checking for u_int32_t... $ECHO_C" >&6
7409 if test "${ac_cv_type_u_int32_t+set}" = set; then
7410   echo $ECHO_N "(cached) $ECHO_C" >&6
7411 else
7412   cat >conftest.$ac_ext <<_ACEOF
7413 /* confdefs.h.  */
7414 _ACEOF
7415 cat confdefs.h >>conftest.$ac_ext
7416 cat >>conftest.$ac_ext <<_ACEOF
7417 /* end confdefs.h.  */
7418 #include <sys/types.h>
7419 #include <$i>
7420
7421 int
7422 main ()
7423 {
7424 if ((u_int32_t *) 0)
7425   return 0;
7426 if (sizeof (u_int32_t))
7427   return 0;
7428   ;
7429   return 0;
7430 }
7431 _ACEOF
7432 rm -f conftest.$ac_objext
7433 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7434   (eval $ac_compile) 2>conftest.er1
7435   ac_status=$?
7436   grep -v '^ *+' conftest.er1 >conftest.err
7437   rm -f conftest.er1
7438   cat conftest.err >&5
7439   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7440   (exit $ac_status); } &&
7441          { ac_try='test -z "$ac_c_werror_flag"
7442                          || test ! -s conftest.err'
7443   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7444   (eval $ac_try) 2>&5
7445   ac_status=$?
7446   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7447   (exit $ac_status); }; } &&
7448          { ac_try='test -s conftest.$ac_objext'
7449   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7450   (eval $ac_try) 2>&5
7451   ac_status=$?
7452   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7453   (exit $ac_status); }; }; then
7454   ac_cv_type_u_int32_t=yes
7455 else
7456   echo "$as_me: failed program was:" >&5
7457 sed 's/^/| /' conftest.$ac_ext >&5
7458
7459 ac_cv_type_u_int32_t=no
7460 fi
7461 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7462 fi
7463 echo "$as_me:$LINENO: result: $ac_cv_type_u_int32_t" >&5
7464 echo "${ECHO_T}$ac_cv_type_u_int32_t" >&6
7465 if test $ac_cv_type_u_int32_t = yes; then
7466   acx_cv_header_stdint=$i
7467 else
7468   continue
7469 fi
7470
7471     echo "$as_me:$LINENO: checking for u_int64_t" >&5
7472 echo $ECHO_N "checking for u_int64_t... $ECHO_C" >&6
7473 if test "${ac_cv_type_u_int64_t+set}" = set; then
7474   echo $ECHO_N "(cached) $ECHO_C" >&6
7475 else
7476   cat >conftest.$ac_ext <<_ACEOF
7477 /* confdefs.h.  */
7478 _ACEOF
7479 cat confdefs.h >>conftest.$ac_ext
7480 cat >>conftest.$ac_ext <<_ACEOF
7481 /* end confdefs.h.  */
7482 #include <sys/types.h>
7483 #include <$i>
7484
7485 int
7486 main ()
7487 {
7488 if ((u_int64_t *) 0)
7489   return 0;
7490 if (sizeof (u_int64_t))
7491   return 0;
7492   ;
7493   return 0;
7494 }
7495 _ACEOF
7496 rm -f conftest.$ac_objext
7497 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7498   (eval $ac_compile) 2>conftest.er1
7499   ac_status=$?
7500   grep -v '^ *+' conftest.er1 >conftest.err
7501   rm -f conftest.er1
7502   cat conftest.err >&5
7503   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7504   (exit $ac_status); } &&
7505          { ac_try='test -z "$ac_c_werror_flag"
7506                          || test ! -s conftest.err'
7507   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7508   (eval $ac_try) 2>&5
7509   ac_status=$?
7510   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7511   (exit $ac_status); }; } &&
7512          { ac_try='test -s conftest.$ac_objext'
7513   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7514   (eval $ac_try) 2>&5
7515   ac_status=$?
7516   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7517   (exit $ac_status); }; }; then
7518   ac_cv_type_u_int64_t=yes
7519 else
7520   echo "$as_me: failed program was:" >&5
7521 sed 's/^/| /' conftest.$ac_ext >&5
7522
7523 ac_cv_type_u_int64_t=no
7524 fi
7525 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7526 fi
7527 echo "$as_me:$LINENO: result: $ac_cv_type_u_int64_t" >&5
7528 echo "${ECHO_T}$ac_cv_type_u_int64_t" >&6
7529
7530     break
7531   done
7532 fi
7533 if test "$acx_cv_header_stdint" = stddef.h; then
7534   acx_cv_header_stdint_kind="(using manual detection)"
7535 fi
7536
7537 test -z "$ac_cv_type_uintptr_t" && ac_cv_type_uintptr_t=no
7538 test -z "$ac_cv_type_uint64_t" && ac_cv_type_uint64_t=no
7539 test -z "$ac_cv_type_u_int64_t" && ac_cv_type_u_int64_t=no
7540 test -z "$ac_cv_type_int_least32_t" && ac_cv_type_int_least32_t=no
7541 test -z "$ac_cv_type_int_fast32_t" && ac_cv_type_int_fast32_t=no
7542
7543 # ----------------- Summarize what we found so far
7544
7545 echo "$as_me:$LINENO: checking what to include in gstdint.h" >&5
7546 echo $ECHO_N "checking what to include in gstdint.h... $ECHO_C" >&6
7547
7548 case `$as_basename gstdint.h ||
7549 $as_expr X/gstdint.h : '.*/\([^/][^/]*\)/*$' \| \
7550          Xgstdint.h : 'X\(//\)$' \| \
7551          Xgstdint.h : 'X\(/\)$' \| \
7552          .     : '\(.\)' 2>/dev/null ||
7553 echo X/gstdint.h |
7554     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
7555           /^X\/\(\/\/\)$/{ s//\1/; q; }
7556           /^X\/\(\/\).*/{ s//\1/; q; }
7557           s/.*/./; q'` in
7558   stdint.h) { echo "$as_me:$LINENO: WARNING: are you sure you want it there?" >&5
7559 echo "$as_me: WARNING: are you sure you want it there?" >&2;} ;;
7560   inttypes.h) { echo "$as_me:$LINENO: WARNING: are you sure you want it there?" >&5
7561 echo "$as_me: WARNING: are you sure you want it there?" >&2;} ;;
7562   *) ;;
7563 esac
7564
7565 echo "$as_me:$LINENO: result: $acx_cv_header_stdint $acx_cv_header_stdint_kind" >&5
7566 echo "${ECHO_T}$acx_cv_header_stdint $acx_cv_header_stdint_kind" >&6
7567
7568 # ----------------- done included file, check C basic types --------
7569
7570 # Lacking an uintptr_t?  Test size of void *
7571 case "$acx_cv_header_stdint:$ac_cv_type_uintptr_t" in
7572   stddef.h:* | *:no) echo "$as_me:$LINENO: checking for void *" >&5
7573 echo $ECHO_N "checking for void *... $ECHO_C" >&6
7574 if test "${ac_cv_type_void_p+set}" = set; then
7575   echo $ECHO_N "(cached) $ECHO_C" >&6
7576 else
7577   cat >conftest.$ac_ext <<_ACEOF
7578 /* confdefs.h.  */
7579 _ACEOF
7580 cat confdefs.h >>conftest.$ac_ext
7581 cat >>conftest.$ac_ext <<_ACEOF
7582 /* end confdefs.h.  */
7583 $ac_includes_default
7584 int
7585 main ()
7586 {
7587 if ((void * *) 0)
7588   return 0;
7589 if (sizeof (void *))
7590   return 0;
7591   ;
7592   return 0;
7593 }
7594 _ACEOF
7595 rm -f conftest.$ac_objext
7596 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7597   (eval $ac_compile) 2>conftest.er1
7598   ac_status=$?
7599   grep -v '^ *+' conftest.er1 >conftest.err
7600   rm -f conftest.er1
7601   cat conftest.err >&5
7602   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7603   (exit $ac_status); } &&
7604          { ac_try='test -z "$ac_c_werror_flag"
7605                          || test ! -s conftest.err'
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); }; } &&
7611          { ac_try='test -s conftest.$ac_objext'
7612   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7613   (eval $ac_try) 2>&5
7614   ac_status=$?
7615   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7616   (exit $ac_status); }; }; then
7617   ac_cv_type_void_p=yes
7618 else
7619   echo "$as_me: failed program was:" >&5
7620 sed 's/^/| /' conftest.$ac_ext >&5
7621
7622 ac_cv_type_void_p=no
7623 fi
7624 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7625 fi
7626 echo "$as_me:$LINENO: result: $ac_cv_type_void_p" >&5
7627 echo "${ECHO_T}$ac_cv_type_void_p" >&6
7628
7629 echo "$as_me:$LINENO: checking size of void *" >&5
7630 echo $ECHO_N "checking size of void *... $ECHO_C" >&6
7631 if test "${ac_cv_sizeof_void_p+set}" = set; then
7632   echo $ECHO_N "(cached) $ECHO_C" >&6
7633 else
7634   if test "$ac_cv_type_void_p" = yes; then
7635   # The cast to unsigned long works around a bug in the HP C Compiler
7636   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
7637   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
7638   # This bug is HP SR number 8606223364.
7639   if test "$cross_compiling" = yes; then
7640   # Depending upon the size, compute the lo and hi bounds.
7641 cat >conftest.$ac_ext <<_ACEOF
7642 /* confdefs.h.  */
7643 _ACEOF
7644 cat confdefs.h >>conftest.$ac_ext
7645 cat >>conftest.$ac_ext <<_ACEOF
7646 /* end confdefs.h.  */
7647 $ac_includes_default
7648 int
7649 main ()
7650 {
7651 static int test_array [1 - 2 * !(((long) (sizeof (void *))) >= 0)];
7652 test_array [0] = 0
7653
7654   ;
7655   return 0;
7656 }
7657 _ACEOF
7658 rm -f conftest.$ac_objext
7659 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7660   (eval $ac_compile) 2>conftest.er1
7661   ac_status=$?
7662   grep -v '^ *+' conftest.er1 >conftest.err
7663   rm -f conftest.er1
7664   cat conftest.err >&5
7665   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7666   (exit $ac_status); } &&
7667          { ac_try='test -z "$ac_c_werror_flag"
7668                          || test ! -s conftest.err'
7669   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7670   (eval $ac_try) 2>&5
7671   ac_status=$?
7672   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7673   (exit $ac_status); }; } &&
7674          { ac_try='test -s conftest.$ac_objext'
7675   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7676   (eval $ac_try) 2>&5
7677   ac_status=$?
7678   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7679   (exit $ac_status); }; }; then
7680   ac_lo=0 ac_mid=0
7681   while :; do
7682     cat >conftest.$ac_ext <<_ACEOF
7683 /* confdefs.h.  */
7684 _ACEOF
7685 cat confdefs.h >>conftest.$ac_ext
7686 cat >>conftest.$ac_ext <<_ACEOF
7687 /* end confdefs.h.  */
7688 $ac_includes_default
7689 int
7690 main ()
7691 {
7692 static int test_array [1 - 2 * !(((long) (sizeof (void *))) <= $ac_mid)];
7693 test_array [0] = 0
7694
7695   ;
7696   return 0;
7697 }
7698 _ACEOF
7699 rm -f conftest.$ac_objext
7700 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7701   (eval $ac_compile) 2>conftest.er1
7702   ac_status=$?
7703   grep -v '^ *+' conftest.er1 >conftest.err
7704   rm -f conftest.er1
7705   cat conftest.err >&5
7706   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7707   (exit $ac_status); } &&
7708          { ac_try='test -z "$ac_c_werror_flag"
7709                          || test ! -s conftest.err'
7710   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7711   (eval $ac_try) 2>&5
7712   ac_status=$?
7713   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7714   (exit $ac_status); }; } &&
7715          { ac_try='test -s conftest.$ac_objext'
7716   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7717   (eval $ac_try) 2>&5
7718   ac_status=$?
7719   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7720   (exit $ac_status); }; }; then
7721   ac_hi=$ac_mid; break
7722 else
7723   echo "$as_me: failed program was:" >&5
7724 sed 's/^/| /' conftest.$ac_ext >&5
7725
7726 ac_lo=`expr $ac_mid + 1`
7727                     if test $ac_lo -le $ac_mid; then
7728                       ac_lo= ac_hi=
7729                       break
7730                     fi
7731                     ac_mid=`expr 2 '*' $ac_mid + 1`
7732 fi
7733 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7734   done
7735 else
7736   echo "$as_me: failed program was:" >&5
7737 sed 's/^/| /' conftest.$ac_ext >&5
7738
7739 cat >conftest.$ac_ext <<_ACEOF
7740 /* confdefs.h.  */
7741 _ACEOF
7742 cat confdefs.h >>conftest.$ac_ext
7743 cat >>conftest.$ac_ext <<_ACEOF
7744 /* end confdefs.h.  */
7745 $ac_includes_default
7746 int
7747 main ()
7748 {
7749 static int test_array [1 - 2 * !(((long) (sizeof (void *))) < 0)];
7750 test_array [0] = 0
7751
7752   ;
7753   return 0;
7754 }
7755 _ACEOF
7756 rm -f conftest.$ac_objext
7757 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7758   (eval $ac_compile) 2>conftest.er1
7759   ac_status=$?
7760   grep -v '^ *+' conftest.er1 >conftest.err
7761   rm -f conftest.er1
7762   cat conftest.err >&5
7763   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7764   (exit $ac_status); } &&
7765          { ac_try='test -z "$ac_c_werror_flag"
7766                          || test ! -s conftest.err'
7767   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7768   (eval $ac_try) 2>&5
7769   ac_status=$?
7770   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7771   (exit $ac_status); }; } &&
7772          { ac_try='test -s conftest.$ac_objext'
7773   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7774   (eval $ac_try) 2>&5
7775   ac_status=$?
7776   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7777   (exit $ac_status); }; }; then
7778   ac_hi=-1 ac_mid=-1
7779   while :; do
7780     cat >conftest.$ac_ext <<_ACEOF
7781 /* confdefs.h.  */
7782 _ACEOF
7783 cat confdefs.h >>conftest.$ac_ext
7784 cat >>conftest.$ac_ext <<_ACEOF
7785 /* end confdefs.h.  */
7786 $ac_includes_default
7787 int
7788 main ()
7789 {
7790 static int test_array [1 - 2 * !(((long) (sizeof (void *))) >= $ac_mid)];
7791 test_array [0] = 0
7792
7793   ;
7794   return 0;
7795 }
7796 _ACEOF
7797 rm -f conftest.$ac_objext
7798 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7799   (eval $ac_compile) 2>conftest.er1
7800   ac_status=$?
7801   grep -v '^ *+' conftest.er1 >conftest.err
7802   rm -f conftest.er1
7803   cat conftest.err >&5
7804   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7805   (exit $ac_status); } &&
7806          { ac_try='test -z "$ac_c_werror_flag"
7807                          || test ! -s conftest.err'
7808   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7809   (eval $ac_try) 2>&5
7810   ac_status=$?
7811   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7812   (exit $ac_status); }; } &&
7813          { ac_try='test -s conftest.$ac_objext'
7814   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7815   (eval $ac_try) 2>&5
7816   ac_status=$?
7817   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7818   (exit $ac_status); }; }; then
7819   ac_lo=$ac_mid; break
7820 else
7821   echo "$as_me: failed program was:" >&5
7822 sed 's/^/| /' conftest.$ac_ext >&5
7823
7824 ac_hi=`expr '(' $ac_mid ')' - 1`
7825                        if test $ac_mid -le $ac_hi; then
7826                          ac_lo= ac_hi=
7827                          break
7828                        fi
7829                        ac_mid=`expr 2 '*' $ac_mid`
7830 fi
7831 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7832   done
7833 else
7834   echo "$as_me: failed program was:" >&5
7835 sed 's/^/| /' conftest.$ac_ext >&5
7836
7837 ac_lo= ac_hi=
7838 fi
7839 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7840 fi
7841 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7842 # Binary search between lo and hi bounds.
7843 while test "x$ac_lo" != "x$ac_hi"; do
7844   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
7845   cat >conftest.$ac_ext <<_ACEOF
7846 /* confdefs.h.  */
7847 _ACEOF
7848 cat confdefs.h >>conftest.$ac_ext
7849 cat >>conftest.$ac_ext <<_ACEOF
7850 /* end confdefs.h.  */
7851 $ac_includes_default
7852 int
7853 main ()
7854 {
7855 static int test_array [1 - 2 * !(((long) (sizeof (void *))) <= $ac_mid)];
7856 test_array [0] = 0
7857
7858   ;
7859   return 0;
7860 }
7861 _ACEOF
7862 rm -f conftest.$ac_objext
7863 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7864   (eval $ac_compile) 2>conftest.er1
7865   ac_status=$?
7866   grep -v '^ *+' conftest.er1 >conftest.err
7867   rm -f conftest.er1
7868   cat conftest.err >&5
7869   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7870   (exit $ac_status); } &&
7871          { ac_try='test -z "$ac_c_werror_flag"
7872                          || test ! -s conftest.err'
7873   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7874   (eval $ac_try) 2>&5
7875   ac_status=$?
7876   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7877   (exit $ac_status); }; } &&
7878          { ac_try='test -s conftest.$ac_objext'
7879   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7880   (eval $ac_try) 2>&5
7881   ac_status=$?
7882   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7883   (exit $ac_status); }; }; then
7884   ac_hi=$ac_mid
7885 else
7886   echo "$as_me: failed program was:" >&5
7887 sed 's/^/| /' conftest.$ac_ext >&5
7888
7889 ac_lo=`expr '(' $ac_mid ')' + 1`
7890 fi
7891 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7892 done
7893 case $ac_lo in
7894 ?*) ac_cv_sizeof_void_p=$ac_lo;;
7895 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (void *), 77
7896 See \`config.log' for more details." >&5
7897 echo "$as_me: error: cannot compute sizeof (void *), 77
7898 See \`config.log' for more details." >&2;}
7899    { (exit 1); exit 1; }; } ;;
7900 esac
7901 else
7902   if test "$cross_compiling" = yes; then
7903   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
7904 See \`config.log' for more details." >&5
7905 echo "$as_me: error: cannot run test program while cross compiling
7906 See \`config.log' for more details." >&2;}
7907    { (exit 1); exit 1; }; }
7908 else
7909   cat >conftest.$ac_ext <<_ACEOF
7910 /* confdefs.h.  */
7911 _ACEOF
7912 cat confdefs.h >>conftest.$ac_ext
7913 cat >>conftest.$ac_ext <<_ACEOF
7914 /* end confdefs.h.  */
7915 $ac_includes_default
7916 long longval () { return (long) (sizeof (void *)); }
7917 unsigned long ulongval () { return (long) (sizeof (void *)); }
7918 #include <stdio.h>
7919 #include <stdlib.h>
7920 int
7921 main ()
7922 {
7923
7924   FILE *f = fopen ("conftest.val", "w");
7925   if (! f)
7926     exit (1);
7927   if (((long) (sizeof (void *))) < 0)
7928     {
7929       long i = longval ();
7930       if (i != ((long) (sizeof (void *))))
7931         exit (1);
7932       fprintf (f, "%ld\n", i);
7933     }
7934   else
7935     {
7936       unsigned long i = ulongval ();
7937       if (i != ((long) (sizeof (void *))))
7938         exit (1);
7939       fprintf (f, "%lu\n", i);
7940     }
7941   exit (ferror (f) || fclose (f) != 0);
7942
7943   ;
7944   return 0;
7945 }
7946 _ACEOF
7947 rm -f conftest$ac_exeext
7948 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7949   (eval $ac_link) 2>&5
7950   ac_status=$?
7951   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7952   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7953   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7954   (eval $ac_try) 2>&5
7955   ac_status=$?
7956   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7957   (exit $ac_status); }; }; then
7958   ac_cv_sizeof_void_p=`cat conftest.val`
7959 else
7960   echo "$as_me: program exited with status $ac_status" >&5
7961 echo "$as_me: failed program was:" >&5
7962 sed 's/^/| /' conftest.$ac_ext >&5
7963
7964 ( exit $ac_status )
7965 { { echo "$as_me:$LINENO: error: cannot compute sizeof (void *), 77
7966 See \`config.log' for more details." >&5
7967 echo "$as_me: error: cannot compute sizeof (void *), 77
7968 See \`config.log' for more details." >&2;}
7969    { (exit 1); exit 1; }; }
7970 fi
7971 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7972 fi
7973 fi
7974 rm -f conftest.val
7975 else
7976   ac_cv_sizeof_void_p=0
7977 fi
7978 fi
7979 echo "$as_me:$LINENO: result: $ac_cv_sizeof_void_p" >&5
7980 echo "${ECHO_T}$ac_cv_sizeof_void_p" >&6
7981 cat >>confdefs.h <<_ACEOF
7982 #define SIZEOF_VOID_P $ac_cv_sizeof_void_p
7983 _ACEOF
7984
7985  ;;
7986 esac
7987
7988 # Lacking an uint64_t?  Test size of long
7989 case "$acx_cv_header_stdint:$ac_cv_type_uint64_t:$ac_cv_type_u_int64_t" in
7990   stddef.h:*:* | *:no:no) echo "$as_me:$LINENO: checking for long" >&5
7991 echo $ECHO_N "checking for long... $ECHO_C" >&6
7992 if test "${ac_cv_type_long+set}" = set; then
7993   echo $ECHO_N "(cached) $ECHO_C" >&6
7994 else
7995   cat >conftest.$ac_ext <<_ACEOF
7996 /* confdefs.h.  */
7997 _ACEOF
7998 cat confdefs.h >>conftest.$ac_ext
7999 cat >>conftest.$ac_ext <<_ACEOF
8000 /* end confdefs.h.  */
8001 $ac_includes_default
8002 int
8003 main ()
8004 {
8005 if ((long *) 0)
8006   return 0;
8007 if (sizeof (long))
8008   return 0;
8009   ;
8010   return 0;
8011 }
8012 _ACEOF
8013 rm -f conftest.$ac_objext
8014 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8015   (eval $ac_compile) 2>conftest.er1
8016   ac_status=$?
8017   grep -v '^ *+' conftest.er1 >conftest.err
8018   rm -f conftest.er1
8019   cat conftest.err >&5
8020   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8021   (exit $ac_status); } &&
8022          { ac_try='test -z "$ac_c_werror_flag"
8023                          || test ! -s conftest.err'
8024   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8025   (eval $ac_try) 2>&5
8026   ac_status=$?
8027   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8028   (exit $ac_status); }; } &&
8029          { ac_try='test -s conftest.$ac_objext'
8030   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8031   (eval $ac_try) 2>&5
8032   ac_status=$?
8033   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8034   (exit $ac_status); }; }; then
8035   ac_cv_type_long=yes
8036 else
8037   echo "$as_me: failed program was:" >&5
8038 sed 's/^/| /' conftest.$ac_ext >&5
8039
8040 ac_cv_type_long=no
8041 fi
8042 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8043 fi
8044 echo "$as_me:$LINENO: result: $ac_cv_type_long" >&5
8045 echo "${ECHO_T}$ac_cv_type_long" >&6
8046
8047 echo "$as_me:$LINENO: checking size of long" >&5
8048 echo $ECHO_N "checking size of long... $ECHO_C" >&6
8049 if test "${ac_cv_sizeof_long+set}" = set; then
8050   echo $ECHO_N "(cached) $ECHO_C" >&6
8051 else
8052   if test "$ac_cv_type_long" = yes; then
8053   # The cast to unsigned long works around a bug in the HP C Compiler
8054   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
8055   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
8056   # This bug is HP SR number 8606223364.
8057   if test "$cross_compiling" = yes; then
8058   # Depending upon the size, compute the lo and hi bounds.
8059 cat >conftest.$ac_ext <<_ACEOF
8060 /* confdefs.h.  */
8061 _ACEOF
8062 cat confdefs.h >>conftest.$ac_ext
8063 cat >>conftest.$ac_ext <<_ACEOF
8064 /* end confdefs.h.  */
8065 $ac_includes_default
8066 int
8067 main ()
8068 {
8069 static int test_array [1 - 2 * !(((long) (sizeof (long))) >= 0)];
8070 test_array [0] = 0
8071
8072   ;
8073   return 0;
8074 }
8075 _ACEOF
8076 rm -f conftest.$ac_objext
8077 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8078   (eval $ac_compile) 2>conftest.er1
8079   ac_status=$?
8080   grep -v '^ *+' conftest.er1 >conftest.err
8081   rm -f conftest.er1
8082   cat conftest.err >&5
8083   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8084   (exit $ac_status); } &&
8085          { ac_try='test -z "$ac_c_werror_flag"
8086                          || test ! -s conftest.err'
8087   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8088   (eval $ac_try) 2>&5
8089   ac_status=$?
8090   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8091   (exit $ac_status); }; } &&
8092          { ac_try='test -s conftest.$ac_objext'
8093   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8094   (eval $ac_try) 2>&5
8095   ac_status=$?
8096   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8097   (exit $ac_status); }; }; then
8098   ac_lo=0 ac_mid=0
8099   while :; do
8100     cat >conftest.$ac_ext <<_ACEOF
8101 /* confdefs.h.  */
8102 _ACEOF
8103 cat confdefs.h >>conftest.$ac_ext
8104 cat >>conftest.$ac_ext <<_ACEOF
8105 /* end confdefs.h.  */
8106 $ac_includes_default
8107 int
8108 main ()
8109 {
8110 static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];
8111 test_array [0] = 0
8112
8113   ;
8114   return 0;
8115 }
8116 _ACEOF
8117 rm -f conftest.$ac_objext
8118 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8119   (eval $ac_compile) 2>conftest.er1
8120   ac_status=$?
8121   grep -v '^ *+' conftest.er1 >conftest.err
8122   rm -f conftest.er1
8123   cat conftest.err >&5
8124   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8125   (exit $ac_status); } &&
8126          { ac_try='test -z "$ac_c_werror_flag"
8127                          || test ! -s conftest.err'
8128   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8129   (eval $ac_try) 2>&5
8130   ac_status=$?
8131   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8132   (exit $ac_status); }; } &&
8133          { ac_try='test -s conftest.$ac_objext'
8134   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8135   (eval $ac_try) 2>&5
8136   ac_status=$?
8137   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8138   (exit $ac_status); }; }; then
8139   ac_hi=$ac_mid; break
8140 else
8141   echo "$as_me: failed program was:" >&5
8142 sed 's/^/| /' conftest.$ac_ext >&5
8143
8144 ac_lo=`expr $ac_mid + 1`
8145                     if test $ac_lo -le $ac_mid; then
8146                       ac_lo= ac_hi=
8147                       break
8148                     fi
8149                     ac_mid=`expr 2 '*' $ac_mid + 1`
8150 fi
8151 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8152   done
8153 else
8154   echo "$as_me: failed program was:" >&5
8155 sed 's/^/| /' conftest.$ac_ext >&5
8156
8157 cat >conftest.$ac_ext <<_ACEOF
8158 /* confdefs.h.  */
8159 _ACEOF
8160 cat confdefs.h >>conftest.$ac_ext
8161 cat >>conftest.$ac_ext <<_ACEOF
8162 /* end confdefs.h.  */
8163 $ac_includes_default
8164 int
8165 main ()
8166 {
8167 static int test_array [1 - 2 * !(((long) (sizeof (long))) < 0)];
8168 test_array [0] = 0
8169
8170   ;
8171   return 0;
8172 }
8173 _ACEOF
8174 rm -f conftest.$ac_objext
8175 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8176   (eval $ac_compile) 2>conftest.er1
8177   ac_status=$?
8178   grep -v '^ *+' conftest.er1 >conftest.err
8179   rm -f conftest.er1
8180   cat conftest.err >&5
8181   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8182   (exit $ac_status); } &&
8183          { ac_try='test -z "$ac_c_werror_flag"
8184                          || test ! -s conftest.err'
8185   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8186   (eval $ac_try) 2>&5
8187   ac_status=$?
8188   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8189   (exit $ac_status); }; } &&
8190          { ac_try='test -s conftest.$ac_objext'
8191   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8192   (eval $ac_try) 2>&5
8193   ac_status=$?
8194   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8195   (exit $ac_status); }; }; then
8196   ac_hi=-1 ac_mid=-1
8197   while :; do
8198     cat >conftest.$ac_ext <<_ACEOF
8199 /* confdefs.h.  */
8200 _ACEOF
8201 cat confdefs.h >>conftest.$ac_ext
8202 cat >>conftest.$ac_ext <<_ACEOF
8203 /* end confdefs.h.  */
8204 $ac_includes_default
8205 int
8206 main ()
8207 {
8208 static int test_array [1 - 2 * !(((long) (sizeof (long))) >= $ac_mid)];
8209 test_array [0] = 0
8210
8211   ;
8212   return 0;
8213 }
8214 _ACEOF
8215 rm -f conftest.$ac_objext
8216 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8217   (eval $ac_compile) 2>conftest.er1
8218   ac_status=$?
8219   grep -v '^ *+' conftest.er1 >conftest.err
8220   rm -f conftest.er1
8221   cat conftest.err >&5
8222   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8223   (exit $ac_status); } &&
8224          { ac_try='test -z "$ac_c_werror_flag"
8225                          || test ! -s conftest.err'
8226   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8227   (eval $ac_try) 2>&5
8228   ac_status=$?
8229   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8230   (exit $ac_status); }; } &&
8231          { ac_try='test -s conftest.$ac_objext'
8232   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8233   (eval $ac_try) 2>&5
8234   ac_status=$?
8235   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8236   (exit $ac_status); }; }; then
8237   ac_lo=$ac_mid; break
8238 else
8239   echo "$as_me: failed program was:" >&5
8240 sed 's/^/| /' conftest.$ac_ext >&5
8241
8242 ac_hi=`expr '(' $ac_mid ')' - 1`
8243                        if test $ac_mid -le $ac_hi; then
8244                          ac_lo= ac_hi=
8245                          break
8246                        fi
8247                        ac_mid=`expr 2 '*' $ac_mid`
8248 fi
8249 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8250   done
8251 else
8252   echo "$as_me: failed program was:" >&5
8253 sed 's/^/| /' conftest.$ac_ext >&5
8254
8255 ac_lo= ac_hi=
8256 fi
8257 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8258 fi
8259 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8260 # Binary search between lo and hi bounds.
8261 while test "x$ac_lo" != "x$ac_hi"; do
8262   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
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 $ac_includes_default
8270 int
8271 main ()
8272 {
8273 static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];
8274 test_array [0] = 0
8275
8276   ;
8277   return 0;
8278 }
8279 _ACEOF
8280 rm -f conftest.$ac_objext
8281 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8282   (eval $ac_compile) 2>conftest.er1
8283   ac_status=$?
8284   grep -v '^ *+' conftest.er1 >conftest.err
8285   rm -f conftest.er1
8286   cat conftest.err >&5
8287   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8288   (exit $ac_status); } &&
8289          { ac_try='test -z "$ac_c_werror_flag"
8290                          || test ! -s conftest.err'
8291   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8292   (eval $ac_try) 2>&5
8293   ac_status=$?
8294   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8295   (exit $ac_status); }; } &&
8296          { ac_try='test -s conftest.$ac_objext'
8297   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8298   (eval $ac_try) 2>&5
8299   ac_status=$?
8300   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8301   (exit $ac_status); }; }; then
8302   ac_hi=$ac_mid
8303 else
8304   echo "$as_me: failed program was:" >&5
8305 sed 's/^/| /' conftest.$ac_ext >&5
8306
8307 ac_lo=`expr '(' $ac_mid ')' + 1`
8308 fi
8309 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8310 done
8311 case $ac_lo in
8312 ?*) ac_cv_sizeof_long=$ac_lo;;
8313 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77
8314 See \`config.log' for more details." >&5
8315 echo "$as_me: error: cannot compute sizeof (long), 77
8316 See \`config.log' for more details." >&2;}
8317    { (exit 1); exit 1; }; } ;;
8318 esac
8319 else
8320   if test "$cross_compiling" = yes; then
8321   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
8322 See \`config.log' for more details." >&5
8323 echo "$as_me: error: cannot run test program while cross compiling
8324 See \`config.log' for more details." >&2;}
8325    { (exit 1); exit 1; }; }
8326 else
8327   cat >conftest.$ac_ext <<_ACEOF
8328 /* confdefs.h.  */
8329 _ACEOF
8330 cat confdefs.h >>conftest.$ac_ext
8331 cat >>conftest.$ac_ext <<_ACEOF
8332 /* end confdefs.h.  */
8333 $ac_includes_default
8334 long longval () { return (long) (sizeof (long)); }
8335 unsigned long ulongval () { return (long) (sizeof (long)); }
8336 #include <stdio.h>
8337 #include <stdlib.h>
8338 int
8339 main ()
8340 {
8341
8342   FILE *f = fopen ("conftest.val", "w");
8343   if (! f)
8344     exit (1);
8345   if (((long) (sizeof (long))) < 0)
8346     {
8347       long i = longval ();
8348       if (i != ((long) (sizeof (long))))
8349         exit (1);
8350       fprintf (f, "%ld\n", i);
8351     }
8352   else
8353     {
8354       unsigned long i = ulongval ();
8355       if (i != ((long) (sizeof (long))))
8356         exit (1);
8357       fprintf (f, "%lu\n", i);
8358     }
8359   exit (ferror (f) || fclose (f) != 0);
8360
8361   ;
8362   return 0;
8363 }
8364 _ACEOF
8365 rm -f conftest$ac_exeext
8366 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8367   (eval $ac_link) 2>&5
8368   ac_status=$?
8369   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8370   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8371   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8372   (eval $ac_try) 2>&5
8373   ac_status=$?
8374   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8375   (exit $ac_status); }; }; then
8376   ac_cv_sizeof_long=`cat conftest.val`
8377 else
8378   echo "$as_me: program exited with status $ac_status" >&5
8379 echo "$as_me: failed program was:" >&5
8380 sed 's/^/| /' conftest.$ac_ext >&5
8381
8382 ( exit $ac_status )
8383 { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77
8384 See \`config.log' for more details." >&5
8385 echo "$as_me: error: cannot compute sizeof (long), 77
8386 See \`config.log' for more details." >&2;}
8387    { (exit 1); exit 1; }; }
8388 fi
8389 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8390 fi
8391 fi
8392 rm -f conftest.val
8393 else
8394   ac_cv_sizeof_long=0
8395 fi
8396 fi
8397 echo "$as_me:$LINENO: result: $ac_cv_sizeof_long" >&5
8398 echo "${ECHO_T}$ac_cv_sizeof_long" >&6
8399 cat >>confdefs.h <<_ACEOF
8400 #define SIZEOF_LONG $ac_cv_sizeof_long
8401 _ACEOF
8402
8403  ;;
8404 esac
8405
8406 if test $acx_cv_header_stdint = stddef.h; then
8407   # Lacking a good header?  Test size of everything and deduce all types.
8408   echo "$as_me:$LINENO: checking for int" >&5
8409 echo $ECHO_N "checking for int... $ECHO_C" >&6
8410 if test "${ac_cv_type_int+set}" = set; then
8411   echo $ECHO_N "(cached) $ECHO_C" >&6
8412 else
8413   cat >conftest.$ac_ext <<_ACEOF
8414 /* confdefs.h.  */
8415 _ACEOF
8416 cat confdefs.h >>conftest.$ac_ext
8417 cat >>conftest.$ac_ext <<_ACEOF
8418 /* end confdefs.h.  */
8419 $ac_includes_default
8420 int
8421 main ()
8422 {
8423 if ((int *) 0)
8424   return 0;
8425 if (sizeof (int))
8426   return 0;
8427   ;
8428   return 0;
8429 }
8430 _ACEOF
8431 rm -f conftest.$ac_objext
8432 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8433   (eval $ac_compile) 2>conftest.er1
8434   ac_status=$?
8435   grep -v '^ *+' conftest.er1 >conftest.err
8436   rm -f conftest.er1
8437   cat conftest.err >&5
8438   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8439   (exit $ac_status); } &&
8440          { ac_try='test -z "$ac_c_werror_flag"
8441                          || test ! -s conftest.err'
8442   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8443   (eval $ac_try) 2>&5
8444   ac_status=$?
8445   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8446   (exit $ac_status); }; } &&
8447          { ac_try='test -s conftest.$ac_objext'
8448   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8449   (eval $ac_try) 2>&5
8450   ac_status=$?
8451   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8452   (exit $ac_status); }; }; then
8453   ac_cv_type_int=yes
8454 else
8455   echo "$as_me: failed program was:" >&5
8456 sed 's/^/| /' conftest.$ac_ext >&5
8457
8458 ac_cv_type_int=no
8459 fi
8460 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8461 fi
8462 echo "$as_me:$LINENO: result: $ac_cv_type_int" >&5
8463 echo "${ECHO_T}$ac_cv_type_int" >&6
8464
8465 echo "$as_me:$LINENO: checking size of int" >&5
8466 echo $ECHO_N "checking size of int... $ECHO_C" >&6
8467 if test "${ac_cv_sizeof_int+set}" = set; then
8468   echo $ECHO_N "(cached) $ECHO_C" >&6
8469 else
8470   if test "$ac_cv_type_int" = yes; then
8471   # The cast to unsigned long works around a bug in the HP C Compiler
8472   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
8473   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
8474   # This bug is HP SR number 8606223364.
8475   if test "$cross_compiling" = yes; then
8476   # Depending upon the size, compute the lo and hi bounds.
8477 cat >conftest.$ac_ext <<_ACEOF
8478 /* confdefs.h.  */
8479 _ACEOF
8480 cat confdefs.h >>conftest.$ac_ext
8481 cat >>conftest.$ac_ext <<_ACEOF
8482 /* end confdefs.h.  */
8483 $ac_includes_default
8484 int
8485 main ()
8486 {
8487 static int test_array [1 - 2 * !(((long) (sizeof (int))) >= 0)];
8488 test_array [0] = 0
8489
8490   ;
8491   return 0;
8492 }
8493 _ACEOF
8494 rm -f conftest.$ac_objext
8495 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8496   (eval $ac_compile) 2>conftest.er1
8497   ac_status=$?
8498   grep -v '^ *+' conftest.er1 >conftest.err
8499   rm -f conftest.er1
8500   cat conftest.err >&5
8501   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8502   (exit $ac_status); } &&
8503          { ac_try='test -z "$ac_c_werror_flag"
8504                          || test ! -s conftest.err'
8505   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8506   (eval $ac_try) 2>&5
8507   ac_status=$?
8508   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8509   (exit $ac_status); }; } &&
8510          { ac_try='test -s conftest.$ac_objext'
8511   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8512   (eval $ac_try) 2>&5
8513   ac_status=$?
8514   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8515   (exit $ac_status); }; }; then
8516   ac_lo=0 ac_mid=0
8517   while :; do
8518     cat >conftest.$ac_ext <<_ACEOF
8519 /* confdefs.h.  */
8520 _ACEOF
8521 cat confdefs.h >>conftest.$ac_ext
8522 cat >>conftest.$ac_ext <<_ACEOF
8523 /* end confdefs.h.  */
8524 $ac_includes_default
8525 int
8526 main ()
8527 {
8528 static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)];
8529 test_array [0] = 0
8530
8531   ;
8532   return 0;
8533 }
8534 _ACEOF
8535 rm -f conftest.$ac_objext
8536 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8537   (eval $ac_compile) 2>conftest.er1
8538   ac_status=$?
8539   grep -v '^ *+' conftest.er1 >conftest.err
8540   rm -f conftest.er1
8541   cat conftest.err >&5
8542   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8543   (exit $ac_status); } &&
8544          { ac_try='test -z "$ac_c_werror_flag"
8545                          || test ! -s conftest.err'
8546   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8547   (eval $ac_try) 2>&5
8548   ac_status=$?
8549   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8550   (exit $ac_status); }; } &&
8551          { ac_try='test -s conftest.$ac_objext'
8552   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8553   (eval $ac_try) 2>&5
8554   ac_status=$?
8555   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8556   (exit $ac_status); }; }; then
8557   ac_hi=$ac_mid; break
8558 else
8559   echo "$as_me: failed program was:" >&5
8560 sed 's/^/| /' conftest.$ac_ext >&5
8561
8562 ac_lo=`expr $ac_mid + 1`
8563                     if test $ac_lo -le $ac_mid; then
8564                       ac_lo= ac_hi=
8565                       break
8566                     fi
8567                     ac_mid=`expr 2 '*' $ac_mid + 1`
8568 fi
8569 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8570   done
8571 else
8572   echo "$as_me: failed program was:" >&5
8573 sed 's/^/| /' conftest.$ac_ext >&5
8574
8575 cat >conftest.$ac_ext <<_ACEOF
8576 /* confdefs.h.  */
8577 _ACEOF
8578 cat confdefs.h >>conftest.$ac_ext
8579 cat >>conftest.$ac_ext <<_ACEOF
8580 /* end confdefs.h.  */
8581 $ac_includes_default
8582 int
8583 main ()
8584 {
8585 static int test_array [1 - 2 * !(((long) (sizeof (int))) < 0)];
8586 test_array [0] = 0
8587
8588   ;
8589   return 0;
8590 }
8591 _ACEOF
8592 rm -f conftest.$ac_objext
8593 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8594   (eval $ac_compile) 2>conftest.er1
8595   ac_status=$?
8596   grep -v '^ *+' conftest.er1 >conftest.err
8597   rm -f conftest.er1
8598   cat conftest.err >&5
8599   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8600   (exit $ac_status); } &&
8601          { ac_try='test -z "$ac_c_werror_flag"
8602                          || test ! -s conftest.err'
8603   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8604   (eval $ac_try) 2>&5
8605   ac_status=$?
8606   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8607   (exit $ac_status); }; } &&
8608          { ac_try='test -s conftest.$ac_objext'
8609   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8610   (eval $ac_try) 2>&5
8611   ac_status=$?
8612   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8613   (exit $ac_status); }; }; then
8614   ac_hi=-1 ac_mid=-1
8615   while :; do
8616     cat >conftest.$ac_ext <<_ACEOF
8617 /* confdefs.h.  */
8618 _ACEOF
8619 cat confdefs.h >>conftest.$ac_ext
8620 cat >>conftest.$ac_ext <<_ACEOF
8621 /* end confdefs.h.  */
8622 $ac_includes_default
8623 int
8624 main ()
8625 {
8626 static int test_array [1 - 2 * !(((long) (sizeof (int))) >= $ac_mid)];
8627 test_array [0] = 0
8628
8629   ;
8630   return 0;
8631 }
8632 _ACEOF
8633 rm -f conftest.$ac_objext
8634 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8635   (eval $ac_compile) 2>conftest.er1
8636   ac_status=$?
8637   grep -v '^ *+' conftest.er1 >conftest.err
8638   rm -f conftest.er1
8639   cat conftest.err >&5
8640   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8641   (exit $ac_status); } &&
8642          { ac_try='test -z "$ac_c_werror_flag"
8643                          || test ! -s conftest.err'
8644   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8645   (eval $ac_try) 2>&5
8646   ac_status=$?
8647   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8648   (exit $ac_status); }; } &&
8649          { ac_try='test -s conftest.$ac_objext'
8650   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8651   (eval $ac_try) 2>&5
8652   ac_status=$?
8653   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8654   (exit $ac_status); }; }; then
8655   ac_lo=$ac_mid; break
8656 else
8657   echo "$as_me: failed program was:" >&5
8658 sed 's/^/| /' conftest.$ac_ext >&5
8659
8660 ac_hi=`expr '(' $ac_mid ')' - 1`
8661                        if test $ac_mid -le $ac_hi; then
8662                          ac_lo= ac_hi=
8663                          break
8664                        fi
8665                        ac_mid=`expr 2 '*' $ac_mid`
8666 fi
8667 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8668   done
8669 else
8670   echo "$as_me: failed program was:" >&5
8671 sed 's/^/| /' conftest.$ac_ext >&5
8672
8673 ac_lo= ac_hi=
8674 fi
8675 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8676 fi
8677 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8678 # Binary search between lo and hi bounds.
8679 while test "x$ac_lo" != "x$ac_hi"; do
8680   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
8681   cat >conftest.$ac_ext <<_ACEOF
8682 /* confdefs.h.  */
8683 _ACEOF
8684 cat confdefs.h >>conftest.$ac_ext
8685 cat >>conftest.$ac_ext <<_ACEOF
8686 /* end confdefs.h.  */
8687 $ac_includes_default
8688 int
8689 main ()
8690 {
8691 static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)];
8692 test_array [0] = 0
8693
8694   ;
8695   return 0;
8696 }
8697 _ACEOF
8698 rm -f conftest.$ac_objext
8699 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8700   (eval $ac_compile) 2>conftest.er1
8701   ac_status=$?
8702   grep -v '^ *+' conftest.er1 >conftest.err
8703   rm -f conftest.er1
8704   cat conftest.err >&5
8705   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8706   (exit $ac_status); } &&
8707          { ac_try='test -z "$ac_c_werror_flag"
8708                          || test ! -s conftest.err'
8709   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8710   (eval $ac_try) 2>&5
8711   ac_status=$?
8712   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8713   (exit $ac_status); }; } &&
8714          { ac_try='test -s conftest.$ac_objext'
8715   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8716   (eval $ac_try) 2>&5
8717   ac_status=$?
8718   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8719   (exit $ac_status); }; }; then
8720   ac_hi=$ac_mid
8721 else
8722   echo "$as_me: failed program was:" >&5
8723 sed 's/^/| /' conftest.$ac_ext >&5
8724
8725 ac_lo=`expr '(' $ac_mid ')' + 1`
8726 fi
8727 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8728 done
8729 case $ac_lo in
8730 ?*) ac_cv_sizeof_int=$ac_lo;;
8731 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77
8732 See \`config.log' for more details." >&5
8733 echo "$as_me: error: cannot compute sizeof (int), 77
8734 See \`config.log' for more details." >&2;}
8735    { (exit 1); exit 1; }; } ;;
8736 esac
8737 else
8738   if test "$cross_compiling" = yes; then
8739   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
8740 See \`config.log' for more details." >&5
8741 echo "$as_me: error: cannot run test program while cross compiling
8742 See \`config.log' for more details." >&2;}
8743    { (exit 1); exit 1; }; }
8744 else
8745   cat >conftest.$ac_ext <<_ACEOF
8746 /* confdefs.h.  */
8747 _ACEOF
8748 cat confdefs.h >>conftest.$ac_ext
8749 cat >>conftest.$ac_ext <<_ACEOF
8750 /* end confdefs.h.  */
8751 $ac_includes_default
8752 long longval () { return (long) (sizeof (int)); }
8753 unsigned long ulongval () { return (long) (sizeof (int)); }
8754 #include <stdio.h>
8755 #include <stdlib.h>
8756 int
8757 main ()
8758 {
8759
8760   FILE *f = fopen ("conftest.val", "w");
8761   if (! f)
8762     exit (1);
8763   if (((long) (sizeof (int))) < 0)
8764     {
8765       long i = longval ();
8766       if (i != ((long) (sizeof (int))))
8767         exit (1);
8768       fprintf (f, "%ld\n", i);
8769     }
8770   else
8771     {
8772       unsigned long i = ulongval ();
8773       if (i != ((long) (sizeof (int))))
8774         exit (1);
8775       fprintf (f, "%lu\n", i);
8776     }
8777   exit (ferror (f) || fclose (f) != 0);
8778
8779   ;
8780   return 0;
8781 }
8782 _ACEOF
8783 rm -f conftest$ac_exeext
8784 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8785   (eval $ac_link) 2>&5
8786   ac_status=$?
8787   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8788   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8789   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8790   (eval $ac_try) 2>&5
8791   ac_status=$?
8792   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8793   (exit $ac_status); }; }; then
8794   ac_cv_sizeof_int=`cat conftest.val`
8795 else
8796   echo "$as_me: program exited with status $ac_status" >&5
8797 echo "$as_me: failed program was:" >&5
8798 sed 's/^/| /' conftest.$ac_ext >&5
8799
8800 ( exit $ac_status )
8801 { { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77
8802 See \`config.log' for more details." >&5
8803 echo "$as_me: error: cannot compute sizeof (int), 77
8804 See \`config.log' for more details." >&2;}
8805    { (exit 1); exit 1; }; }
8806 fi
8807 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8808 fi
8809 fi
8810 rm -f conftest.val
8811 else
8812   ac_cv_sizeof_int=0
8813 fi
8814 fi
8815 echo "$as_me:$LINENO: result: $ac_cv_sizeof_int" >&5
8816 echo "${ECHO_T}$ac_cv_sizeof_int" >&6
8817 cat >>confdefs.h <<_ACEOF
8818 #define SIZEOF_INT $ac_cv_sizeof_int
8819 _ACEOF
8820
8821
8822   echo "$as_me:$LINENO: checking for short" >&5
8823 echo $ECHO_N "checking for short... $ECHO_C" >&6
8824 if test "${ac_cv_type_short+set}" = set; then
8825   echo $ECHO_N "(cached) $ECHO_C" >&6
8826 else
8827   cat >conftest.$ac_ext <<_ACEOF
8828 /* confdefs.h.  */
8829 _ACEOF
8830 cat confdefs.h >>conftest.$ac_ext
8831 cat >>conftest.$ac_ext <<_ACEOF
8832 /* end confdefs.h.  */
8833 $ac_includes_default
8834 int
8835 main ()
8836 {
8837 if ((short *) 0)
8838   return 0;
8839 if (sizeof (short))
8840   return 0;
8841   ;
8842   return 0;
8843 }
8844 _ACEOF
8845 rm -f conftest.$ac_objext
8846 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8847   (eval $ac_compile) 2>conftest.er1
8848   ac_status=$?
8849   grep -v '^ *+' conftest.er1 >conftest.err
8850   rm -f conftest.er1
8851   cat conftest.err >&5
8852   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8853   (exit $ac_status); } &&
8854          { ac_try='test -z "$ac_c_werror_flag"
8855                          || test ! -s conftest.err'
8856   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8857   (eval $ac_try) 2>&5
8858   ac_status=$?
8859   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8860   (exit $ac_status); }; } &&
8861          { ac_try='test -s conftest.$ac_objext'
8862   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8863   (eval $ac_try) 2>&5
8864   ac_status=$?
8865   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8866   (exit $ac_status); }; }; then
8867   ac_cv_type_short=yes
8868 else
8869   echo "$as_me: failed program was:" >&5
8870 sed 's/^/| /' conftest.$ac_ext >&5
8871
8872 ac_cv_type_short=no
8873 fi
8874 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8875 fi
8876 echo "$as_me:$LINENO: result: $ac_cv_type_short" >&5
8877 echo "${ECHO_T}$ac_cv_type_short" >&6
8878
8879 echo "$as_me:$LINENO: checking size of short" >&5
8880 echo $ECHO_N "checking size of short... $ECHO_C" >&6
8881 if test "${ac_cv_sizeof_short+set}" = set; then
8882   echo $ECHO_N "(cached) $ECHO_C" >&6
8883 else
8884   if test "$ac_cv_type_short" = yes; then
8885   # The cast to unsigned long works around a bug in the HP C Compiler
8886   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
8887   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
8888   # This bug is HP SR number 8606223364.
8889   if test "$cross_compiling" = yes; then
8890   # Depending upon the size, compute the lo and hi bounds.
8891 cat >conftest.$ac_ext <<_ACEOF
8892 /* confdefs.h.  */
8893 _ACEOF
8894 cat confdefs.h >>conftest.$ac_ext
8895 cat >>conftest.$ac_ext <<_ACEOF
8896 /* end confdefs.h.  */
8897 $ac_includes_default
8898 int
8899 main ()
8900 {
8901 static int test_array [1 - 2 * !(((long) (sizeof (short))) >= 0)];
8902 test_array [0] = 0
8903
8904   ;
8905   return 0;
8906 }
8907 _ACEOF
8908 rm -f conftest.$ac_objext
8909 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8910   (eval $ac_compile) 2>conftest.er1
8911   ac_status=$?
8912   grep -v '^ *+' conftest.er1 >conftest.err
8913   rm -f conftest.er1
8914   cat conftest.err >&5
8915   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8916   (exit $ac_status); } &&
8917          { ac_try='test -z "$ac_c_werror_flag"
8918                          || test ! -s conftest.err'
8919   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8920   (eval $ac_try) 2>&5
8921   ac_status=$?
8922   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8923   (exit $ac_status); }; } &&
8924          { ac_try='test -s conftest.$ac_objext'
8925   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8926   (eval $ac_try) 2>&5
8927   ac_status=$?
8928   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8929   (exit $ac_status); }; }; then
8930   ac_lo=0 ac_mid=0
8931   while :; do
8932     cat >conftest.$ac_ext <<_ACEOF
8933 /* confdefs.h.  */
8934 _ACEOF
8935 cat confdefs.h >>conftest.$ac_ext
8936 cat >>conftest.$ac_ext <<_ACEOF
8937 /* end confdefs.h.  */
8938 $ac_includes_default
8939 int
8940 main ()
8941 {
8942 static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)];
8943 test_array [0] = 0
8944
8945   ;
8946   return 0;
8947 }
8948 _ACEOF
8949 rm -f conftest.$ac_objext
8950 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8951   (eval $ac_compile) 2>conftest.er1
8952   ac_status=$?
8953   grep -v '^ *+' conftest.er1 >conftest.err
8954   rm -f conftest.er1
8955   cat conftest.err >&5
8956   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8957   (exit $ac_status); } &&
8958          { ac_try='test -z "$ac_c_werror_flag"
8959                          || test ! -s conftest.err'
8960   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8961   (eval $ac_try) 2>&5
8962   ac_status=$?
8963   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8964   (exit $ac_status); }; } &&
8965          { ac_try='test -s conftest.$ac_objext'
8966   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8967   (eval $ac_try) 2>&5
8968   ac_status=$?
8969   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8970   (exit $ac_status); }; }; then
8971   ac_hi=$ac_mid; break
8972 else
8973   echo "$as_me: failed program was:" >&5
8974 sed 's/^/| /' conftest.$ac_ext >&5
8975
8976 ac_lo=`expr $ac_mid + 1`
8977                     if test $ac_lo -le $ac_mid; then
8978                       ac_lo= ac_hi=
8979                       break
8980                     fi
8981                     ac_mid=`expr 2 '*' $ac_mid + 1`
8982 fi
8983 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8984   done
8985 else
8986   echo "$as_me: failed program was:" >&5
8987 sed 's/^/| /' conftest.$ac_ext >&5
8988
8989 cat >conftest.$ac_ext <<_ACEOF
8990 /* confdefs.h.  */
8991 _ACEOF
8992 cat confdefs.h >>conftest.$ac_ext
8993 cat >>conftest.$ac_ext <<_ACEOF
8994 /* end confdefs.h.  */
8995 $ac_includes_default
8996 int
8997 main ()
8998 {
8999 static int test_array [1 - 2 * !(((long) (sizeof (short))) < 0)];
9000 test_array [0] = 0
9001
9002   ;
9003   return 0;
9004 }
9005 _ACEOF
9006 rm -f conftest.$ac_objext
9007 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9008   (eval $ac_compile) 2>conftest.er1
9009   ac_status=$?
9010   grep -v '^ *+' conftest.er1 >conftest.err
9011   rm -f conftest.er1
9012   cat conftest.err >&5
9013   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9014   (exit $ac_status); } &&
9015          { ac_try='test -z "$ac_c_werror_flag"
9016                          || test ! -s conftest.err'
9017   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9018   (eval $ac_try) 2>&5
9019   ac_status=$?
9020   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9021   (exit $ac_status); }; } &&
9022          { ac_try='test -s conftest.$ac_objext'
9023   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9024   (eval $ac_try) 2>&5
9025   ac_status=$?
9026   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9027   (exit $ac_status); }; }; then
9028   ac_hi=-1 ac_mid=-1
9029   while :; do
9030     cat >conftest.$ac_ext <<_ACEOF
9031 /* confdefs.h.  */
9032 _ACEOF
9033 cat confdefs.h >>conftest.$ac_ext
9034 cat >>conftest.$ac_ext <<_ACEOF
9035 /* end confdefs.h.  */
9036 $ac_includes_default
9037 int
9038 main ()
9039 {
9040 static int test_array [1 - 2 * !(((long) (sizeof (short))) >= $ac_mid)];
9041 test_array [0] = 0
9042
9043   ;
9044   return 0;
9045 }
9046 _ACEOF
9047 rm -f conftest.$ac_objext
9048 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9049   (eval $ac_compile) 2>conftest.er1
9050   ac_status=$?
9051   grep -v '^ *+' conftest.er1 >conftest.err
9052   rm -f conftest.er1
9053   cat conftest.err >&5
9054   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9055   (exit $ac_status); } &&
9056          { ac_try='test -z "$ac_c_werror_flag"
9057                          || test ! -s conftest.err'
9058   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9059   (eval $ac_try) 2>&5
9060   ac_status=$?
9061   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9062   (exit $ac_status); }; } &&
9063          { ac_try='test -s conftest.$ac_objext'
9064   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9065   (eval $ac_try) 2>&5
9066   ac_status=$?
9067   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9068   (exit $ac_status); }; }; then
9069   ac_lo=$ac_mid; break
9070 else
9071   echo "$as_me: failed program was:" >&5
9072 sed 's/^/| /' conftest.$ac_ext >&5
9073
9074 ac_hi=`expr '(' $ac_mid ')' - 1`
9075                        if test $ac_mid -le $ac_hi; then
9076                          ac_lo= ac_hi=
9077                          break
9078                        fi
9079                        ac_mid=`expr 2 '*' $ac_mid`
9080 fi
9081 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9082   done
9083 else
9084   echo "$as_me: failed program was:" >&5
9085 sed 's/^/| /' conftest.$ac_ext >&5
9086
9087 ac_lo= ac_hi=
9088 fi
9089 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9090 fi
9091 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9092 # Binary search between lo and hi bounds.
9093 while test "x$ac_lo" != "x$ac_hi"; do
9094   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
9095   cat >conftest.$ac_ext <<_ACEOF
9096 /* confdefs.h.  */
9097 _ACEOF
9098 cat confdefs.h >>conftest.$ac_ext
9099 cat >>conftest.$ac_ext <<_ACEOF
9100 /* end confdefs.h.  */
9101 $ac_includes_default
9102 int
9103 main ()
9104 {
9105 static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)];
9106 test_array [0] = 0
9107
9108   ;
9109   return 0;
9110 }
9111 _ACEOF
9112 rm -f conftest.$ac_objext
9113 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9114   (eval $ac_compile) 2>conftest.er1
9115   ac_status=$?
9116   grep -v '^ *+' conftest.er1 >conftest.err
9117   rm -f conftest.er1
9118   cat conftest.err >&5
9119   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9120   (exit $ac_status); } &&
9121          { ac_try='test -z "$ac_c_werror_flag"
9122                          || test ! -s conftest.err'
9123   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9124   (eval $ac_try) 2>&5
9125   ac_status=$?
9126   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9127   (exit $ac_status); }; } &&
9128          { ac_try='test -s conftest.$ac_objext'
9129   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9130   (eval $ac_try) 2>&5
9131   ac_status=$?
9132   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9133   (exit $ac_status); }; }; then
9134   ac_hi=$ac_mid
9135 else
9136   echo "$as_me: failed program was:" >&5
9137 sed 's/^/| /' conftest.$ac_ext >&5
9138
9139 ac_lo=`expr '(' $ac_mid ')' + 1`
9140 fi
9141 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9142 done
9143 case $ac_lo in
9144 ?*) ac_cv_sizeof_short=$ac_lo;;
9145 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77
9146 See \`config.log' for more details." >&5
9147 echo "$as_me: error: cannot compute sizeof (short), 77
9148 See \`config.log' for more details." >&2;}
9149    { (exit 1); exit 1; }; } ;;
9150 esac
9151 else
9152   if test "$cross_compiling" = yes; then
9153   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
9154 See \`config.log' for more details." >&5
9155 echo "$as_me: error: cannot run test program while cross compiling
9156 See \`config.log' for more details." >&2;}
9157    { (exit 1); exit 1; }; }
9158 else
9159   cat >conftest.$ac_ext <<_ACEOF
9160 /* confdefs.h.  */
9161 _ACEOF
9162 cat confdefs.h >>conftest.$ac_ext
9163 cat >>conftest.$ac_ext <<_ACEOF
9164 /* end confdefs.h.  */
9165 $ac_includes_default
9166 long longval () { return (long) (sizeof (short)); }
9167 unsigned long ulongval () { return (long) (sizeof (short)); }
9168 #include <stdio.h>
9169 #include <stdlib.h>
9170 int
9171 main ()
9172 {
9173
9174   FILE *f = fopen ("conftest.val", "w");
9175   if (! f)
9176     exit (1);
9177   if (((long) (sizeof (short))) < 0)
9178     {
9179       long i = longval ();
9180       if (i != ((long) (sizeof (short))))
9181         exit (1);
9182       fprintf (f, "%ld\n", i);
9183     }
9184   else
9185     {
9186       unsigned long i = ulongval ();
9187       if (i != ((long) (sizeof (short))))
9188         exit (1);
9189       fprintf (f, "%lu\n", i);
9190     }
9191   exit (ferror (f) || fclose (f) != 0);
9192
9193   ;
9194   return 0;
9195 }
9196 _ACEOF
9197 rm -f conftest$ac_exeext
9198 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9199   (eval $ac_link) 2>&5
9200   ac_status=$?
9201   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9202   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9203   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9204   (eval $ac_try) 2>&5
9205   ac_status=$?
9206   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9207   (exit $ac_status); }; }; then
9208   ac_cv_sizeof_short=`cat conftest.val`
9209 else
9210   echo "$as_me: program exited with status $ac_status" >&5
9211 echo "$as_me: failed program was:" >&5
9212 sed 's/^/| /' conftest.$ac_ext >&5
9213
9214 ( exit $ac_status )
9215 { { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77
9216 See \`config.log' for more details." >&5
9217 echo "$as_me: error: cannot compute sizeof (short), 77
9218 See \`config.log' for more details." >&2;}
9219    { (exit 1); exit 1; }; }
9220 fi
9221 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9222 fi
9223 fi
9224 rm -f conftest.val
9225 else
9226   ac_cv_sizeof_short=0
9227 fi
9228 fi
9229 echo "$as_me:$LINENO: result: $ac_cv_sizeof_short" >&5
9230 echo "${ECHO_T}$ac_cv_sizeof_short" >&6
9231 cat >>confdefs.h <<_ACEOF
9232 #define SIZEOF_SHORT $ac_cv_sizeof_short
9233 _ACEOF
9234
9235
9236   echo "$as_me:$LINENO: checking for char" >&5
9237 echo $ECHO_N "checking for char... $ECHO_C" >&6
9238 if test "${ac_cv_type_char+set}" = set; then
9239   echo $ECHO_N "(cached) $ECHO_C" >&6
9240 else
9241   cat >conftest.$ac_ext <<_ACEOF
9242 /* confdefs.h.  */
9243 _ACEOF
9244 cat confdefs.h >>conftest.$ac_ext
9245 cat >>conftest.$ac_ext <<_ACEOF
9246 /* end confdefs.h.  */
9247 $ac_includes_default
9248 int
9249 main ()
9250 {
9251 if ((char *) 0)
9252   return 0;
9253 if (sizeof (char))
9254   return 0;
9255   ;
9256   return 0;
9257 }
9258 _ACEOF
9259 rm -f conftest.$ac_objext
9260 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9261   (eval $ac_compile) 2>conftest.er1
9262   ac_status=$?
9263   grep -v '^ *+' conftest.er1 >conftest.err
9264   rm -f conftest.er1
9265   cat conftest.err >&5
9266   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9267   (exit $ac_status); } &&
9268          { ac_try='test -z "$ac_c_werror_flag"
9269                          || test ! -s conftest.err'
9270   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9271   (eval $ac_try) 2>&5
9272   ac_status=$?
9273   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9274   (exit $ac_status); }; } &&
9275          { ac_try='test -s conftest.$ac_objext'
9276   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9277   (eval $ac_try) 2>&5
9278   ac_status=$?
9279   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9280   (exit $ac_status); }; }; then
9281   ac_cv_type_char=yes
9282 else
9283   echo "$as_me: failed program was:" >&5
9284 sed 's/^/| /' conftest.$ac_ext >&5
9285
9286 ac_cv_type_char=no
9287 fi
9288 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9289 fi
9290 echo "$as_me:$LINENO: result: $ac_cv_type_char" >&5
9291 echo "${ECHO_T}$ac_cv_type_char" >&6
9292
9293 echo "$as_me:$LINENO: checking size of char" >&5
9294 echo $ECHO_N "checking size of char... $ECHO_C" >&6
9295 if test "${ac_cv_sizeof_char+set}" = set; then
9296   echo $ECHO_N "(cached) $ECHO_C" >&6
9297 else
9298   if test "$ac_cv_type_char" = yes; then
9299   # The cast to unsigned long works around a bug in the HP C Compiler
9300   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
9301   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
9302   # This bug is HP SR number 8606223364.
9303   if test "$cross_compiling" = yes; then
9304   # Depending upon the size, compute the lo and hi bounds.
9305 cat >conftest.$ac_ext <<_ACEOF
9306 /* confdefs.h.  */
9307 _ACEOF
9308 cat confdefs.h >>conftest.$ac_ext
9309 cat >>conftest.$ac_ext <<_ACEOF
9310 /* end confdefs.h.  */
9311 $ac_includes_default
9312 int
9313 main ()
9314 {
9315 static int test_array [1 - 2 * !(((long) (sizeof (char))) >= 0)];
9316 test_array [0] = 0
9317
9318   ;
9319   return 0;
9320 }
9321 _ACEOF
9322 rm -f conftest.$ac_objext
9323 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9324   (eval $ac_compile) 2>conftest.er1
9325   ac_status=$?
9326   grep -v '^ *+' conftest.er1 >conftest.err
9327   rm -f conftest.er1
9328   cat conftest.err >&5
9329   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9330   (exit $ac_status); } &&
9331          { ac_try='test -z "$ac_c_werror_flag"
9332                          || test ! -s conftest.err'
9333   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9334   (eval $ac_try) 2>&5
9335   ac_status=$?
9336   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9337   (exit $ac_status); }; } &&
9338          { ac_try='test -s conftest.$ac_objext'
9339   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9340   (eval $ac_try) 2>&5
9341   ac_status=$?
9342   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9343   (exit $ac_status); }; }; then
9344   ac_lo=0 ac_mid=0
9345   while :; do
9346     cat >conftest.$ac_ext <<_ACEOF
9347 /* confdefs.h.  */
9348 _ACEOF
9349 cat confdefs.h >>conftest.$ac_ext
9350 cat >>conftest.$ac_ext <<_ACEOF
9351 /* end confdefs.h.  */
9352 $ac_includes_default
9353 int
9354 main ()
9355 {
9356 static int test_array [1 - 2 * !(((long) (sizeof (char))) <= $ac_mid)];
9357 test_array [0] = 0
9358
9359   ;
9360   return 0;
9361 }
9362 _ACEOF
9363 rm -f conftest.$ac_objext
9364 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9365   (eval $ac_compile) 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_objext'
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_hi=$ac_mid; break
9386 else
9387   echo "$as_me: failed program was:" >&5
9388 sed 's/^/| /' conftest.$ac_ext >&5
9389
9390 ac_lo=`expr $ac_mid + 1`
9391                     if test $ac_lo -le $ac_mid; then
9392                       ac_lo= ac_hi=
9393                       break
9394                     fi
9395                     ac_mid=`expr 2 '*' $ac_mid + 1`
9396 fi
9397 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9398   done
9399 else
9400   echo "$as_me: failed program was:" >&5
9401 sed 's/^/| /' conftest.$ac_ext >&5
9402
9403 cat >conftest.$ac_ext <<_ACEOF
9404 /* confdefs.h.  */
9405 _ACEOF
9406 cat confdefs.h >>conftest.$ac_ext
9407 cat >>conftest.$ac_ext <<_ACEOF
9408 /* end confdefs.h.  */
9409 $ac_includes_default
9410 int
9411 main ()
9412 {
9413 static int test_array [1 - 2 * !(((long) (sizeof (char))) < 0)];
9414 test_array [0] = 0
9415
9416   ;
9417   return 0;
9418 }
9419 _ACEOF
9420 rm -f conftest.$ac_objext
9421 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9422   (eval $ac_compile) 2>conftest.er1
9423   ac_status=$?
9424   grep -v '^ *+' conftest.er1 >conftest.err
9425   rm -f conftest.er1
9426   cat conftest.err >&5
9427   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9428   (exit $ac_status); } &&
9429          { ac_try='test -z "$ac_c_werror_flag"
9430                          || test ! -s conftest.err'
9431   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9432   (eval $ac_try) 2>&5
9433   ac_status=$?
9434   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9435   (exit $ac_status); }; } &&
9436          { ac_try='test -s conftest.$ac_objext'
9437   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9438   (eval $ac_try) 2>&5
9439   ac_status=$?
9440   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9441   (exit $ac_status); }; }; then
9442   ac_hi=-1 ac_mid=-1
9443   while :; do
9444     cat >conftest.$ac_ext <<_ACEOF
9445 /* confdefs.h.  */
9446 _ACEOF
9447 cat confdefs.h >>conftest.$ac_ext
9448 cat >>conftest.$ac_ext <<_ACEOF
9449 /* end confdefs.h.  */
9450 $ac_includes_default
9451 int
9452 main ()
9453 {
9454 static int test_array [1 - 2 * !(((long) (sizeof (char))) >= $ac_mid)];
9455 test_array [0] = 0
9456
9457   ;
9458   return 0;
9459 }
9460 _ACEOF
9461 rm -f conftest.$ac_objext
9462 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9463   (eval $ac_compile) 2>conftest.er1
9464   ac_status=$?
9465   grep -v '^ *+' conftest.er1 >conftest.err
9466   rm -f conftest.er1
9467   cat conftest.err >&5
9468   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9469   (exit $ac_status); } &&
9470          { ac_try='test -z "$ac_c_werror_flag"
9471                          || test ! -s conftest.err'
9472   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9473   (eval $ac_try) 2>&5
9474   ac_status=$?
9475   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9476   (exit $ac_status); }; } &&
9477          { ac_try='test -s conftest.$ac_objext'
9478   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9479   (eval $ac_try) 2>&5
9480   ac_status=$?
9481   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9482   (exit $ac_status); }; }; then
9483   ac_lo=$ac_mid; break
9484 else
9485   echo "$as_me: failed program was:" >&5
9486 sed 's/^/| /' conftest.$ac_ext >&5
9487
9488 ac_hi=`expr '(' $ac_mid ')' - 1`
9489                        if test $ac_mid -le $ac_hi; then
9490                          ac_lo= ac_hi=
9491                          break
9492                        fi
9493                        ac_mid=`expr 2 '*' $ac_mid`
9494 fi
9495 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9496   done
9497 else
9498   echo "$as_me: failed program was:" >&5
9499 sed 's/^/| /' conftest.$ac_ext >&5
9500
9501 ac_lo= ac_hi=
9502 fi
9503 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9504 fi
9505 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9506 # Binary search between lo and hi bounds.
9507 while test "x$ac_lo" != "x$ac_hi"; do
9508   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
9509   cat >conftest.$ac_ext <<_ACEOF
9510 /* confdefs.h.  */
9511 _ACEOF
9512 cat confdefs.h >>conftest.$ac_ext
9513 cat >>conftest.$ac_ext <<_ACEOF
9514 /* end confdefs.h.  */
9515 $ac_includes_default
9516 int
9517 main ()
9518 {
9519 static int test_array [1 - 2 * !(((long) (sizeof (char))) <= $ac_mid)];
9520 test_array [0] = 0
9521
9522   ;
9523   return 0;
9524 }
9525 _ACEOF
9526 rm -f conftest.$ac_objext
9527 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9528   (eval $ac_compile) 2>conftest.er1
9529   ac_status=$?
9530   grep -v '^ *+' conftest.er1 >conftest.err
9531   rm -f conftest.er1
9532   cat conftest.err >&5
9533   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9534   (exit $ac_status); } &&
9535          { ac_try='test -z "$ac_c_werror_flag"
9536                          || test ! -s conftest.err'
9537   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9538   (eval $ac_try) 2>&5
9539   ac_status=$?
9540   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9541   (exit $ac_status); }; } &&
9542          { ac_try='test -s conftest.$ac_objext'
9543   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9544   (eval $ac_try) 2>&5
9545   ac_status=$?
9546   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9547   (exit $ac_status); }; }; then
9548   ac_hi=$ac_mid
9549 else
9550   echo "$as_me: failed program was:" >&5
9551 sed 's/^/| /' conftest.$ac_ext >&5
9552
9553 ac_lo=`expr '(' $ac_mid ')' + 1`
9554 fi
9555 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9556 done
9557 case $ac_lo in
9558 ?*) ac_cv_sizeof_char=$ac_lo;;
9559 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (char), 77
9560 See \`config.log' for more details." >&5
9561 echo "$as_me: error: cannot compute sizeof (char), 77
9562 See \`config.log' for more details." >&2;}
9563    { (exit 1); exit 1; }; } ;;
9564 esac
9565 else
9566   if test "$cross_compiling" = yes; then
9567   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
9568 See \`config.log' for more details." >&5
9569 echo "$as_me: error: cannot run test program while cross compiling
9570 See \`config.log' for more details." >&2;}
9571    { (exit 1); exit 1; }; }
9572 else
9573   cat >conftest.$ac_ext <<_ACEOF
9574 /* confdefs.h.  */
9575 _ACEOF
9576 cat confdefs.h >>conftest.$ac_ext
9577 cat >>conftest.$ac_ext <<_ACEOF
9578 /* end confdefs.h.  */
9579 $ac_includes_default
9580 long longval () { return (long) (sizeof (char)); }
9581 unsigned long ulongval () { return (long) (sizeof (char)); }
9582 #include <stdio.h>
9583 #include <stdlib.h>
9584 int
9585 main ()
9586 {
9587
9588   FILE *f = fopen ("conftest.val", "w");
9589   if (! f)
9590     exit (1);
9591   if (((long) (sizeof (char))) < 0)
9592     {
9593       long i = longval ();
9594       if (i != ((long) (sizeof (char))))
9595         exit (1);
9596       fprintf (f, "%ld\n", i);
9597     }
9598   else
9599     {
9600       unsigned long i = ulongval ();
9601       if (i != ((long) (sizeof (char))))
9602         exit (1);
9603       fprintf (f, "%lu\n", i);
9604     }
9605   exit (ferror (f) || fclose (f) != 0);
9606
9607   ;
9608   return 0;
9609 }
9610 _ACEOF
9611 rm -f conftest$ac_exeext
9612 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9613   (eval $ac_link) 2>&5
9614   ac_status=$?
9615   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9616   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9617   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9618   (eval $ac_try) 2>&5
9619   ac_status=$?
9620   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9621   (exit $ac_status); }; }; then
9622   ac_cv_sizeof_char=`cat conftest.val`
9623 else
9624   echo "$as_me: program exited with status $ac_status" >&5
9625 echo "$as_me: failed program was:" >&5
9626 sed 's/^/| /' conftest.$ac_ext >&5
9627
9628 ( exit $ac_status )
9629 { { echo "$as_me:$LINENO: error: cannot compute sizeof (char), 77
9630 See \`config.log' for more details." >&5
9631 echo "$as_me: error: cannot compute sizeof (char), 77
9632 See \`config.log' for more details." >&2;}
9633    { (exit 1); exit 1; }; }
9634 fi
9635 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9636 fi
9637 fi
9638 rm -f conftest.val
9639 else
9640   ac_cv_sizeof_char=0
9641 fi
9642 fi
9643 echo "$as_me:$LINENO: result: $ac_cv_sizeof_char" >&5
9644 echo "${ECHO_T}$ac_cv_sizeof_char" >&6
9645 cat >>confdefs.h <<_ACEOF
9646 #define SIZEOF_CHAR $ac_cv_sizeof_char
9647 _ACEOF
9648
9649
9650
9651   echo "$as_me:$LINENO: checking for type equivalent to int8_t" >&5
9652 echo $ECHO_N "checking for type equivalent to int8_t... $ECHO_C" >&6
9653   case "$ac_cv_sizeof_char" in
9654     1) acx_cv_type_int8_t=char ;;
9655     *) { { echo "$as_me:$LINENO: error: no 8-bit type" >&5
9656 echo "$as_me: error: no 8-bit type" >&2;}
9657    { (exit please report a bug); exit please report a bug; }; }
9658   esac
9659   echo "$as_me:$LINENO: result: $acx_cv_type_int8_t" >&5
9660 echo "${ECHO_T}$acx_cv_type_int8_t" >&6
9661
9662   echo "$as_me:$LINENO: checking for type equivalent to int16_t" >&5
9663 echo $ECHO_N "checking for type equivalent to int16_t... $ECHO_C" >&6
9664   case "$ac_cv_sizeof_int:$ac_cv_sizeof_short" in
9665     2:*) acx_cv_type_int16_t=int ;;
9666     *:2) acx_cv_type_int16_t=short ;;
9667     *) { { echo "$as_me:$LINENO: error: no 16-bit type" >&5
9668 echo "$as_me: error: no 16-bit type" >&2;}
9669    { (exit please report a bug); exit please report a bug; }; }
9670   esac
9671   echo "$as_me:$LINENO: result: $acx_cv_type_int16_t" >&5
9672 echo "${ECHO_T}$acx_cv_type_int16_t" >&6
9673
9674   echo "$as_me:$LINENO: checking for type equivalent to int32_t" >&5
9675 echo $ECHO_N "checking for type equivalent to int32_t... $ECHO_C" >&6
9676   case "$ac_cv_sizeof_int:$ac_cv_sizeof_long" in
9677     4:*) acx_cv_type_int32_t=int ;;
9678     *:4) acx_cv_type_int32_t=long ;;
9679     *) { { echo "$as_me:$LINENO: error: no 32-bit type" >&5
9680 echo "$as_me: error: no 32-bit type" >&2;}
9681    { (exit please report a bug); exit please report a bug; }; }
9682   esac
9683   echo "$as_me:$LINENO: result: $acx_cv_type_int32_t" >&5
9684 echo "${ECHO_T}$acx_cv_type_int32_t" >&6
9685 fi
9686
9687 # These tests are here to make the output prettier
9688
9689 if test "$ac_cv_type_uint64_t" != yes && test "$ac_cv_type_u_int64_t" != yes; then
9690   case "$ac_cv_sizeof_long" in
9691     8) acx_cv_type_int64_t=long ;;
9692   esac
9693   echo "$as_me:$LINENO: checking for type equivalent to int64_t" >&5
9694 echo $ECHO_N "checking for type equivalent to int64_t... $ECHO_C" >&6
9695   echo "$as_me:$LINENO: result: ${acx_cv_type_int64_t-'using preprocessor symbols'}" >&5
9696 echo "${ECHO_T}${acx_cv_type_int64_t-'using preprocessor symbols'}" >&6
9697 fi
9698
9699 # Now we can use the above types
9700
9701 if test "$ac_cv_type_uintptr_t" != yes; then
9702   echo "$as_me:$LINENO: checking for type equivalent to intptr_t" >&5
9703 echo $ECHO_N "checking for type equivalent to intptr_t... $ECHO_C" >&6
9704   case $ac_cv_sizeof_void_p in
9705     2) acx_cv_type_intptr_t=int16_t ;;
9706     4) acx_cv_type_intptr_t=int32_t ;;
9707     8) acx_cv_type_intptr_t=int64_t ;;
9708     *) { { echo "$as_me:$LINENO: error: no equivalent for intptr_t" >&5
9709 echo "$as_me: error: no equivalent for intptr_t" >&2;}
9710    { (exit please report a bug); exit please report a bug; }; }
9711   esac
9712   echo "$as_me:$LINENO: result: $acx_cv_type_intptr_t" >&5
9713 echo "${ECHO_T}$acx_cv_type_intptr_t" >&6
9714 fi
9715
9716 # ----------------- done all checks, emit header -------------
9717           ac_config_commands="$ac_config_commands gstdint.h"
9718
9719
9720
9721
9722 echo "$as_me:$LINENO: checking for struct stat.st_blksize" >&5
9723 echo $ECHO_N "checking for struct stat.st_blksize... $ECHO_C" >&6
9724 if test "${ac_cv_member_struct_stat_st_blksize+set}" = set; then
9725   echo $ECHO_N "(cached) $ECHO_C" >&6
9726 else
9727   cat >conftest.$ac_ext <<_ACEOF
9728 /* confdefs.h.  */
9729 _ACEOF
9730 cat confdefs.h >>conftest.$ac_ext
9731 cat >>conftest.$ac_ext <<_ACEOF
9732 /* end confdefs.h.  */
9733 $ac_includes_default
9734 int
9735 main ()
9736 {
9737 static struct stat ac_aggr;
9738 if (ac_aggr.st_blksize)
9739 return 0;
9740   ;
9741   return 0;
9742 }
9743 _ACEOF
9744 rm -f conftest.$ac_objext
9745 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9746   (eval $ac_compile) 2>conftest.er1
9747   ac_status=$?
9748   grep -v '^ *+' conftest.er1 >conftest.err
9749   rm -f conftest.er1
9750   cat conftest.err >&5
9751   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9752   (exit $ac_status); } &&
9753          { ac_try='test -z "$ac_c_werror_flag"
9754                          || test ! -s conftest.err'
9755   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9756   (eval $ac_try) 2>&5
9757   ac_status=$?
9758   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9759   (exit $ac_status); }; } &&
9760          { ac_try='test -s conftest.$ac_objext'
9761   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9762   (eval $ac_try) 2>&5
9763   ac_status=$?
9764   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9765   (exit $ac_status); }; }; then
9766   ac_cv_member_struct_stat_st_blksize=yes
9767 else
9768   echo "$as_me: failed program was:" >&5
9769 sed 's/^/| /' conftest.$ac_ext >&5
9770
9771 cat >conftest.$ac_ext <<_ACEOF
9772 /* confdefs.h.  */
9773 _ACEOF
9774 cat confdefs.h >>conftest.$ac_ext
9775 cat >>conftest.$ac_ext <<_ACEOF
9776 /* end confdefs.h.  */
9777 $ac_includes_default
9778 int
9779 main ()
9780 {
9781 static struct stat ac_aggr;
9782 if (sizeof ac_aggr.st_blksize)
9783 return 0;
9784   ;
9785   return 0;
9786 }
9787 _ACEOF
9788 rm -f conftest.$ac_objext
9789 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9790   (eval $ac_compile) 2>conftest.er1
9791   ac_status=$?
9792   grep -v '^ *+' conftest.er1 >conftest.err
9793   rm -f conftest.er1
9794   cat conftest.err >&5
9795   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9796   (exit $ac_status); } &&
9797          { ac_try='test -z "$ac_c_werror_flag"
9798                          || test ! -s conftest.err'
9799   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9800   (eval $ac_try) 2>&5
9801   ac_status=$?
9802   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9803   (exit $ac_status); }; } &&
9804          { ac_try='test -s conftest.$ac_objext'
9805   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9806   (eval $ac_try) 2>&5
9807   ac_status=$?
9808   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9809   (exit $ac_status); }; }; then
9810   ac_cv_member_struct_stat_st_blksize=yes
9811 else
9812   echo "$as_me: failed program was:" >&5
9813 sed 's/^/| /' conftest.$ac_ext >&5
9814
9815 ac_cv_member_struct_stat_st_blksize=no
9816 fi
9817 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9818 fi
9819 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9820 fi
9821 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blksize" >&5
9822 echo "${ECHO_T}$ac_cv_member_struct_stat_st_blksize" >&6
9823 if test $ac_cv_member_struct_stat_st_blksize = yes; then
9824
9825 cat >>confdefs.h <<_ACEOF
9826 #define HAVE_STRUCT_STAT_ST_BLKSIZE 1
9827 _ACEOF
9828
9829
9830 fi
9831
9832 echo "$as_me:$LINENO: checking for struct stat.st_blocks" >&5
9833 echo $ECHO_N "checking for struct stat.st_blocks... $ECHO_C" >&6
9834 if test "${ac_cv_member_struct_stat_st_blocks+set}" = set; then
9835   echo $ECHO_N "(cached) $ECHO_C" >&6
9836 else
9837   cat >conftest.$ac_ext <<_ACEOF
9838 /* confdefs.h.  */
9839 _ACEOF
9840 cat confdefs.h >>conftest.$ac_ext
9841 cat >>conftest.$ac_ext <<_ACEOF
9842 /* end confdefs.h.  */
9843 $ac_includes_default
9844 int
9845 main ()
9846 {
9847 static struct stat ac_aggr;
9848 if (ac_aggr.st_blocks)
9849 return 0;
9850   ;
9851   return 0;
9852 }
9853 _ACEOF
9854 rm -f conftest.$ac_objext
9855 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9856   (eval $ac_compile) 2>conftest.er1
9857   ac_status=$?
9858   grep -v '^ *+' conftest.er1 >conftest.err
9859   rm -f conftest.er1
9860   cat conftest.err >&5
9861   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9862   (exit $ac_status); } &&
9863          { ac_try='test -z "$ac_c_werror_flag"
9864                          || test ! -s conftest.err'
9865   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9866   (eval $ac_try) 2>&5
9867   ac_status=$?
9868   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9869   (exit $ac_status); }; } &&
9870          { ac_try='test -s conftest.$ac_objext'
9871   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9872   (eval $ac_try) 2>&5
9873   ac_status=$?
9874   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9875   (exit $ac_status); }; }; then
9876   ac_cv_member_struct_stat_st_blocks=yes
9877 else
9878   echo "$as_me: failed program was:" >&5
9879 sed 's/^/| /' conftest.$ac_ext >&5
9880
9881 cat >conftest.$ac_ext <<_ACEOF
9882 /* confdefs.h.  */
9883 _ACEOF
9884 cat confdefs.h >>conftest.$ac_ext
9885 cat >>conftest.$ac_ext <<_ACEOF
9886 /* end confdefs.h.  */
9887 $ac_includes_default
9888 int
9889 main ()
9890 {
9891 static struct stat ac_aggr;
9892 if (sizeof ac_aggr.st_blocks)
9893 return 0;
9894   ;
9895   return 0;
9896 }
9897 _ACEOF
9898 rm -f conftest.$ac_objext
9899 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9900   (eval $ac_compile) 2>conftest.er1
9901   ac_status=$?
9902   grep -v '^ *+' conftest.er1 >conftest.err
9903   rm -f conftest.er1
9904   cat conftest.err >&5
9905   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9906   (exit $ac_status); } &&
9907          { ac_try='test -z "$ac_c_werror_flag"
9908                          || test ! -s conftest.err'
9909   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9910   (eval $ac_try) 2>&5
9911   ac_status=$?
9912   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9913   (exit $ac_status); }; } &&
9914          { ac_try='test -s conftest.$ac_objext'
9915   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9916   (eval $ac_try) 2>&5
9917   ac_status=$?
9918   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9919   (exit $ac_status); }; }; then
9920   ac_cv_member_struct_stat_st_blocks=yes
9921 else
9922   echo "$as_me: failed program was:" >&5
9923 sed 's/^/| /' conftest.$ac_ext >&5
9924
9925 ac_cv_member_struct_stat_st_blocks=no
9926 fi
9927 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9928 fi
9929 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9930 fi
9931 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blocks" >&5
9932 echo "${ECHO_T}$ac_cv_member_struct_stat_st_blocks" >&6
9933 if test $ac_cv_member_struct_stat_st_blocks = yes; then
9934
9935 cat >>confdefs.h <<_ACEOF
9936 #define HAVE_STRUCT_STAT_ST_BLOCKS 1
9937 _ACEOF
9938
9939
9940 fi
9941
9942 echo "$as_me:$LINENO: checking for struct stat.st_rdev" >&5
9943 echo $ECHO_N "checking for struct stat.st_rdev... $ECHO_C" >&6
9944 if test "${ac_cv_member_struct_stat_st_rdev+set}" = set; then
9945   echo $ECHO_N "(cached) $ECHO_C" >&6
9946 else
9947   cat >conftest.$ac_ext <<_ACEOF
9948 /* confdefs.h.  */
9949 _ACEOF
9950 cat confdefs.h >>conftest.$ac_ext
9951 cat >>conftest.$ac_ext <<_ACEOF
9952 /* end confdefs.h.  */
9953 $ac_includes_default
9954 int
9955 main ()
9956 {
9957 static struct stat ac_aggr;
9958 if (ac_aggr.st_rdev)
9959 return 0;
9960   ;
9961   return 0;
9962 }
9963 _ACEOF
9964 rm -f conftest.$ac_objext
9965 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9966   (eval $ac_compile) 2>conftest.er1
9967   ac_status=$?
9968   grep -v '^ *+' conftest.er1 >conftest.err
9969   rm -f conftest.er1
9970   cat conftest.err >&5
9971   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9972   (exit $ac_status); } &&
9973          { ac_try='test -z "$ac_c_werror_flag"
9974                          || test ! -s conftest.err'
9975   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9976   (eval $ac_try) 2>&5
9977   ac_status=$?
9978   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9979   (exit $ac_status); }; } &&
9980          { ac_try='test -s conftest.$ac_objext'
9981   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9982   (eval $ac_try) 2>&5
9983   ac_status=$?
9984   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9985   (exit $ac_status); }; }; then
9986   ac_cv_member_struct_stat_st_rdev=yes
9987 else
9988   echo "$as_me: failed program was:" >&5
9989 sed 's/^/| /' conftest.$ac_ext >&5
9990
9991 cat >conftest.$ac_ext <<_ACEOF
9992 /* confdefs.h.  */
9993 _ACEOF
9994 cat confdefs.h >>conftest.$ac_ext
9995 cat >>conftest.$ac_ext <<_ACEOF
9996 /* end confdefs.h.  */
9997 $ac_includes_default
9998 int
9999 main ()
10000 {
10001 static struct stat ac_aggr;
10002 if (sizeof ac_aggr.st_rdev)
10003 return 0;
10004   ;
10005   return 0;
10006 }
10007 _ACEOF
10008 rm -f conftest.$ac_objext
10009 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10010   (eval $ac_compile) 2>conftest.er1
10011   ac_status=$?
10012   grep -v '^ *+' conftest.er1 >conftest.err
10013   rm -f conftest.er1
10014   cat conftest.err >&5
10015   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10016   (exit $ac_status); } &&
10017          { ac_try='test -z "$ac_c_werror_flag"
10018                          || test ! -s conftest.err'
10019   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10020   (eval $ac_try) 2>&5
10021   ac_status=$?
10022   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10023   (exit $ac_status); }; } &&
10024          { ac_try='test -s conftest.$ac_objext'
10025   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10026   (eval $ac_try) 2>&5
10027   ac_status=$?
10028   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10029   (exit $ac_status); }; }; then
10030   ac_cv_member_struct_stat_st_rdev=yes
10031 else
10032   echo "$as_me: failed program was:" >&5
10033 sed 's/^/| /' conftest.$ac_ext >&5
10034
10035 ac_cv_member_struct_stat_st_rdev=no
10036 fi
10037 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10038 fi
10039 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10040 fi
10041 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_rdev" >&5
10042 echo "${ECHO_T}$ac_cv_member_struct_stat_st_rdev" >&6
10043 if test $ac_cv_member_struct_stat_st_rdev = yes; then
10044
10045 cat >>confdefs.h <<_ACEOF
10046 #define HAVE_STRUCT_STAT_ST_RDEV 1
10047 _ACEOF
10048
10049
10050 fi
10051
10052
10053 # Check for library functions.
10054
10055
10056
10057
10058
10059
10060
10061
10062 for ac_func in getrusage times mkstemp strtof strtold snprintf ftruncate chsize
10063 do
10064 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10065 echo "$as_me:$LINENO: checking for $ac_func" >&5
10066 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10067 if eval "test \"\${$as_ac_var+set}\" = set"; then
10068   echo $ECHO_N "(cached) $ECHO_C" >&6
10069 else
10070   if test x$gcc_no_link = xyes; then
10071   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10072 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10073    { (exit 1); exit 1; }; }
10074 fi
10075 cat >conftest.$ac_ext <<_ACEOF
10076 /* confdefs.h.  */
10077 _ACEOF
10078 cat confdefs.h >>conftest.$ac_ext
10079 cat >>conftest.$ac_ext <<_ACEOF
10080 /* end confdefs.h.  */
10081 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10082    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10083 #define $ac_func innocuous_$ac_func
10084
10085 /* System header to define __stub macros and hopefully few prototypes,
10086     which can conflict with char $ac_func (); below.
10087     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10088     <limits.h> exists even on freestanding compilers.  */
10089
10090 #ifdef __STDC__
10091 # include <limits.h>
10092 #else
10093 # include <assert.h>
10094 #endif
10095
10096 #undef $ac_func
10097
10098 /* Override any gcc2 internal prototype to avoid an error.  */
10099 #ifdef __cplusplus
10100 extern "C"
10101 {
10102 #endif
10103 /* We use char because int might match the return type of a gcc2
10104    builtin and then its argument prototype would still apply.  */
10105 char $ac_func ();
10106 /* The GNU C library defines this for functions which it implements
10107     to always fail with ENOSYS.  Some functions are actually named
10108     something starting with __ and the normal name is an alias.  */
10109 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10110 choke me
10111 #else
10112 char (*f) () = $ac_func;
10113 #endif
10114 #ifdef __cplusplus
10115 }
10116 #endif
10117
10118 int
10119 main ()
10120 {
10121 return f != $ac_func;
10122   ;
10123   return 0;
10124 }
10125 _ACEOF
10126 rm -f conftest.$ac_objext conftest$ac_exeext
10127 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10128   (eval $ac_link) 2>conftest.er1
10129   ac_status=$?
10130   grep -v '^ *+' conftest.er1 >conftest.err
10131   rm -f conftest.er1
10132   cat conftest.err >&5
10133   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10134   (exit $ac_status); } &&
10135          { ac_try='test -z "$ac_c_werror_flag"
10136                          || test ! -s conftest.err'
10137   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10138   (eval $ac_try) 2>&5
10139   ac_status=$?
10140   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10141   (exit $ac_status); }; } &&
10142          { ac_try='test -s conftest$ac_exeext'
10143   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10144   (eval $ac_try) 2>&5
10145   ac_status=$?
10146   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10147   (exit $ac_status); }; }; then
10148   eval "$as_ac_var=yes"
10149 else
10150   echo "$as_me: failed program was:" >&5
10151 sed 's/^/| /' conftest.$ac_ext >&5
10152
10153 eval "$as_ac_var=no"
10154 fi
10155 rm -f conftest.err conftest.$ac_objext \
10156       conftest$ac_exeext conftest.$ac_ext
10157 fi
10158 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10159 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10160 if test `eval echo '${'$as_ac_var'}'` = yes; then
10161   cat >>confdefs.h <<_ACEOF
10162 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10163 _ACEOF
10164
10165 fi
10166 done
10167
10168
10169
10170
10171
10172
10173
10174
10175
10176 for ac_func in chdir strerror getlogin gethostname kill link symlink perror
10177 do
10178 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10179 echo "$as_me:$LINENO: checking for $ac_func" >&5
10180 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10181 if eval "test \"\${$as_ac_var+set}\" = set"; then
10182   echo $ECHO_N "(cached) $ECHO_C" >&6
10183 else
10184   if test x$gcc_no_link = xyes; then
10185   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10186 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10187    { (exit 1); exit 1; }; }
10188 fi
10189 cat >conftest.$ac_ext <<_ACEOF
10190 /* confdefs.h.  */
10191 _ACEOF
10192 cat confdefs.h >>conftest.$ac_ext
10193 cat >>conftest.$ac_ext <<_ACEOF
10194 /* end confdefs.h.  */
10195 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10196    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10197 #define $ac_func innocuous_$ac_func
10198
10199 /* System header to define __stub macros and hopefully few prototypes,
10200     which can conflict with char $ac_func (); below.
10201     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10202     <limits.h> exists even on freestanding compilers.  */
10203
10204 #ifdef __STDC__
10205 # include <limits.h>
10206 #else
10207 # include <assert.h>
10208 #endif
10209
10210 #undef $ac_func
10211
10212 /* Override any gcc2 internal prototype to avoid an error.  */
10213 #ifdef __cplusplus
10214 extern "C"
10215 {
10216 #endif
10217 /* We use char because int might match the return type of a gcc2
10218    builtin and then its argument prototype would still apply.  */
10219 char $ac_func ();
10220 /* The GNU C library defines this for functions which it implements
10221     to always fail with ENOSYS.  Some functions are actually named
10222     something starting with __ and the normal name is an alias.  */
10223 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10224 choke me
10225 #else
10226 char (*f) () = $ac_func;
10227 #endif
10228 #ifdef __cplusplus
10229 }
10230 #endif
10231
10232 int
10233 main ()
10234 {
10235 return f != $ac_func;
10236   ;
10237   return 0;
10238 }
10239 _ACEOF
10240 rm -f conftest.$ac_objext conftest$ac_exeext
10241 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10242   (eval $ac_link) 2>conftest.er1
10243   ac_status=$?
10244   grep -v '^ *+' conftest.er1 >conftest.err
10245   rm -f conftest.er1
10246   cat conftest.err >&5
10247   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10248   (exit $ac_status); } &&
10249          { ac_try='test -z "$ac_c_werror_flag"
10250                          || test ! -s conftest.err'
10251   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10252   (eval $ac_try) 2>&5
10253   ac_status=$?
10254   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10255   (exit $ac_status); }; } &&
10256          { ac_try='test -s conftest$ac_exeext'
10257   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10258   (eval $ac_try) 2>&5
10259   ac_status=$?
10260   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10261   (exit $ac_status); }; }; then
10262   eval "$as_ac_var=yes"
10263 else
10264   echo "$as_me: failed program was:" >&5
10265 sed 's/^/| /' conftest.$ac_ext >&5
10266
10267 eval "$as_ac_var=no"
10268 fi
10269 rm -f conftest.err conftest.$ac_objext \
10270       conftest$ac_exeext conftest.$ac_ext
10271 fi
10272 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10273 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10274 if test `eval echo '${'$as_ac_var'}'` = yes; then
10275   cat >>confdefs.h <<_ACEOF
10276 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10277 _ACEOF
10278
10279 fi
10280 done
10281
10282
10283
10284
10285
10286
10287
10288
10289
10290
10291
10292 for ac_func in sleep time ttyname signal alarm ctime clock access fork execl
10293 do
10294 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10295 echo "$as_me:$LINENO: checking for $ac_func" >&5
10296 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10297 if eval "test \"\${$as_ac_var+set}\" = set"; then
10298   echo $ECHO_N "(cached) $ECHO_C" >&6
10299 else
10300   if test x$gcc_no_link = xyes; then
10301   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10302 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10303    { (exit 1); exit 1; }; }
10304 fi
10305 cat >conftest.$ac_ext <<_ACEOF
10306 /* confdefs.h.  */
10307 _ACEOF
10308 cat confdefs.h >>conftest.$ac_ext
10309 cat >>conftest.$ac_ext <<_ACEOF
10310 /* end confdefs.h.  */
10311 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10312    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10313 #define $ac_func innocuous_$ac_func
10314
10315 /* System header to define __stub macros and hopefully few prototypes,
10316     which can conflict with char $ac_func (); below.
10317     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10318     <limits.h> exists even on freestanding compilers.  */
10319
10320 #ifdef __STDC__
10321 # include <limits.h>
10322 #else
10323 # include <assert.h>
10324 #endif
10325
10326 #undef $ac_func
10327
10328 /* Override any gcc2 internal prototype to avoid an error.  */
10329 #ifdef __cplusplus
10330 extern "C"
10331 {
10332 #endif
10333 /* We use char because int might match the return type of a gcc2
10334    builtin and then its argument prototype would still apply.  */
10335 char $ac_func ();
10336 /* The GNU C library defines this for functions which it implements
10337     to always fail with ENOSYS.  Some functions are actually named
10338     something starting with __ and the normal name is an alias.  */
10339 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10340 choke me
10341 #else
10342 char (*f) () = $ac_func;
10343 #endif
10344 #ifdef __cplusplus
10345 }
10346 #endif
10347
10348 int
10349 main ()
10350 {
10351 return f != $ac_func;
10352   ;
10353   return 0;
10354 }
10355 _ACEOF
10356 rm -f conftest.$ac_objext conftest$ac_exeext
10357 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10358   (eval $ac_link) 2>conftest.er1
10359   ac_status=$?
10360   grep -v '^ *+' conftest.er1 >conftest.err
10361   rm -f conftest.er1
10362   cat conftest.err >&5
10363   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10364   (exit $ac_status); } &&
10365          { ac_try='test -z "$ac_c_werror_flag"
10366                          || test ! -s conftest.err'
10367   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10368   (eval $ac_try) 2>&5
10369   ac_status=$?
10370   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10371   (exit $ac_status); }; } &&
10372          { ac_try='test -s conftest$ac_exeext'
10373   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10374   (eval $ac_try) 2>&5
10375   ac_status=$?
10376   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10377   (exit $ac_status); }; }; then
10378   eval "$as_ac_var=yes"
10379 else
10380   echo "$as_me: failed program was:" >&5
10381 sed 's/^/| /' conftest.$ac_ext >&5
10382
10383 eval "$as_ac_var=no"
10384 fi
10385 rm -f conftest.err conftest.$ac_objext \
10386       conftest$ac_exeext conftest.$ac_ext
10387 fi
10388 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10389 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10390 if test `eval echo '${'$as_ac_var'}'` = yes; then
10391   cat >>confdefs.h <<_ACEOF
10392 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10393 _ACEOF
10394
10395 fi
10396 done
10397
10398
10399
10400
10401
10402
10403
10404
10405
10406
10407 for ac_func in wait setmode execvp pipe dup2 close fdopen strcasestr getrlimit
10408 do
10409 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10410 echo "$as_me:$LINENO: checking for $ac_func" >&5
10411 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10412 if eval "test \"\${$as_ac_var+set}\" = set"; then
10413   echo $ECHO_N "(cached) $ECHO_C" >&6
10414 else
10415   if test x$gcc_no_link = xyes; then
10416   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10417 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10418    { (exit 1); exit 1; }; }
10419 fi
10420 cat >conftest.$ac_ext <<_ACEOF
10421 /* confdefs.h.  */
10422 _ACEOF
10423 cat confdefs.h >>conftest.$ac_ext
10424 cat >>conftest.$ac_ext <<_ACEOF
10425 /* end confdefs.h.  */
10426 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10427    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10428 #define $ac_func innocuous_$ac_func
10429
10430 /* System header to define __stub macros and hopefully few prototypes,
10431     which can conflict with char $ac_func (); below.
10432     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10433     <limits.h> exists even on freestanding compilers.  */
10434
10435 #ifdef __STDC__
10436 # include <limits.h>
10437 #else
10438 # include <assert.h>
10439 #endif
10440
10441 #undef $ac_func
10442
10443 /* Override any gcc2 internal prototype to avoid an error.  */
10444 #ifdef __cplusplus
10445 extern "C"
10446 {
10447 #endif
10448 /* We use char because int might match the return type of a gcc2
10449    builtin and then its argument prototype would still apply.  */
10450 char $ac_func ();
10451 /* The GNU C library defines this for functions which it implements
10452     to always fail with ENOSYS.  Some functions are actually named
10453     something starting with __ and the normal name is an alias.  */
10454 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10455 choke me
10456 #else
10457 char (*f) () = $ac_func;
10458 #endif
10459 #ifdef __cplusplus
10460 }
10461 #endif
10462
10463 int
10464 main ()
10465 {
10466 return f != $ac_func;
10467   ;
10468   return 0;
10469 }
10470 _ACEOF
10471 rm -f conftest.$ac_objext conftest$ac_exeext
10472 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10473   (eval $ac_link) 2>conftest.er1
10474   ac_status=$?
10475   grep -v '^ *+' conftest.er1 >conftest.err
10476   rm -f conftest.er1
10477   cat conftest.err >&5
10478   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10479   (exit $ac_status); } &&
10480          { ac_try='test -z "$ac_c_werror_flag"
10481                          || test ! -s conftest.err'
10482   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10483   (eval $ac_try) 2>&5
10484   ac_status=$?
10485   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10486   (exit $ac_status); }; } &&
10487          { ac_try='test -s conftest$ac_exeext'
10488   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10489   (eval $ac_try) 2>&5
10490   ac_status=$?
10491   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10492   (exit $ac_status); }; }; then
10493   eval "$as_ac_var=yes"
10494 else
10495   echo "$as_me: failed program was:" >&5
10496 sed 's/^/| /' conftest.$ac_ext >&5
10497
10498 eval "$as_ac_var=no"
10499 fi
10500 rm -f conftest.err conftest.$ac_objext \
10501       conftest$ac_exeext conftest.$ac_ext
10502 fi
10503 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10504 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10505 if test `eval echo '${'$as_ac_var'}'` = yes; then
10506   cat >>confdefs.h <<_ACEOF
10507 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10508 _ACEOF
10509
10510 fi
10511 done
10512
10513
10514 # Check for glibc backtrace functions
10515
10516
10517 for ac_func in backtrace backtrace_symbols
10518 do
10519 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10520 echo "$as_me:$LINENO: checking for $ac_func" >&5
10521 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10522 if eval "test \"\${$as_ac_var+set}\" = set"; then
10523   echo $ECHO_N "(cached) $ECHO_C" >&6
10524 else
10525   if test x$gcc_no_link = xyes; then
10526   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10527 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10528    { (exit 1); exit 1; }; }
10529 fi
10530 cat >conftest.$ac_ext <<_ACEOF
10531 /* confdefs.h.  */
10532 _ACEOF
10533 cat confdefs.h >>conftest.$ac_ext
10534 cat >>conftest.$ac_ext <<_ACEOF
10535 /* end confdefs.h.  */
10536 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10537    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10538 #define $ac_func innocuous_$ac_func
10539
10540 /* System header to define __stub macros and hopefully few prototypes,
10541     which can conflict with char $ac_func (); below.
10542     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10543     <limits.h> exists even on freestanding compilers.  */
10544
10545 #ifdef __STDC__
10546 # include <limits.h>
10547 #else
10548 # include <assert.h>
10549 #endif
10550
10551 #undef $ac_func
10552
10553 /* Override any gcc2 internal prototype to avoid an error.  */
10554 #ifdef __cplusplus
10555 extern "C"
10556 {
10557 #endif
10558 /* We use char because int might match the return type of a gcc2
10559    builtin and then its argument prototype would still apply.  */
10560 char $ac_func ();
10561 /* The GNU C library defines this for functions which it implements
10562     to always fail with ENOSYS.  Some functions are actually named
10563     something starting with __ and the normal name is an alias.  */
10564 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10565 choke me
10566 #else
10567 char (*f) () = $ac_func;
10568 #endif
10569 #ifdef __cplusplus
10570 }
10571 #endif
10572
10573 int
10574 main ()
10575 {
10576 return f != $ac_func;
10577   ;
10578   return 0;
10579 }
10580 _ACEOF
10581 rm -f conftest.$ac_objext conftest$ac_exeext
10582 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10583   (eval $ac_link) 2>conftest.er1
10584   ac_status=$?
10585   grep -v '^ *+' conftest.er1 >conftest.err
10586   rm -f conftest.er1
10587   cat conftest.err >&5
10588   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10589   (exit $ac_status); } &&
10590          { ac_try='test -z "$ac_c_werror_flag"
10591                          || test ! -s conftest.err'
10592   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10593   (eval $ac_try) 2>&5
10594   ac_status=$?
10595   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10596   (exit $ac_status); }; } &&
10597          { ac_try='test -s conftest$ac_exeext'
10598   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10599   (eval $ac_try) 2>&5
10600   ac_status=$?
10601   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10602   (exit $ac_status); }; }; then
10603   eval "$as_ac_var=yes"
10604 else
10605   echo "$as_me: failed program was:" >&5
10606 sed 's/^/| /' conftest.$ac_ext >&5
10607
10608 eval "$as_ac_var=no"
10609 fi
10610 rm -f conftest.err conftest.$ac_objext \
10611       conftest$ac_exeext conftest.$ac_ext
10612 fi
10613 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10614 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10615 if test `eval echo '${'$as_ac_var'}'` = yes; then
10616   cat >>confdefs.h <<_ACEOF
10617 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10618 _ACEOF
10619
10620 fi
10621 done
10622
10623
10624 # Check for types
10625 echo "$as_me:$LINENO: checking for intptr_t" >&5
10626 echo $ECHO_N "checking for intptr_t... $ECHO_C" >&6
10627 if test "${ac_cv_type_intptr_t+set}" = set; then
10628   echo $ECHO_N "(cached) $ECHO_C" >&6
10629 else
10630   cat >conftest.$ac_ext <<_ACEOF
10631 /* confdefs.h.  */
10632 _ACEOF
10633 cat confdefs.h >>conftest.$ac_ext
10634 cat >>conftest.$ac_ext <<_ACEOF
10635 /* end confdefs.h.  */
10636 $ac_includes_default
10637 int
10638 main ()
10639 {
10640 if ((intptr_t *) 0)
10641   return 0;
10642 if (sizeof (intptr_t))
10643   return 0;
10644   ;
10645   return 0;
10646 }
10647 _ACEOF
10648 rm -f conftest.$ac_objext
10649 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10650   (eval $ac_compile) 2>conftest.er1
10651   ac_status=$?
10652   grep -v '^ *+' conftest.er1 >conftest.err
10653   rm -f conftest.er1
10654   cat conftest.err >&5
10655   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10656   (exit $ac_status); } &&
10657          { ac_try='test -z "$ac_c_werror_flag"
10658                          || test ! -s conftest.err'
10659   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10660   (eval $ac_try) 2>&5
10661   ac_status=$?
10662   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10663   (exit $ac_status); }; } &&
10664          { ac_try='test -s conftest.$ac_objext'
10665   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10666   (eval $ac_try) 2>&5
10667   ac_status=$?
10668   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10669   (exit $ac_status); }; }; then
10670   ac_cv_type_intptr_t=yes
10671 else
10672   echo "$as_me: failed program was:" >&5
10673 sed 's/^/| /' conftest.$ac_ext >&5
10674
10675 ac_cv_type_intptr_t=no
10676 fi
10677 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10678 fi
10679 echo "$as_me:$LINENO: result: $ac_cv_type_intptr_t" >&5
10680 echo "${ECHO_T}$ac_cv_type_intptr_t" >&6
10681 if test $ac_cv_type_intptr_t = yes; then
10682
10683 cat >>confdefs.h <<_ACEOF
10684 #define HAVE_INTPTR_T 1
10685 _ACEOF
10686
10687
10688 fi
10689
10690
10691 # Check libc for getgid, getpid, getuid
10692 echo "$as_me:$LINENO: checking for getgid in -lc" >&5
10693 echo $ECHO_N "checking for getgid in -lc... $ECHO_C" >&6
10694 if test "${ac_cv_lib_c_getgid+set}" = set; then
10695   echo $ECHO_N "(cached) $ECHO_C" >&6
10696 else
10697   ac_check_lib_save_LIBS=$LIBS
10698 LIBS="-lc  $LIBS"
10699 if test x$gcc_no_link = xyes; then
10700   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10701 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10702    { (exit 1); exit 1; }; }
10703 fi
10704 cat >conftest.$ac_ext <<_ACEOF
10705 /* confdefs.h.  */
10706 _ACEOF
10707 cat confdefs.h >>conftest.$ac_ext
10708 cat >>conftest.$ac_ext <<_ACEOF
10709 /* end confdefs.h.  */
10710
10711 /* Override any gcc2 internal prototype to avoid an error.  */
10712 #ifdef __cplusplus
10713 extern "C"
10714 #endif
10715 /* We use char because int might match the return type of a gcc2
10716    builtin and then its argument prototype would still apply.  */
10717 char getgid ();
10718 int
10719 main ()
10720 {
10721 getgid ();
10722   ;
10723   return 0;
10724 }
10725 _ACEOF
10726 rm -f conftest.$ac_objext conftest$ac_exeext
10727 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10728   (eval $ac_link) 2>conftest.er1
10729   ac_status=$?
10730   grep -v '^ *+' conftest.er1 >conftest.err
10731   rm -f conftest.er1
10732   cat conftest.err >&5
10733   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10734   (exit $ac_status); } &&
10735          { ac_try='test -z "$ac_c_werror_flag"
10736                          || test ! -s conftest.err'
10737   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10738   (eval $ac_try) 2>&5
10739   ac_status=$?
10740   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10741   (exit $ac_status); }; } &&
10742          { ac_try='test -s conftest$ac_exeext'
10743   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10744   (eval $ac_try) 2>&5
10745   ac_status=$?
10746   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10747   (exit $ac_status); }; }; then
10748   ac_cv_lib_c_getgid=yes
10749 else
10750   echo "$as_me: failed program was:" >&5
10751 sed 's/^/| /' conftest.$ac_ext >&5
10752
10753 ac_cv_lib_c_getgid=no
10754 fi
10755 rm -f conftest.err conftest.$ac_objext \
10756       conftest$ac_exeext conftest.$ac_ext
10757 LIBS=$ac_check_lib_save_LIBS
10758 fi
10759 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getgid" >&5
10760 echo "${ECHO_T}$ac_cv_lib_c_getgid" >&6
10761 if test $ac_cv_lib_c_getgid = yes; then
10762
10763 cat >>confdefs.h <<\_ACEOF
10764 #define HAVE_GETGID 1
10765 _ACEOF
10766
10767 fi
10768
10769 echo "$as_me:$LINENO: checking for getpid in -lc" >&5
10770 echo $ECHO_N "checking for getpid in -lc... $ECHO_C" >&6
10771 if test "${ac_cv_lib_c_getpid+set}" = set; then
10772   echo $ECHO_N "(cached) $ECHO_C" >&6
10773 else
10774   ac_check_lib_save_LIBS=$LIBS
10775 LIBS="-lc  $LIBS"
10776 if test x$gcc_no_link = xyes; then
10777   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10778 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10779    { (exit 1); exit 1; }; }
10780 fi
10781 cat >conftest.$ac_ext <<_ACEOF
10782 /* confdefs.h.  */
10783 _ACEOF
10784 cat confdefs.h >>conftest.$ac_ext
10785 cat >>conftest.$ac_ext <<_ACEOF
10786 /* end confdefs.h.  */
10787
10788 /* Override any gcc2 internal prototype to avoid an error.  */
10789 #ifdef __cplusplus
10790 extern "C"
10791 #endif
10792 /* We use char because int might match the return type of a gcc2
10793    builtin and then its argument prototype would still apply.  */
10794 char getpid ();
10795 int
10796 main ()
10797 {
10798 getpid ();
10799   ;
10800   return 0;
10801 }
10802 _ACEOF
10803 rm -f conftest.$ac_objext conftest$ac_exeext
10804 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10805   (eval $ac_link) 2>conftest.er1
10806   ac_status=$?
10807   grep -v '^ *+' conftest.er1 >conftest.err
10808   rm -f conftest.er1
10809   cat conftest.err >&5
10810   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10811   (exit $ac_status); } &&
10812          { ac_try='test -z "$ac_c_werror_flag"
10813                          || test ! -s conftest.err'
10814   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10815   (eval $ac_try) 2>&5
10816   ac_status=$?
10817   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10818   (exit $ac_status); }; } &&
10819          { ac_try='test -s conftest$ac_exeext'
10820   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10821   (eval $ac_try) 2>&5
10822   ac_status=$?
10823   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10824   (exit $ac_status); }; }; then
10825   ac_cv_lib_c_getpid=yes
10826 else
10827   echo "$as_me: failed program was:" >&5
10828 sed 's/^/| /' conftest.$ac_ext >&5
10829
10830 ac_cv_lib_c_getpid=no
10831 fi
10832 rm -f conftest.err conftest.$ac_objext \
10833       conftest$ac_exeext conftest.$ac_ext
10834 LIBS=$ac_check_lib_save_LIBS
10835 fi
10836 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getpid" >&5
10837 echo "${ECHO_T}$ac_cv_lib_c_getpid" >&6
10838 if test $ac_cv_lib_c_getpid = yes; then
10839
10840 cat >>confdefs.h <<\_ACEOF
10841 #define HAVE_GETPID 1
10842 _ACEOF
10843
10844 fi
10845
10846 echo "$as_me:$LINENO: checking for getppid in -lc" >&5
10847 echo $ECHO_N "checking for getppid in -lc... $ECHO_C" >&6
10848 if test "${ac_cv_lib_c_getppid+set}" = set; then
10849   echo $ECHO_N "(cached) $ECHO_C" >&6
10850 else
10851   ac_check_lib_save_LIBS=$LIBS
10852 LIBS="-lc  $LIBS"
10853 if test x$gcc_no_link = xyes; then
10854   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10855 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10856    { (exit 1); exit 1; }; }
10857 fi
10858 cat >conftest.$ac_ext <<_ACEOF
10859 /* confdefs.h.  */
10860 _ACEOF
10861 cat confdefs.h >>conftest.$ac_ext
10862 cat >>conftest.$ac_ext <<_ACEOF
10863 /* end confdefs.h.  */
10864
10865 /* Override any gcc2 internal prototype to avoid an error.  */
10866 #ifdef __cplusplus
10867 extern "C"
10868 #endif
10869 /* We use char because int might match the return type of a gcc2
10870    builtin and then its argument prototype would still apply.  */
10871 char getppid ();
10872 int
10873 main ()
10874 {
10875 getppid ();
10876   ;
10877   return 0;
10878 }
10879 _ACEOF
10880 rm -f conftest.$ac_objext conftest$ac_exeext
10881 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10882   (eval $ac_link) 2>conftest.er1
10883   ac_status=$?
10884   grep -v '^ *+' conftest.er1 >conftest.err
10885   rm -f conftest.er1
10886   cat conftest.err >&5
10887   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10888   (exit $ac_status); } &&
10889          { ac_try='test -z "$ac_c_werror_flag"
10890                          || test ! -s conftest.err'
10891   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10892   (eval $ac_try) 2>&5
10893   ac_status=$?
10894   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10895   (exit $ac_status); }; } &&
10896          { ac_try='test -s conftest$ac_exeext'
10897   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10898   (eval $ac_try) 2>&5
10899   ac_status=$?
10900   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10901   (exit $ac_status); }; }; then
10902   ac_cv_lib_c_getppid=yes
10903 else
10904   echo "$as_me: failed program was:" >&5
10905 sed 's/^/| /' conftest.$ac_ext >&5
10906
10907 ac_cv_lib_c_getppid=no
10908 fi
10909 rm -f conftest.err conftest.$ac_objext \
10910       conftest$ac_exeext conftest.$ac_ext
10911 LIBS=$ac_check_lib_save_LIBS
10912 fi
10913 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getppid" >&5
10914 echo "${ECHO_T}$ac_cv_lib_c_getppid" >&6
10915 if test $ac_cv_lib_c_getppid = yes; then
10916
10917 cat >>confdefs.h <<\_ACEOF
10918 #define HAVE_GETPPID 1
10919 _ACEOF
10920
10921 fi
10922
10923 echo "$as_me:$LINENO: checking for getuid in -lc" >&5
10924 echo $ECHO_N "checking for getuid in -lc... $ECHO_C" >&6
10925 if test "${ac_cv_lib_c_getuid+set}" = set; then
10926   echo $ECHO_N "(cached) $ECHO_C" >&6
10927 else
10928   ac_check_lib_save_LIBS=$LIBS
10929 LIBS="-lc  $LIBS"
10930 if test x$gcc_no_link = xyes; then
10931   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10932 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10933    { (exit 1); exit 1; }; }
10934 fi
10935 cat >conftest.$ac_ext <<_ACEOF
10936 /* confdefs.h.  */
10937 _ACEOF
10938 cat confdefs.h >>conftest.$ac_ext
10939 cat >>conftest.$ac_ext <<_ACEOF
10940 /* end confdefs.h.  */
10941
10942 /* Override any gcc2 internal prototype to avoid an error.  */
10943 #ifdef __cplusplus
10944 extern "C"
10945 #endif
10946 /* We use char because int might match the return type of a gcc2
10947    builtin and then its argument prototype would still apply.  */
10948 char getuid ();
10949 int
10950 main ()
10951 {
10952 getuid ();
10953   ;
10954   return 0;
10955 }
10956 _ACEOF
10957 rm -f conftest.$ac_objext conftest$ac_exeext
10958 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10959   (eval $ac_link) 2>conftest.er1
10960   ac_status=$?
10961   grep -v '^ *+' conftest.er1 >conftest.err
10962   rm -f conftest.er1
10963   cat conftest.err >&5
10964   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10965   (exit $ac_status); } &&
10966          { ac_try='test -z "$ac_c_werror_flag"
10967                          || test ! -s conftest.err'
10968   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10969   (eval $ac_try) 2>&5
10970   ac_status=$?
10971   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10972   (exit $ac_status); }; } &&
10973          { ac_try='test -s conftest$ac_exeext'
10974   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10975   (eval $ac_try) 2>&5
10976   ac_status=$?
10977   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10978   (exit $ac_status); }; }; then
10979   ac_cv_lib_c_getuid=yes
10980 else
10981   echo "$as_me: failed program was:" >&5
10982 sed 's/^/| /' conftest.$ac_ext >&5
10983
10984 ac_cv_lib_c_getuid=no
10985 fi
10986 rm -f conftest.err conftest.$ac_objext \
10987       conftest$ac_exeext conftest.$ac_ext
10988 LIBS=$ac_check_lib_save_LIBS
10989 fi
10990 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getuid" >&5
10991 echo "${ECHO_T}$ac_cv_lib_c_getuid" >&6
10992 if test $ac_cv_lib_c_getuid = yes; then
10993
10994 cat >>confdefs.h <<\_ACEOF
10995 #define HAVE_GETUID 1
10996 _ACEOF
10997
10998 fi
10999
11000
11001 # Check for C99 (and other IEEE) math functions
11002 # ??? This list seems awful long. Is there a better way to test for these?
11003 echo "$as_me:$LINENO: checking for acosf in -lm" >&5
11004 echo $ECHO_N "checking for acosf in -lm... $ECHO_C" >&6
11005 if test "${ac_cv_lib_m_acosf+set}" = set; then
11006   echo $ECHO_N "(cached) $ECHO_C" >&6
11007 else
11008   ac_check_lib_save_LIBS=$LIBS
11009 LIBS="-lm  $LIBS"
11010 if test x$gcc_no_link = xyes; then
11011   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11012 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11013    { (exit 1); exit 1; }; }
11014 fi
11015 cat >conftest.$ac_ext <<_ACEOF
11016 /* confdefs.h.  */
11017 _ACEOF
11018 cat confdefs.h >>conftest.$ac_ext
11019 cat >>conftest.$ac_ext <<_ACEOF
11020 /* end confdefs.h.  */
11021
11022 /* Override any gcc2 internal prototype to avoid an error.  */
11023 #ifdef __cplusplus
11024 extern "C"
11025 #endif
11026 /* We use char because int might match the return type of a gcc2
11027    builtin and then its argument prototype would still apply.  */
11028 char acosf ();
11029 int
11030 main ()
11031 {
11032 acosf ();
11033   ;
11034   return 0;
11035 }
11036 _ACEOF
11037 rm -f conftest.$ac_objext conftest$ac_exeext
11038 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11039   (eval $ac_link) 2>conftest.er1
11040   ac_status=$?
11041   grep -v '^ *+' conftest.er1 >conftest.err
11042   rm -f conftest.er1
11043   cat conftest.err >&5
11044   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11045   (exit $ac_status); } &&
11046          { ac_try='test -z "$ac_c_werror_flag"
11047                          || test ! -s conftest.err'
11048   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11049   (eval $ac_try) 2>&5
11050   ac_status=$?
11051   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11052   (exit $ac_status); }; } &&
11053          { ac_try='test -s conftest$ac_exeext'
11054   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11055   (eval $ac_try) 2>&5
11056   ac_status=$?
11057   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11058   (exit $ac_status); }; }; then
11059   ac_cv_lib_m_acosf=yes
11060 else
11061   echo "$as_me: failed program was:" >&5
11062 sed 's/^/| /' conftest.$ac_ext >&5
11063
11064 ac_cv_lib_m_acosf=no
11065 fi
11066 rm -f conftest.err conftest.$ac_objext \
11067       conftest$ac_exeext conftest.$ac_ext
11068 LIBS=$ac_check_lib_save_LIBS
11069 fi
11070 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosf" >&5
11071 echo "${ECHO_T}$ac_cv_lib_m_acosf" >&6
11072 if test $ac_cv_lib_m_acosf = yes; then
11073
11074 cat >>confdefs.h <<\_ACEOF
11075 #define HAVE_ACOSF 1
11076 _ACEOF
11077
11078 fi
11079
11080 echo "$as_me:$LINENO: checking for acos in -lm" >&5
11081 echo $ECHO_N "checking for acos in -lm... $ECHO_C" >&6
11082 if test "${ac_cv_lib_m_acos+set}" = set; then
11083   echo $ECHO_N "(cached) $ECHO_C" >&6
11084 else
11085   ac_check_lib_save_LIBS=$LIBS
11086 LIBS="-lm  $LIBS"
11087 if test x$gcc_no_link = xyes; then
11088   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11089 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11090    { (exit 1); exit 1; }; }
11091 fi
11092 cat >conftest.$ac_ext <<_ACEOF
11093 /* confdefs.h.  */
11094 _ACEOF
11095 cat confdefs.h >>conftest.$ac_ext
11096 cat >>conftest.$ac_ext <<_ACEOF
11097 /* end confdefs.h.  */
11098
11099 /* Override any gcc2 internal prototype to avoid an error.  */
11100 #ifdef __cplusplus
11101 extern "C"
11102 #endif
11103 /* We use char because int might match the return type of a gcc2
11104    builtin and then its argument prototype would still apply.  */
11105 char acos ();
11106 int
11107 main ()
11108 {
11109 acos ();
11110   ;
11111   return 0;
11112 }
11113 _ACEOF
11114 rm -f conftest.$ac_objext conftest$ac_exeext
11115 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11116   (eval $ac_link) 2>conftest.er1
11117   ac_status=$?
11118   grep -v '^ *+' conftest.er1 >conftest.err
11119   rm -f conftest.er1
11120   cat conftest.err >&5
11121   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11122   (exit $ac_status); } &&
11123          { ac_try='test -z "$ac_c_werror_flag"
11124                          || test ! -s conftest.err'
11125   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11126   (eval $ac_try) 2>&5
11127   ac_status=$?
11128   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11129   (exit $ac_status); }; } &&
11130          { ac_try='test -s conftest$ac_exeext'
11131   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11132   (eval $ac_try) 2>&5
11133   ac_status=$?
11134   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11135   (exit $ac_status); }; }; then
11136   ac_cv_lib_m_acos=yes
11137 else
11138   echo "$as_me: failed program was:" >&5
11139 sed 's/^/| /' conftest.$ac_ext >&5
11140
11141 ac_cv_lib_m_acos=no
11142 fi
11143 rm -f conftest.err conftest.$ac_objext \
11144       conftest$ac_exeext conftest.$ac_ext
11145 LIBS=$ac_check_lib_save_LIBS
11146 fi
11147 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acos" >&5
11148 echo "${ECHO_T}$ac_cv_lib_m_acos" >&6
11149 if test $ac_cv_lib_m_acos = yes; then
11150
11151 cat >>confdefs.h <<\_ACEOF
11152 #define HAVE_ACOS 1
11153 _ACEOF
11154
11155 fi
11156
11157 echo "$as_me:$LINENO: checking for acosl in -lm" >&5
11158 echo $ECHO_N "checking for acosl in -lm... $ECHO_C" >&6
11159 if test "${ac_cv_lib_m_acosl+set}" = set; then
11160   echo $ECHO_N "(cached) $ECHO_C" >&6
11161 else
11162   ac_check_lib_save_LIBS=$LIBS
11163 LIBS="-lm  $LIBS"
11164 if test x$gcc_no_link = xyes; then
11165   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11166 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11167    { (exit 1); exit 1; }; }
11168 fi
11169 cat >conftest.$ac_ext <<_ACEOF
11170 /* confdefs.h.  */
11171 _ACEOF
11172 cat confdefs.h >>conftest.$ac_ext
11173 cat >>conftest.$ac_ext <<_ACEOF
11174 /* end confdefs.h.  */
11175
11176 /* Override any gcc2 internal prototype to avoid an error.  */
11177 #ifdef __cplusplus
11178 extern "C"
11179 #endif
11180 /* We use char because int might match the return type of a gcc2
11181    builtin and then its argument prototype would still apply.  */
11182 char acosl ();
11183 int
11184 main ()
11185 {
11186 acosl ();
11187   ;
11188   return 0;
11189 }
11190 _ACEOF
11191 rm -f conftest.$ac_objext conftest$ac_exeext
11192 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11193   (eval $ac_link) 2>conftest.er1
11194   ac_status=$?
11195   grep -v '^ *+' conftest.er1 >conftest.err
11196   rm -f conftest.er1
11197   cat conftest.err >&5
11198   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11199   (exit $ac_status); } &&
11200          { ac_try='test -z "$ac_c_werror_flag"
11201                          || test ! -s conftest.err'
11202   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11203   (eval $ac_try) 2>&5
11204   ac_status=$?
11205   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11206   (exit $ac_status); }; } &&
11207          { ac_try='test -s conftest$ac_exeext'
11208   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11209   (eval $ac_try) 2>&5
11210   ac_status=$?
11211   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11212   (exit $ac_status); }; }; then
11213   ac_cv_lib_m_acosl=yes
11214 else
11215   echo "$as_me: failed program was:" >&5
11216 sed 's/^/| /' conftest.$ac_ext >&5
11217
11218 ac_cv_lib_m_acosl=no
11219 fi
11220 rm -f conftest.err conftest.$ac_objext \
11221       conftest$ac_exeext conftest.$ac_ext
11222 LIBS=$ac_check_lib_save_LIBS
11223 fi
11224 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosl" >&5
11225 echo "${ECHO_T}$ac_cv_lib_m_acosl" >&6
11226 if test $ac_cv_lib_m_acosl = yes; then
11227
11228 cat >>confdefs.h <<\_ACEOF
11229 #define HAVE_ACOSL 1
11230 _ACEOF
11231
11232 fi
11233
11234 echo "$as_me:$LINENO: checking for acoshf in -lm" >&5
11235 echo $ECHO_N "checking for acoshf in -lm... $ECHO_C" >&6
11236 if test "${ac_cv_lib_m_acoshf+set}" = set; then
11237   echo $ECHO_N "(cached) $ECHO_C" >&6
11238 else
11239   ac_check_lib_save_LIBS=$LIBS
11240 LIBS="-lm  $LIBS"
11241 if test x$gcc_no_link = xyes; then
11242   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11243 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11244    { (exit 1); exit 1; }; }
11245 fi
11246 cat >conftest.$ac_ext <<_ACEOF
11247 /* confdefs.h.  */
11248 _ACEOF
11249 cat confdefs.h >>conftest.$ac_ext
11250 cat >>conftest.$ac_ext <<_ACEOF
11251 /* end confdefs.h.  */
11252
11253 /* Override any gcc2 internal prototype to avoid an error.  */
11254 #ifdef __cplusplus
11255 extern "C"
11256 #endif
11257 /* We use char because int might match the return type of a gcc2
11258    builtin and then its argument prototype would still apply.  */
11259 char acoshf ();
11260 int
11261 main ()
11262 {
11263 acoshf ();
11264   ;
11265   return 0;
11266 }
11267 _ACEOF
11268 rm -f conftest.$ac_objext conftest$ac_exeext
11269 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11270   (eval $ac_link) 2>conftest.er1
11271   ac_status=$?
11272   grep -v '^ *+' conftest.er1 >conftest.err
11273   rm -f conftest.er1
11274   cat conftest.err >&5
11275   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11276   (exit $ac_status); } &&
11277          { ac_try='test -z "$ac_c_werror_flag"
11278                          || test ! -s conftest.err'
11279   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11280   (eval $ac_try) 2>&5
11281   ac_status=$?
11282   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11283   (exit $ac_status); }; } &&
11284          { ac_try='test -s conftest$ac_exeext'
11285   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11286   (eval $ac_try) 2>&5
11287   ac_status=$?
11288   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11289   (exit $ac_status); }; }; then
11290   ac_cv_lib_m_acoshf=yes
11291 else
11292   echo "$as_me: failed program was:" >&5
11293 sed 's/^/| /' conftest.$ac_ext >&5
11294
11295 ac_cv_lib_m_acoshf=no
11296 fi
11297 rm -f conftest.err conftest.$ac_objext \
11298       conftest$ac_exeext conftest.$ac_ext
11299 LIBS=$ac_check_lib_save_LIBS
11300 fi
11301 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acoshf" >&5
11302 echo "${ECHO_T}$ac_cv_lib_m_acoshf" >&6
11303 if test $ac_cv_lib_m_acoshf = yes; then
11304
11305 cat >>confdefs.h <<\_ACEOF
11306 #define HAVE_ACOSHF 1
11307 _ACEOF
11308
11309 fi
11310
11311 echo "$as_me:$LINENO: checking for acosh in -lm" >&5
11312 echo $ECHO_N "checking for acosh in -lm... $ECHO_C" >&6
11313 if test "${ac_cv_lib_m_acosh+set}" = set; then
11314   echo $ECHO_N "(cached) $ECHO_C" >&6
11315 else
11316   ac_check_lib_save_LIBS=$LIBS
11317 LIBS="-lm  $LIBS"
11318 if test x$gcc_no_link = xyes; then
11319   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11320 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11321    { (exit 1); exit 1; }; }
11322 fi
11323 cat >conftest.$ac_ext <<_ACEOF
11324 /* confdefs.h.  */
11325 _ACEOF
11326 cat confdefs.h >>conftest.$ac_ext
11327 cat >>conftest.$ac_ext <<_ACEOF
11328 /* end confdefs.h.  */
11329
11330 /* Override any gcc2 internal prototype to avoid an error.  */
11331 #ifdef __cplusplus
11332 extern "C"
11333 #endif
11334 /* We use char because int might match the return type of a gcc2
11335    builtin and then its argument prototype would still apply.  */
11336 char acosh ();
11337 int
11338 main ()
11339 {
11340 acosh ();
11341   ;
11342   return 0;
11343 }
11344 _ACEOF
11345 rm -f conftest.$ac_objext conftest$ac_exeext
11346 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11347   (eval $ac_link) 2>conftest.er1
11348   ac_status=$?
11349   grep -v '^ *+' conftest.er1 >conftest.err
11350   rm -f conftest.er1
11351   cat conftest.err >&5
11352   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11353   (exit $ac_status); } &&
11354          { ac_try='test -z "$ac_c_werror_flag"
11355                          || test ! -s conftest.err'
11356   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11357   (eval $ac_try) 2>&5
11358   ac_status=$?
11359   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11360   (exit $ac_status); }; } &&
11361          { ac_try='test -s conftest$ac_exeext'
11362   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11363   (eval $ac_try) 2>&5
11364   ac_status=$?
11365   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11366   (exit $ac_status); }; }; then
11367   ac_cv_lib_m_acosh=yes
11368 else
11369   echo "$as_me: failed program was:" >&5
11370 sed 's/^/| /' conftest.$ac_ext >&5
11371
11372 ac_cv_lib_m_acosh=no
11373 fi
11374 rm -f conftest.err conftest.$ac_objext \
11375       conftest$ac_exeext conftest.$ac_ext
11376 LIBS=$ac_check_lib_save_LIBS
11377 fi
11378 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosh" >&5
11379 echo "${ECHO_T}$ac_cv_lib_m_acosh" >&6
11380 if test $ac_cv_lib_m_acosh = yes; then
11381
11382 cat >>confdefs.h <<\_ACEOF
11383 #define HAVE_ACOSH 1
11384 _ACEOF
11385
11386 fi
11387
11388 echo "$as_me:$LINENO: checking for acoshl in -lm" >&5
11389 echo $ECHO_N "checking for acoshl in -lm... $ECHO_C" >&6
11390 if test "${ac_cv_lib_m_acoshl+set}" = set; then
11391   echo $ECHO_N "(cached) $ECHO_C" >&6
11392 else
11393   ac_check_lib_save_LIBS=$LIBS
11394 LIBS="-lm  $LIBS"
11395 if test x$gcc_no_link = xyes; then
11396   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11397 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11398    { (exit 1); exit 1; }; }
11399 fi
11400 cat >conftest.$ac_ext <<_ACEOF
11401 /* confdefs.h.  */
11402 _ACEOF
11403 cat confdefs.h >>conftest.$ac_ext
11404 cat >>conftest.$ac_ext <<_ACEOF
11405 /* end confdefs.h.  */
11406
11407 /* Override any gcc2 internal prototype to avoid an error.  */
11408 #ifdef __cplusplus
11409 extern "C"
11410 #endif
11411 /* We use char because int might match the return type of a gcc2
11412    builtin and then its argument prototype would still apply.  */
11413 char acoshl ();
11414 int
11415 main ()
11416 {
11417 acoshl ();
11418   ;
11419   return 0;
11420 }
11421 _ACEOF
11422 rm -f conftest.$ac_objext conftest$ac_exeext
11423 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11424   (eval $ac_link) 2>conftest.er1
11425   ac_status=$?
11426   grep -v '^ *+' conftest.er1 >conftest.err
11427   rm -f conftest.er1
11428   cat conftest.err >&5
11429   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11430   (exit $ac_status); } &&
11431          { ac_try='test -z "$ac_c_werror_flag"
11432                          || test ! -s conftest.err'
11433   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11434   (eval $ac_try) 2>&5
11435   ac_status=$?
11436   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11437   (exit $ac_status); }; } &&
11438          { ac_try='test -s conftest$ac_exeext'
11439   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11440   (eval $ac_try) 2>&5
11441   ac_status=$?
11442   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11443   (exit $ac_status); }; }; then
11444   ac_cv_lib_m_acoshl=yes
11445 else
11446   echo "$as_me: failed program was:" >&5
11447 sed 's/^/| /' conftest.$ac_ext >&5
11448
11449 ac_cv_lib_m_acoshl=no
11450 fi
11451 rm -f conftest.err conftest.$ac_objext \
11452       conftest$ac_exeext conftest.$ac_ext
11453 LIBS=$ac_check_lib_save_LIBS
11454 fi
11455 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acoshl" >&5
11456 echo "${ECHO_T}$ac_cv_lib_m_acoshl" >&6
11457 if test $ac_cv_lib_m_acoshl = yes; then
11458
11459 cat >>confdefs.h <<\_ACEOF
11460 #define HAVE_ACOSHL 1
11461 _ACEOF
11462
11463 fi
11464
11465 echo "$as_me:$LINENO: checking for asinf in -lm" >&5
11466 echo $ECHO_N "checking for asinf in -lm... $ECHO_C" >&6
11467 if test "${ac_cv_lib_m_asinf+set}" = set; then
11468   echo $ECHO_N "(cached) $ECHO_C" >&6
11469 else
11470   ac_check_lib_save_LIBS=$LIBS
11471 LIBS="-lm  $LIBS"
11472 if test x$gcc_no_link = xyes; then
11473   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11474 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11475    { (exit 1); exit 1; }; }
11476 fi
11477 cat >conftest.$ac_ext <<_ACEOF
11478 /* confdefs.h.  */
11479 _ACEOF
11480 cat confdefs.h >>conftest.$ac_ext
11481 cat >>conftest.$ac_ext <<_ACEOF
11482 /* end confdefs.h.  */
11483
11484 /* Override any gcc2 internal prototype to avoid an error.  */
11485 #ifdef __cplusplus
11486 extern "C"
11487 #endif
11488 /* We use char because int might match the return type of a gcc2
11489    builtin and then its argument prototype would still apply.  */
11490 char asinf ();
11491 int
11492 main ()
11493 {
11494 asinf ();
11495   ;
11496   return 0;
11497 }
11498 _ACEOF
11499 rm -f conftest.$ac_objext conftest$ac_exeext
11500 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11501   (eval $ac_link) 2>conftest.er1
11502   ac_status=$?
11503   grep -v '^ *+' conftest.er1 >conftest.err
11504   rm -f conftest.er1
11505   cat conftest.err >&5
11506   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11507   (exit $ac_status); } &&
11508          { ac_try='test -z "$ac_c_werror_flag"
11509                          || test ! -s conftest.err'
11510   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11511   (eval $ac_try) 2>&5
11512   ac_status=$?
11513   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11514   (exit $ac_status); }; } &&
11515          { ac_try='test -s conftest$ac_exeext'
11516   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11517   (eval $ac_try) 2>&5
11518   ac_status=$?
11519   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11520   (exit $ac_status); }; }; then
11521   ac_cv_lib_m_asinf=yes
11522 else
11523   echo "$as_me: failed program was:" >&5
11524 sed 's/^/| /' conftest.$ac_ext >&5
11525
11526 ac_cv_lib_m_asinf=no
11527 fi
11528 rm -f conftest.err conftest.$ac_objext \
11529       conftest$ac_exeext conftest.$ac_ext
11530 LIBS=$ac_check_lib_save_LIBS
11531 fi
11532 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinf" >&5
11533 echo "${ECHO_T}$ac_cv_lib_m_asinf" >&6
11534 if test $ac_cv_lib_m_asinf = yes; then
11535
11536 cat >>confdefs.h <<\_ACEOF
11537 #define HAVE_ASINF 1
11538 _ACEOF
11539
11540 fi
11541
11542 echo "$as_me:$LINENO: checking for asin in -lm" >&5
11543 echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
11544 if test "${ac_cv_lib_m_asin+set}" = set; then
11545   echo $ECHO_N "(cached) $ECHO_C" >&6
11546 else
11547   ac_check_lib_save_LIBS=$LIBS
11548 LIBS="-lm  $LIBS"
11549 if test x$gcc_no_link = xyes; then
11550   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11551 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11552    { (exit 1); exit 1; }; }
11553 fi
11554 cat >conftest.$ac_ext <<_ACEOF
11555 /* confdefs.h.  */
11556 _ACEOF
11557 cat confdefs.h >>conftest.$ac_ext
11558 cat >>conftest.$ac_ext <<_ACEOF
11559 /* end confdefs.h.  */
11560
11561 /* Override any gcc2 internal prototype to avoid an error.  */
11562 #ifdef __cplusplus
11563 extern "C"
11564 #endif
11565 /* We use char because int might match the return type of a gcc2
11566    builtin and then its argument prototype would still apply.  */
11567 char asin ();
11568 int
11569 main ()
11570 {
11571 asin ();
11572   ;
11573   return 0;
11574 }
11575 _ACEOF
11576 rm -f conftest.$ac_objext conftest$ac_exeext
11577 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11578   (eval $ac_link) 2>conftest.er1
11579   ac_status=$?
11580   grep -v '^ *+' conftest.er1 >conftest.err
11581   rm -f conftest.er1
11582   cat conftest.err >&5
11583   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11584   (exit $ac_status); } &&
11585          { ac_try='test -z "$ac_c_werror_flag"
11586                          || test ! -s conftest.err'
11587   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11588   (eval $ac_try) 2>&5
11589   ac_status=$?
11590   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11591   (exit $ac_status); }; } &&
11592          { ac_try='test -s conftest$ac_exeext'
11593   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11594   (eval $ac_try) 2>&5
11595   ac_status=$?
11596   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11597   (exit $ac_status); }; }; then
11598   ac_cv_lib_m_asin=yes
11599 else
11600   echo "$as_me: failed program was:" >&5
11601 sed 's/^/| /' conftest.$ac_ext >&5
11602
11603 ac_cv_lib_m_asin=no
11604 fi
11605 rm -f conftest.err conftest.$ac_objext \
11606       conftest$ac_exeext conftest.$ac_ext
11607 LIBS=$ac_check_lib_save_LIBS
11608 fi
11609 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
11610 echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
11611 if test $ac_cv_lib_m_asin = yes; then
11612
11613 cat >>confdefs.h <<\_ACEOF
11614 #define HAVE_ASIN 1
11615 _ACEOF
11616
11617 fi
11618
11619 echo "$as_me:$LINENO: checking for asinl in -lm" >&5
11620 echo $ECHO_N "checking for asinl in -lm... $ECHO_C" >&6
11621 if test "${ac_cv_lib_m_asinl+set}" = set; then
11622   echo $ECHO_N "(cached) $ECHO_C" >&6
11623 else
11624   ac_check_lib_save_LIBS=$LIBS
11625 LIBS="-lm  $LIBS"
11626 if test x$gcc_no_link = xyes; then
11627   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11628 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11629    { (exit 1); exit 1; }; }
11630 fi
11631 cat >conftest.$ac_ext <<_ACEOF
11632 /* confdefs.h.  */
11633 _ACEOF
11634 cat confdefs.h >>conftest.$ac_ext
11635 cat >>conftest.$ac_ext <<_ACEOF
11636 /* end confdefs.h.  */
11637
11638 /* Override any gcc2 internal prototype to avoid an error.  */
11639 #ifdef __cplusplus
11640 extern "C"
11641 #endif
11642 /* We use char because int might match the return type of a gcc2
11643    builtin and then its argument prototype would still apply.  */
11644 char asinl ();
11645 int
11646 main ()
11647 {
11648 asinl ();
11649   ;
11650   return 0;
11651 }
11652 _ACEOF
11653 rm -f conftest.$ac_objext conftest$ac_exeext
11654 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11655   (eval $ac_link) 2>conftest.er1
11656   ac_status=$?
11657   grep -v '^ *+' conftest.er1 >conftest.err
11658   rm -f conftest.er1
11659   cat conftest.err >&5
11660   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11661   (exit $ac_status); } &&
11662          { ac_try='test -z "$ac_c_werror_flag"
11663                          || test ! -s conftest.err'
11664   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11665   (eval $ac_try) 2>&5
11666   ac_status=$?
11667   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11668   (exit $ac_status); }; } &&
11669          { ac_try='test -s conftest$ac_exeext'
11670   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11671   (eval $ac_try) 2>&5
11672   ac_status=$?
11673   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11674   (exit $ac_status); }; }; then
11675   ac_cv_lib_m_asinl=yes
11676 else
11677   echo "$as_me: failed program was:" >&5
11678 sed 's/^/| /' conftest.$ac_ext >&5
11679
11680 ac_cv_lib_m_asinl=no
11681 fi
11682 rm -f conftest.err conftest.$ac_objext \
11683       conftest$ac_exeext conftest.$ac_ext
11684 LIBS=$ac_check_lib_save_LIBS
11685 fi
11686 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinl" >&5
11687 echo "${ECHO_T}$ac_cv_lib_m_asinl" >&6
11688 if test $ac_cv_lib_m_asinl = yes; then
11689
11690 cat >>confdefs.h <<\_ACEOF
11691 #define HAVE_ASINL 1
11692 _ACEOF
11693
11694 fi
11695
11696 echo "$as_me:$LINENO: checking for asinhf in -lm" >&5
11697 echo $ECHO_N "checking for asinhf in -lm... $ECHO_C" >&6
11698 if test "${ac_cv_lib_m_asinhf+set}" = set; then
11699   echo $ECHO_N "(cached) $ECHO_C" >&6
11700 else
11701   ac_check_lib_save_LIBS=$LIBS
11702 LIBS="-lm  $LIBS"
11703 if test x$gcc_no_link = xyes; then
11704   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11705 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11706    { (exit 1); exit 1; }; }
11707 fi
11708 cat >conftest.$ac_ext <<_ACEOF
11709 /* confdefs.h.  */
11710 _ACEOF
11711 cat confdefs.h >>conftest.$ac_ext
11712 cat >>conftest.$ac_ext <<_ACEOF
11713 /* end confdefs.h.  */
11714
11715 /* Override any gcc2 internal prototype to avoid an error.  */
11716 #ifdef __cplusplus
11717 extern "C"
11718 #endif
11719 /* We use char because int might match the return type of a gcc2
11720    builtin and then its argument prototype would still apply.  */
11721 char asinhf ();
11722 int
11723 main ()
11724 {
11725 asinhf ();
11726   ;
11727   return 0;
11728 }
11729 _ACEOF
11730 rm -f conftest.$ac_objext conftest$ac_exeext
11731 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11732   (eval $ac_link) 2>conftest.er1
11733   ac_status=$?
11734   grep -v '^ *+' conftest.er1 >conftest.err
11735   rm -f conftest.er1
11736   cat conftest.err >&5
11737   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11738   (exit $ac_status); } &&
11739          { ac_try='test -z "$ac_c_werror_flag"
11740                          || test ! -s conftest.err'
11741   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11742   (eval $ac_try) 2>&5
11743   ac_status=$?
11744   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11745   (exit $ac_status); }; } &&
11746          { ac_try='test -s conftest$ac_exeext'
11747   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11748   (eval $ac_try) 2>&5
11749   ac_status=$?
11750   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11751   (exit $ac_status); }; }; then
11752   ac_cv_lib_m_asinhf=yes
11753 else
11754   echo "$as_me: failed program was:" >&5
11755 sed 's/^/| /' conftest.$ac_ext >&5
11756
11757 ac_cv_lib_m_asinhf=no
11758 fi
11759 rm -f conftest.err conftest.$ac_objext \
11760       conftest$ac_exeext conftest.$ac_ext
11761 LIBS=$ac_check_lib_save_LIBS
11762 fi
11763 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinhf" >&5
11764 echo "${ECHO_T}$ac_cv_lib_m_asinhf" >&6
11765 if test $ac_cv_lib_m_asinhf = yes; then
11766
11767 cat >>confdefs.h <<\_ACEOF
11768 #define HAVE_ASINHF 1
11769 _ACEOF
11770
11771 fi
11772
11773 echo "$as_me:$LINENO: checking for asinh in -lm" >&5
11774 echo $ECHO_N "checking for asinh in -lm... $ECHO_C" >&6
11775 if test "${ac_cv_lib_m_asinh+set}" = set; then
11776   echo $ECHO_N "(cached) $ECHO_C" >&6
11777 else
11778   ac_check_lib_save_LIBS=$LIBS
11779 LIBS="-lm  $LIBS"
11780 if test x$gcc_no_link = xyes; then
11781   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11782 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11783    { (exit 1); exit 1; }; }
11784 fi
11785 cat >conftest.$ac_ext <<_ACEOF
11786 /* confdefs.h.  */
11787 _ACEOF
11788 cat confdefs.h >>conftest.$ac_ext
11789 cat >>conftest.$ac_ext <<_ACEOF
11790 /* end confdefs.h.  */
11791
11792 /* Override any gcc2 internal prototype to avoid an error.  */
11793 #ifdef __cplusplus
11794 extern "C"
11795 #endif
11796 /* We use char because int might match the return type of a gcc2
11797    builtin and then its argument prototype would still apply.  */
11798 char asinh ();
11799 int
11800 main ()
11801 {
11802 asinh ();
11803   ;
11804   return 0;
11805 }
11806 _ACEOF
11807 rm -f conftest.$ac_objext conftest$ac_exeext
11808 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11809   (eval $ac_link) 2>conftest.er1
11810   ac_status=$?
11811   grep -v '^ *+' conftest.er1 >conftest.err
11812   rm -f conftest.er1
11813   cat conftest.err >&5
11814   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11815   (exit $ac_status); } &&
11816          { ac_try='test -z "$ac_c_werror_flag"
11817                          || test ! -s conftest.err'
11818   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11819   (eval $ac_try) 2>&5
11820   ac_status=$?
11821   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11822   (exit $ac_status); }; } &&
11823          { ac_try='test -s conftest$ac_exeext'
11824   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11825   (eval $ac_try) 2>&5
11826   ac_status=$?
11827   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11828   (exit $ac_status); }; }; then
11829   ac_cv_lib_m_asinh=yes
11830 else
11831   echo "$as_me: failed program was:" >&5
11832 sed 's/^/| /' conftest.$ac_ext >&5
11833
11834 ac_cv_lib_m_asinh=no
11835 fi
11836 rm -f conftest.err conftest.$ac_objext \
11837       conftest$ac_exeext conftest.$ac_ext
11838 LIBS=$ac_check_lib_save_LIBS
11839 fi
11840 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinh" >&5
11841 echo "${ECHO_T}$ac_cv_lib_m_asinh" >&6
11842 if test $ac_cv_lib_m_asinh = yes; then
11843
11844 cat >>confdefs.h <<\_ACEOF
11845 #define HAVE_ASINH 1
11846 _ACEOF
11847
11848 fi
11849
11850 echo "$as_me:$LINENO: checking for asinhl in -lm" >&5
11851 echo $ECHO_N "checking for asinhl in -lm... $ECHO_C" >&6
11852 if test "${ac_cv_lib_m_asinhl+set}" = set; then
11853   echo $ECHO_N "(cached) $ECHO_C" >&6
11854 else
11855   ac_check_lib_save_LIBS=$LIBS
11856 LIBS="-lm  $LIBS"
11857 if test x$gcc_no_link = xyes; then
11858   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11859 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11860    { (exit 1); exit 1; }; }
11861 fi
11862 cat >conftest.$ac_ext <<_ACEOF
11863 /* confdefs.h.  */
11864 _ACEOF
11865 cat confdefs.h >>conftest.$ac_ext
11866 cat >>conftest.$ac_ext <<_ACEOF
11867 /* end confdefs.h.  */
11868
11869 /* Override any gcc2 internal prototype to avoid an error.  */
11870 #ifdef __cplusplus
11871 extern "C"
11872 #endif
11873 /* We use char because int might match the return type of a gcc2
11874    builtin and then its argument prototype would still apply.  */
11875 char asinhl ();
11876 int
11877 main ()
11878 {
11879 asinhl ();
11880   ;
11881   return 0;
11882 }
11883 _ACEOF
11884 rm -f conftest.$ac_objext conftest$ac_exeext
11885 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11886   (eval $ac_link) 2>conftest.er1
11887   ac_status=$?
11888   grep -v '^ *+' conftest.er1 >conftest.err
11889   rm -f conftest.er1
11890   cat conftest.err >&5
11891   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11892   (exit $ac_status); } &&
11893          { ac_try='test -z "$ac_c_werror_flag"
11894                          || test ! -s conftest.err'
11895   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11896   (eval $ac_try) 2>&5
11897   ac_status=$?
11898   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11899   (exit $ac_status); }; } &&
11900          { ac_try='test -s conftest$ac_exeext'
11901   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11902   (eval $ac_try) 2>&5
11903   ac_status=$?
11904   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11905   (exit $ac_status); }; }; then
11906   ac_cv_lib_m_asinhl=yes
11907 else
11908   echo "$as_me: failed program was:" >&5
11909 sed 's/^/| /' conftest.$ac_ext >&5
11910
11911 ac_cv_lib_m_asinhl=no
11912 fi
11913 rm -f conftest.err conftest.$ac_objext \
11914       conftest$ac_exeext conftest.$ac_ext
11915 LIBS=$ac_check_lib_save_LIBS
11916 fi
11917 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinhl" >&5
11918 echo "${ECHO_T}$ac_cv_lib_m_asinhl" >&6
11919 if test $ac_cv_lib_m_asinhl = yes; then
11920
11921 cat >>confdefs.h <<\_ACEOF
11922 #define HAVE_ASINHL 1
11923 _ACEOF
11924
11925 fi
11926
11927 echo "$as_me:$LINENO: checking for atan2f in -lm" >&5
11928 echo $ECHO_N "checking for atan2f in -lm... $ECHO_C" >&6
11929 if test "${ac_cv_lib_m_atan2f+set}" = set; then
11930   echo $ECHO_N "(cached) $ECHO_C" >&6
11931 else
11932   ac_check_lib_save_LIBS=$LIBS
11933 LIBS="-lm  $LIBS"
11934 if test x$gcc_no_link = xyes; then
11935   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11936 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11937    { (exit 1); exit 1; }; }
11938 fi
11939 cat >conftest.$ac_ext <<_ACEOF
11940 /* confdefs.h.  */
11941 _ACEOF
11942 cat confdefs.h >>conftest.$ac_ext
11943 cat >>conftest.$ac_ext <<_ACEOF
11944 /* end confdefs.h.  */
11945
11946 /* Override any gcc2 internal prototype to avoid an error.  */
11947 #ifdef __cplusplus
11948 extern "C"
11949 #endif
11950 /* We use char because int might match the return type of a gcc2
11951    builtin and then its argument prototype would still apply.  */
11952 char atan2f ();
11953 int
11954 main ()
11955 {
11956 atan2f ();
11957   ;
11958   return 0;
11959 }
11960 _ACEOF
11961 rm -f conftest.$ac_objext conftest$ac_exeext
11962 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11963   (eval $ac_link) 2>conftest.er1
11964   ac_status=$?
11965   grep -v '^ *+' conftest.er1 >conftest.err
11966   rm -f conftest.er1
11967   cat conftest.err >&5
11968   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11969   (exit $ac_status); } &&
11970          { ac_try='test -z "$ac_c_werror_flag"
11971                          || test ! -s conftest.err'
11972   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11973   (eval $ac_try) 2>&5
11974   ac_status=$?
11975   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11976   (exit $ac_status); }; } &&
11977          { ac_try='test -s conftest$ac_exeext'
11978   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11979   (eval $ac_try) 2>&5
11980   ac_status=$?
11981   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11982   (exit $ac_status); }; }; then
11983   ac_cv_lib_m_atan2f=yes
11984 else
11985   echo "$as_me: failed program was:" >&5
11986 sed 's/^/| /' conftest.$ac_ext >&5
11987
11988 ac_cv_lib_m_atan2f=no
11989 fi
11990 rm -f conftest.err conftest.$ac_objext \
11991       conftest$ac_exeext conftest.$ac_ext
11992 LIBS=$ac_check_lib_save_LIBS
11993 fi
11994 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2f" >&5
11995 echo "${ECHO_T}$ac_cv_lib_m_atan2f" >&6
11996 if test $ac_cv_lib_m_atan2f = yes; then
11997
11998 cat >>confdefs.h <<\_ACEOF
11999 #define HAVE_ATAN2F 1
12000 _ACEOF
12001
12002 fi
12003
12004 echo "$as_me:$LINENO: checking for atan2 in -lm" >&5
12005 echo $ECHO_N "checking for atan2 in -lm... $ECHO_C" >&6
12006 if test "${ac_cv_lib_m_atan2+set}" = set; then
12007   echo $ECHO_N "(cached) $ECHO_C" >&6
12008 else
12009   ac_check_lib_save_LIBS=$LIBS
12010 LIBS="-lm  $LIBS"
12011 if test x$gcc_no_link = xyes; then
12012   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12013 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12014    { (exit 1); exit 1; }; }
12015 fi
12016 cat >conftest.$ac_ext <<_ACEOF
12017 /* confdefs.h.  */
12018 _ACEOF
12019 cat confdefs.h >>conftest.$ac_ext
12020 cat >>conftest.$ac_ext <<_ACEOF
12021 /* end confdefs.h.  */
12022
12023 /* Override any gcc2 internal prototype to avoid an error.  */
12024 #ifdef __cplusplus
12025 extern "C"
12026 #endif
12027 /* We use char because int might match the return type of a gcc2
12028    builtin and then its argument prototype would still apply.  */
12029 char atan2 ();
12030 int
12031 main ()
12032 {
12033 atan2 ();
12034   ;
12035   return 0;
12036 }
12037 _ACEOF
12038 rm -f conftest.$ac_objext conftest$ac_exeext
12039 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12040   (eval $ac_link) 2>conftest.er1
12041   ac_status=$?
12042   grep -v '^ *+' conftest.er1 >conftest.err
12043   rm -f conftest.er1
12044   cat conftest.err >&5
12045   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12046   (exit $ac_status); } &&
12047          { ac_try='test -z "$ac_c_werror_flag"
12048                          || test ! -s conftest.err'
12049   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12050   (eval $ac_try) 2>&5
12051   ac_status=$?
12052   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12053   (exit $ac_status); }; } &&
12054          { ac_try='test -s conftest$ac_exeext'
12055   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12056   (eval $ac_try) 2>&5
12057   ac_status=$?
12058   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12059   (exit $ac_status); }; }; then
12060   ac_cv_lib_m_atan2=yes
12061 else
12062   echo "$as_me: failed program was:" >&5
12063 sed 's/^/| /' conftest.$ac_ext >&5
12064
12065 ac_cv_lib_m_atan2=no
12066 fi
12067 rm -f conftest.err conftest.$ac_objext \
12068       conftest$ac_exeext conftest.$ac_ext
12069 LIBS=$ac_check_lib_save_LIBS
12070 fi
12071 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2" >&5
12072 echo "${ECHO_T}$ac_cv_lib_m_atan2" >&6
12073 if test $ac_cv_lib_m_atan2 = yes; then
12074
12075 cat >>confdefs.h <<\_ACEOF
12076 #define HAVE_ATAN2 1
12077 _ACEOF
12078
12079 fi
12080
12081 echo "$as_me:$LINENO: checking for atan2l in -lm" >&5
12082 echo $ECHO_N "checking for atan2l in -lm... $ECHO_C" >&6
12083 if test "${ac_cv_lib_m_atan2l+set}" = set; then
12084   echo $ECHO_N "(cached) $ECHO_C" >&6
12085 else
12086   ac_check_lib_save_LIBS=$LIBS
12087 LIBS="-lm  $LIBS"
12088 if test x$gcc_no_link = xyes; then
12089   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12090 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12091    { (exit 1); exit 1; }; }
12092 fi
12093 cat >conftest.$ac_ext <<_ACEOF
12094 /* confdefs.h.  */
12095 _ACEOF
12096 cat confdefs.h >>conftest.$ac_ext
12097 cat >>conftest.$ac_ext <<_ACEOF
12098 /* end confdefs.h.  */
12099
12100 /* Override any gcc2 internal prototype to avoid an error.  */
12101 #ifdef __cplusplus
12102 extern "C"
12103 #endif
12104 /* We use char because int might match the return type of a gcc2
12105    builtin and then its argument prototype would still apply.  */
12106 char atan2l ();
12107 int
12108 main ()
12109 {
12110 atan2l ();
12111   ;
12112   return 0;
12113 }
12114 _ACEOF
12115 rm -f conftest.$ac_objext conftest$ac_exeext
12116 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12117   (eval $ac_link) 2>conftest.er1
12118   ac_status=$?
12119   grep -v '^ *+' conftest.er1 >conftest.err
12120   rm -f conftest.er1
12121   cat conftest.err >&5
12122   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12123   (exit $ac_status); } &&
12124          { ac_try='test -z "$ac_c_werror_flag"
12125                          || test ! -s conftest.err'
12126   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12127   (eval $ac_try) 2>&5
12128   ac_status=$?
12129   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12130   (exit $ac_status); }; } &&
12131          { ac_try='test -s conftest$ac_exeext'
12132   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12133   (eval $ac_try) 2>&5
12134   ac_status=$?
12135   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12136   (exit $ac_status); }; }; then
12137   ac_cv_lib_m_atan2l=yes
12138 else
12139   echo "$as_me: failed program was:" >&5
12140 sed 's/^/| /' conftest.$ac_ext >&5
12141
12142 ac_cv_lib_m_atan2l=no
12143 fi
12144 rm -f conftest.err conftest.$ac_objext \
12145       conftest$ac_exeext conftest.$ac_ext
12146 LIBS=$ac_check_lib_save_LIBS
12147 fi
12148 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2l" >&5
12149 echo "${ECHO_T}$ac_cv_lib_m_atan2l" >&6
12150 if test $ac_cv_lib_m_atan2l = yes; then
12151
12152 cat >>confdefs.h <<\_ACEOF
12153 #define HAVE_ATAN2L 1
12154 _ACEOF
12155
12156 fi
12157
12158 echo "$as_me:$LINENO: checking for atanf in -lm" >&5
12159 echo $ECHO_N "checking for atanf in -lm... $ECHO_C" >&6
12160 if test "${ac_cv_lib_m_atanf+set}" = set; then
12161   echo $ECHO_N "(cached) $ECHO_C" >&6
12162 else
12163   ac_check_lib_save_LIBS=$LIBS
12164 LIBS="-lm  $LIBS"
12165 if test x$gcc_no_link = xyes; then
12166   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12167 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12168    { (exit 1); exit 1; }; }
12169 fi
12170 cat >conftest.$ac_ext <<_ACEOF
12171 /* confdefs.h.  */
12172 _ACEOF
12173 cat confdefs.h >>conftest.$ac_ext
12174 cat >>conftest.$ac_ext <<_ACEOF
12175 /* end confdefs.h.  */
12176
12177 /* Override any gcc2 internal prototype to avoid an error.  */
12178 #ifdef __cplusplus
12179 extern "C"
12180 #endif
12181 /* We use char because int might match the return type of a gcc2
12182    builtin and then its argument prototype would still apply.  */
12183 char atanf ();
12184 int
12185 main ()
12186 {
12187 atanf ();
12188   ;
12189   return 0;
12190 }
12191 _ACEOF
12192 rm -f conftest.$ac_objext conftest$ac_exeext
12193 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12194   (eval $ac_link) 2>conftest.er1
12195   ac_status=$?
12196   grep -v '^ *+' conftest.er1 >conftest.err
12197   rm -f conftest.er1
12198   cat conftest.err >&5
12199   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12200   (exit $ac_status); } &&
12201          { ac_try='test -z "$ac_c_werror_flag"
12202                          || test ! -s conftest.err'
12203   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12204   (eval $ac_try) 2>&5
12205   ac_status=$?
12206   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12207   (exit $ac_status); }; } &&
12208          { ac_try='test -s conftest$ac_exeext'
12209   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12210   (eval $ac_try) 2>&5
12211   ac_status=$?
12212   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12213   (exit $ac_status); }; }; then
12214   ac_cv_lib_m_atanf=yes
12215 else
12216   echo "$as_me: failed program was:" >&5
12217 sed 's/^/| /' conftest.$ac_ext >&5
12218
12219 ac_cv_lib_m_atanf=no
12220 fi
12221 rm -f conftest.err conftest.$ac_objext \
12222       conftest$ac_exeext conftest.$ac_ext
12223 LIBS=$ac_check_lib_save_LIBS
12224 fi
12225 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanf" >&5
12226 echo "${ECHO_T}$ac_cv_lib_m_atanf" >&6
12227 if test $ac_cv_lib_m_atanf = yes; then
12228
12229 cat >>confdefs.h <<\_ACEOF
12230 #define HAVE_ATANF 1
12231 _ACEOF
12232
12233 fi
12234
12235 echo "$as_me:$LINENO: checking for atan in -lm" >&5
12236 echo $ECHO_N "checking for atan in -lm... $ECHO_C" >&6
12237 if test "${ac_cv_lib_m_atan+set}" = set; then
12238   echo $ECHO_N "(cached) $ECHO_C" >&6
12239 else
12240   ac_check_lib_save_LIBS=$LIBS
12241 LIBS="-lm  $LIBS"
12242 if test x$gcc_no_link = xyes; then
12243   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12244 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12245    { (exit 1); exit 1; }; }
12246 fi
12247 cat >conftest.$ac_ext <<_ACEOF
12248 /* confdefs.h.  */
12249 _ACEOF
12250 cat confdefs.h >>conftest.$ac_ext
12251 cat >>conftest.$ac_ext <<_ACEOF
12252 /* end confdefs.h.  */
12253
12254 /* Override any gcc2 internal prototype to avoid an error.  */
12255 #ifdef __cplusplus
12256 extern "C"
12257 #endif
12258 /* We use char because int might match the return type of a gcc2
12259    builtin and then its argument prototype would still apply.  */
12260 char atan ();
12261 int
12262 main ()
12263 {
12264 atan ();
12265   ;
12266   return 0;
12267 }
12268 _ACEOF
12269 rm -f conftest.$ac_objext conftest$ac_exeext
12270 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12271   (eval $ac_link) 2>conftest.er1
12272   ac_status=$?
12273   grep -v '^ *+' conftest.er1 >conftest.err
12274   rm -f conftest.er1
12275   cat conftest.err >&5
12276   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12277   (exit $ac_status); } &&
12278          { ac_try='test -z "$ac_c_werror_flag"
12279                          || test ! -s conftest.err'
12280   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12281   (eval $ac_try) 2>&5
12282   ac_status=$?
12283   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12284   (exit $ac_status); }; } &&
12285          { ac_try='test -s conftest$ac_exeext'
12286   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12287   (eval $ac_try) 2>&5
12288   ac_status=$?
12289   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12290   (exit $ac_status); }; }; then
12291   ac_cv_lib_m_atan=yes
12292 else
12293   echo "$as_me: failed program was:" >&5
12294 sed 's/^/| /' conftest.$ac_ext >&5
12295
12296 ac_cv_lib_m_atan=no
12297 fi
12298 rm -f conftest.err conftest.$ac_objext \
12299       conftest$ac_exeext conftest.$ac_ext
12300 LIBS=$ac_check_lib_save_LIBS
12301 fi
12302 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan" >&5
12303 echo "${ECHO_T}$ac_cv_lib_m_atan" >&6
12304 if test $ac_cv_lib_m_atan = yes; then
12305
12306 cat >>confdefs.h <<\_ACEOF
12307 #define HAVE_ATAN 1
12308 _ACEOF
12309
12310 fi
12311
12312 echo "$as_me:$LINENO: checking for atanl in -lm" >&5
12313 echo $ECHO_N "checking for atanl in -lm... $ECHO_C" >&6
12314 if test "${ac_cv_lib_m_atanl+set}" = set; then
12315   echo $ECHO_N "(cached) $ECHO_C" >&6
12316 else
12317   ac_check_lib_save_LIBS=$LIBS
12318 LIBS="-lm  $LIBS"
12319 if test x$gcc_no_link = xyes; then
12320   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12321 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12322    { (exit 1); exit 1; }; }
12323 fi
12324 cat >conftest.$ac_ext <<_ACEOF
12325 /* confdefs.h.  */
12326 _ACEOF
12327 cat confdefs.h >>conftest.$ac_ext
12328 cat >>conftest.$ac_ext <<_ACEOF
12329 /* end confdefs.h.  */
12330
12331 /* Override any gcc2 internal prototype to avoid an error.  */
12332 #ifdef __cplusplus
12333 extern "C"
12334 #endif
12335 /* We use char because int might match the return type of a gcc2
12336    builtin and then its argument prototype would still apply.  */
12337 char atanl ();
12338 int
12339 main ()
12340 {
12341 atanl ();
12342   ;
12343   return 0;
12344 }
12345 _ACEOF
12346 rm -f conftest.$ac_objext conftest$ac_exeext
12347 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12348   (eval $ac_link) 2>conftest.er1
12349   ac_status=$?
12350   grep -v '^ *+' conftest.er1 >conftest.err
12351   rm -f conftest.er1
12352   cat conftest.err >&5
12353   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12354   (exit $ac_status); } &&
12355          { ac_try='test -z "$ac_c_werror_flag"
12356                          || test ! -s conftest.err'
12357   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12358   (eval $ac_try) 2>&5
12359   ac_status=$?
12360   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12361   (exit $ac_status); }; } &&
12362          { ac_try='test -s conftest$ac_exeext'
12363   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12364   (eval $ac_try) 2>&5
12365   ac_status=$?
12366   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12367   (exit $ac_status); }; }; then
12368   ac_cv_lib_m_atanl=yes
12369 else
12370   echo "$as_me: failed program was:" >&5
12371 sed 's/^/| /' conftest.$ac_ext >&5
12372
12373 ac_cv_lib_m_atanl=no
12374 fi
12375 rm -f conftest.err conftest.$ac_objext \
12376       conftest$ac_exeext conftest.$ac_ext
12377 LIBS=$ac_check_lib_save_LIBS
12378 fi
12379 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanl" >&5
12380 echo "${ECHO_T}$ac_cv_lib_m_atanl" >&6
12381 if test $ac_cv_lib_m_atanl = yes; then
12382
12383 cat >>confdefs.h <<\_ACEOF
12384 #define HAVE_ATANL 1
12385 _ACEOF
12386
12387 fi
12388
12389 echo "$as_me:$LINENO: checking for atanhf in -lm" >&5
12390 echo $ECHO_N "checking for atanhf in -lm... $ECHO_C" >&6
12391 if test "${ac_cv_lib_m_atanhf+set}" = set; then
12392   echo $ECHO_N "(cached) $ECHO_C" >&6
12393 else
12394   ac_check_lib_save_LIBS=$LIBS
12395 LIBS="-lm  $LIBS"
12396 if test x$gcc_no_link = xyes; then
12397   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12398 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12399    { (exit 1); exit 1; }; }
12400 fi
12401 cat >conftest.$ac_ext <<_ACEOF
12402 /* confdefs.h.  */
12403 _ACEOF
12404 cat confdefs.h >>conftest.$ac_ext
12405 cat >>conftest.$ac_ext <<_ACEOF
12406 /* end confdefs.h.  */
12407
12408 /* Override any gcc2 internal prototype to avoid an error.  */
12409 #ifdef __cplusplus
12410 extern "C"
12411 #endif
12412 /* We use char because int might match the return type of a gcc2
12413    builtin and then its argument prototype would still apply.  */
12414 char atanhf ();
12415 int
12416 main ()
12417 {
12418 atanhf ();
12419   ;
12420   return 0;
12421 }
12422 _ACEOF
12423 rm -f conftest.$ac_objext conftest$ac_exeext
12424 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12425   (eval $ac_link) 2>conftest.er1
12426   ac_status=$?
12427   grep -v '^ *+' conftest.er1 >conftest.err
12428   rm -f conftest.er1
12429   cat conftest.err >&5
12430   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12431   (exit $ac_status); } &&
12432          { ac_try='test -z "$ac_c_werror_flag"
12433                          || test ! -s conftest.err'
12434   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12435   (eval $ac_try) 2>&5
12436   ac_status=$?
12437   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12438   (exit $ac_status); }; } &&
12439          { ac_try='test -s conftest$ac_exeext'
12440   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12441   (eval $ac_try) 2>&5
12442   ac_status=$?
12443   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12444   (exit $ac_status); }; }; then
12445   ac_cv_lib_m_atanhf=yes
12446 else
12447   echo "$as_me: failed program was:" >&5
12448 sed 's/^/| /' conftest.$ac_ext >&5
12449
12450 ac_cv_lib_m_atanhf=no
12451 fi
12452 rm -f conftest.err conftest.$ac_objext \
12453       conftest$ac_exeext conftest.$ac_ext
12454 LIBS=$ac_check_lib_save_LIBS
12455 fi
12456 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanhf" >&5
12457 echo "${ECHO_T}$ac_cv_lib_m_atanhf" >&6
12458 if test $ac_cv_lib_m_atanhf = yes; then
12459
12460 cat >>confdefs.h <<\_ACEOF
12461 #define HAVE_ATANHF 1
12462 _ACEOF
12463
12464 fi
12465
12466 echo "$as_me:$LINENO: checking for atanh in -lm" >&5
12467 echo $ECHO_N "checking for atanh in -lm... $ECHO_C" >&6
12468 if test "${ac_cv_lib_m_atanh+set}" = set; then
12469   echo $ECHO_N "(cached) $ECHO_C" >&6
12470 else
12471   ac_check_lib_save_LIBS=$LIBS
12472 LIBS="-lm  $LIBS"
12473 if test x$gcc_no_link = xyes; then
12474   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12475 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12476    { (exit 1); exit 1; }; }
12477 fi
12478 cat >conftest.$ac_ext <<_ACEOF
12479 /* confdefs.h.  */
12480 _ACEOF
12481 cat confdefs.h >>conftest.$ac_ext
12482 cat >>conftest.$ac_ext <<_ACEOF
12483 /* end confdefs.h.  */
12484
12485 /* Override any gcc2 internal prototype to avoid an error.  */
12486 #ifdef __cplusplus
12487 extern "C"
12488 #endif
12489 /* We use char because int might match the return type of a gcc2
12490    builtin and then its argument prototype would still apply.  */
12491 char atanh ();
12492 int
12493 main ()
12494 {
12495 atanh ();
12496   ;
12497   return 0;
12498 }
12499 _ACEOF
12500 rm -f conftest.$ac_objext conftest$ac_exeext
12501 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12502   (eval $ac_link) 2>conftest.er1
12503   ac_status=$?
12504   grep -v '^ *+' conftest.er1 >conftest.err
12505   rm -f conftest.er1
12506   cat conftest.err >&5
12507   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12508   (exit $ac_status); } &&
12509          { ac_try='test -z "$ac_c_werror_flag"
12510                          || test ! -s conftest.err'
12511   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12512   (eval $ac_try) 2>&5
12513   ac_status=$?
12514   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12515   (exit $ac_status); }; } &&
12516          { ac_try='test -s conftest$ac_exeext'
12517   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12518   (eval $ac_try) 2>&5
12519   ac_status=$?
12520   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12521   (exit $ac_status); }; }; then
12522   ac_cv_lib_m_atanh=yes
12523 else
12524   echo "$as_me: failed program was:" >&5
12525 sed 's/^/| /' conftest.$ac_ext >&5
12526
12527 ac_cv_lib_m_atanh=no
12528 fi
12529 rm -f conftest.err conftest.$ac_objext \
12530       conftest$ac_exeext conftest.$ac_ext
12531 LIBS=$ac_check_lib_save_LIBS
12532 fi
12533 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanh" >&5
12534 echo "${ECHO_T}$ac_cv_lib_m_atanh" >&6
12535 if test $ac_cv_lib_m_atanh = yes; then
12536
12537 cat >>confdefs.h <<\_ACEOF
12538 #define HAVE_ATANH 1
12539 _ACEOF
12540
12541 fi
12542
12543 echo "$as_me:$LINENO: checking for atanhl in -lm" >&5
12544 echo $ECHO_N "checking for atanhl in -lm... $ECHO_C" >&6
12545 if test "${ac_cv_lib_m_atanhl+set}" = set; then
12546   echo $ECHO_N "(cached) $ECHO_C" >&6
12547 else
12548   ac_check_lib_save_LIBS=$LIBS
12549 LIBS="-lm  $LIBS"
12550 if test x$gcc_no_link = xyes; then
12551   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12552 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12553    { (exit 1); exit 1; }; }
12554 fi
12555 cat >conftest.$ac_ext <<_ACEOF
12556 /* confdefs.h.  */
12557 _ACEOF
12558 cat confdefs.h >>conftest.$ac_ext
12559 cat >>conftest.$ac_ext <<_ACEOF
12560 /* end confdefs.h.  */
12561
12562 /* Override any gcc2 internal prototype to avoid an error.  */
12563 #ifdef __cplusplus
12564 extern "C"
12565 #endif
12566 /* We use char because int might match the return type of a gcc2
12567    builtin and then its argument prototype would still apply.  */
12568 char atanhl ();
12569 int
12570 main ()
12571 {
12572 atanhl ();
12573   ;
12574   return 0;
12575 }
12576 _ACEOF
12577 rm -f conftest.$ac_objext conftest$ac_exeext
12578 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12579   (eval $ac_link) 2>conftest.er1
12580   ac_status=$?
12581   grep -v '^ *+' conftest.er1 >conftest.err
12582   rm -f conftest.er1
12583   cat conftest.err >&5
12584   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12585   (exit $ac_status); } &&
12586          { ac_try='test -z "$ac_c_werror_flag"
12587                          || test ! -s conftest.err'
12588   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12589   (eval $ac_try) 2>&5
12590   ac_status=$?
12591   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12592   (exit $ac_status); }; } &&
12593          { ac_try='test -s conftest$ac_exeext'
12594   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12595   (eval $ac_try) 2>&5
12596   ac_status=$?
12597   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12598   (exit $ac_status); }; }; then
12599   ac_cv_lib_m_atanhl=yes
12600 else
12601   echo "$as_me: failed program was:" >&5
12602 sed 's/^/| /' conftest.$ac_ext >&5
12603
12604 ac_cv_lib_m_atanhl=no
12605 fi
12606 rm -f conftest.err conftest.$ac_objext \
12607       conftest$ac_exeext conftest.$ac_ext
12608 LIBS=$ac_check_lib_save_LIBS
12609 fi
12610 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanhl" >&5
12611 echo "${ECHO_T}$ac_cv_lib_m_atanhl" >&6
12612 if test $ac_cv_lib_m_atanhl = yes; then
12613
12614 cat >>confdefs.h <<\_ACEOF
12615 #define HAVE_ATANHL 1
12616 _ACEOF
12617
12618 fi
12619
12620 echo "$as_me:$LINENO: checking for cargf in -lm" >&5
12621 echo $ECHO_N "checking for cargf in -lm... $ECHO_C" >&6
12622 if test "${ac_cv_lib_m_cargf+set}" = set; then
12623   echo $ECHO_N "(cached) $ECHO_C" >&6
12624 else
12625   ac_check_lib_save_LIBS=$LIBS
12626 LIBS="-lm  $LIBS"
12627 if test x$gcc_no_link = xyes; then
12628   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12629 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12630    { (exit 1); exit 1; }; }
12631 fi
12632 cat >conftest.$ac_ext <<_ACEOF
12633 /* confdefs.h.  */
12634 _ACEOF
12635 cat confdefs.h >>conftest.$ac_ext
12636 cat >>conftest.$ac_ext <<_ACEOF
12637 /* end confdefs.h.  */
12638
12639 /* Override any gcc2 internal prototype to avoid an error.  */
12640 #ifdef __cplusplus
12641 extern "C"
12642 #endif
12643 /* We use char because int might match the return type of a gcc2
12644    builtin and then its argument prototype would still apply.  */
12645 char cargf ();
12646 int
12647 main ()
12648 {
12649 cargf ();
12650   ;
12651   return 0;
12652 }
12653 _ACEOF
12654 rm -f conftest.$ac_objext conftest$ac_exeext
12655 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12656   (eval $ac_link) 2>conftest.er1
12657   ac_status=$?
12658   grep -v '^ *+' conftest.er1 >conftest.err
12659   rm -f conftest.er1
12660   cat conftest.err >&5
12661   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12662   (exit $ac_status); } &&
12663          { ac_try='test -z "$ac_c_werror_flag"
12664                          || test ! -s conftest.err'
12665   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12666   (eval $ac_try) 2>&5
12667   ac_status=$?
12668   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12669   (exit $ac_status); }; } &&
12670          { ac_try='test -s conftest$ac_exeext'
12671   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12672   (eval $ac_try) 2>&5
12673   ac_status=$?
12674   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12675   (exit $ac_status); }; }; then
12676   ac_cv_lib_m_cargf=yes
12677 else
12678   echo "$as_me: failed program was:" >&5
12679 sed 's/^/| /' conftest.$ac_ext >&5
12680
12681 ac_cv_lib_m_cargf=no
12682 fi
12683 rm -f conftest.err conftest.$ac_objext \
12684       conftest$ac_exeext conftest.$ac_ext
12685 LIBS=$ac_check_lib_save_LIBS
12686 fi
12687 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cargf" >&5
12688 echo "${ECHO_T}$ac_cv_lib_m_cargf" >&6
12689 if test $ac_cv_lib_m_cargf = yes; then
12690
12691 cat >>confdefs.h <<\_ACEOF
12692 #define HAVE_CARGF 1
12693 _ACEOF
12694
12695 fi
12696
12697 echo "$as_me:$LINENO: checking for carg in -lm" >&5
12698 echo $ECHO_N "checking for carg in -lm... $ECHO_C" >&6
12699 if test "${ac_cv_lib_m_carg+set}" = set; then
12700   echo $ECHO_N "(cached) $ECHO_C" >&6
12701 else
12702   ac_check_lib_save_LIBS=$LIBS
12703 LIBS="-lm  $LIBS"
12704 if test x$gcc_no_link = xyes; then
12705   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12706 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12707    { (exit 1); exit 1; }; }
12708 fi
12709 cat >conftest.$ac_ext <<_ACEOF
12710 /* confdefs.h.  */
12711 _ACEOF
12712 cat confdefs.h >>conftest.$ac_ext
12713 cat >>conftest.$ac_ext <<_ACEOF
12714 /* end confdefs.h.  */
12715
12716 /* Override any gcc2 internal prototype to avoid an error.  */
12717 #ifdef __cplusplus
12718 extern "C"
12719 #endif
12720 /* We use char because int might match the return type of a gcc2
12721    builtin and then its argument prototype would still apply.  */
12722 char carg ();
12723 int
12724 main ()
12725 {
12726 carg ();
12727   ;
12728   return 0;
12729 }
12730 _ACEOF
12731 rm -f conftest.$ac_objext conftest$ac_exeext
12732 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12733   (eval $ac_link) 2>conftest.er1
12734   ac_status=$?
12735   grep -v '^ *+' conftest.er1 >conftest.err
12736   rm -f conftest.er1
12737   cat conftest.err >&5
12738   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12739   (exit $ac_status); } &&
12740          { ac_try='test -z "$ac_c_werror_flag"
12741                          || test ! -s conftest.err'
12742   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12743   (eval $ac_try) 2>&5
12744   ac_status=$?
12745   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12746   (exit $ac_status); }; } &&
12747          { ac_try='test -s conftest$ac_exeext'
12748   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12749   (eval $ac_try) 2>&5
12750   ac_status=$?
12751   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12752   (exit $ac_status); }; }; then
12753   ac_cv_lib_m_carg=yes
12754 else
12755   echo "$as_me: failed program was:" >&5
12756 sed 's/^/| /' conftest.$ac_ext >&5
12757
12758 ac_cv_lib_m_carg=no
12759 fi
12760 rm -f conftest.err conftest.$ac_objext \
12761       conftest$ac_exeext conftest.$ac_ext
12762 LIBS=$ac_check_lib_save_LIBS
12763 fi
12764 echo "$as_me:$LINENO: result: $ac_cv_lib_m_carg" >&5
12765 echo "${ECHO_T}$ac_cv_lib_m_carg" >&6
12766 if test $ac_cv_lib_m_carg = yes; then
12767
12768 cat >>confdefs.h <<\_ACEOF
12769 #define HAVE_CARG 1
12770 _ACEOF
12771
12772 fi
12773
12774 echo "$as_me:$LINENO: checking for cargl in -lm" >&5
12775 echo $ECHO_N "checking for cargl in -lm... $ECHO_C" >&6
12776 if test "${ac_cv_lib_m_cargl+set}" = set; then
12777   echo $ECHO_N "(cached) $ECHO_C" >&6
12778 else
12779   ac_check_lib_save_LIBS=$LIBS
12780 LIBS="-lm  $LIBS"
12781 if test x$gcc_no_link = xyes; then
12782   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12783 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12784    { (exit 1); exit 1; }; }
12785 fi
12786 cat >conftest.$ac_ext <<_ACEOF
12787 /* confdefs.h.  */
12788 _ACEOF
12789 cat confdefs.h >>conftest.$ac_ext
12790 cat >>conftest.$ac_ext <<_ACEOF
12791 /* end confdefs.h.  */
12792
12793 /* Override any gcc2 internal prototype to avoid an error.  */
12794 #ifdef __cplusplus
12795 extern "C"
12796 #endif
12797 /* We use char because int might match the return type of a gcc2
12798    builtin and then its argument prototype would still apply.  */
12799 char cargl ();
12800 int
12801 main ()
12802 {
12803 cargl ();
12804   ;
12805   return 0;
12806 }
12807 _ACEOF
12808 rm -f conftest.$ac_objext conftest$ac_exeext
12809 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12810   (eval $ac_link) 2>conftest.er1
12811   ac_status=$?
12812   grep -v '^ *+' conftest.er1 >conftest.err
12813   rm -f conftest.er1
12814   cat conftest.err >&5
12815   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12816   (exit $ac_status); } &&
12817          { ac_try='test -z "$ac_c_werror_flag"
12818                          || test ! -s conftest.err'
12819   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12820   (eval $ac_try) 2>&5
12821   ac_status=$?
12822   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12823   (exit $ac_status); }; } &&
12824          { ac_try='test -s conftest$ac_exeext'
12825   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12826   (eval $ac_try) 2>&5
12827   ac_status=$?
12828   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12829   (exit $ac_status); }; }; then
12830   ac_cv_lib_m_cargl=yes
12831 else
12832   echo "$as_me: failed program was:" >&5
12833 sed 's/^/| /' conftest.$ac_ext >&5
12834
12835 ac_cv_lib_m_cargl=no
12836 fi
12837 rm -f conftest.err conftest.$ac_objext \
12838       conftest$ac_exeext conftest.$ac_ext
12839 LIBS=$ac_check_lib_save_LIBS
12840 fi
12841 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cargl" >&5
12842 echo "${ECHO_T}$ac_cv_lib_m_cargl" >&6
12843 if test $ac_cv_lib_m_cargl = yes; then
12844
12845 cat >>confdefs.h <<\_ACEOF
12846 #define HAVE_CARGL 1
12847 _ACEOF
12848
12849 fi
12850
12851 echo "$as_me:$LINENO: checking for ceilf in -lm" >&5
12852 echo $ECHO_N "checking for ceilf in -lm... $ECHO_C" >&6
12853 if test "${ac_cv_lib_m_ceilf+set}" = set; then
12854   echo $ECHO_N "(cached) $ECHO_C" >&6
12855 else
12856   ac_check_lib_save_LIBS=$LIBS
12857 LIBS="-lm  $LIBS"
12858 if test x$gcc_no_link = xyes; then
12859   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12860 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12861    { (exit 1); exit 1; }; }
12862 fi
12863 cat >conftest.$ac_ext <<_ACEOF
12864 /* confdefs.h.  */
12865 _ACEOF
12866 cat confdefs.h >>conftest.$ac_ext
12867 cat >>conftest.$ac_ext <<_ACEOF
12868 /* end confdefs.h.  */
12869
12870 /* Override any gcc2 internal prototype to avoid an error.  */
12871 #ifdef __cplusplus
12872 extern "C"
12873 #endif
12874 /* We use char because int might match the return type of a gcc2
12875    builtin and then its argument prototype would still apply.  */
12876 char ceilf ();
12877 int
12878 main ()
12879 {
12880 ceilf ();
12881   ;
12882   return 0;
12883 }
12884 _ACEOF
12885 rm -f conftest.$ac_objext conftest$ac_exeext
12886 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12887   (eval $ac_link) 2>conftest.er1
12888   ac_status=$?
12889   grep -v '^ *+' conftest.er1 >conftest.err
12890   rm -f conftest.er1
12891   cat conftest.err >&5
12892   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12893   (exit $ac_status); } &&
12894          { ac_try='test -z "$ac_c_werror_flag"
12895                          || test ! -s conftest.err'
12896   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12897   (eval $ac_try) 2>&5
12898   ac_status=$?
12899   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12900   (exit $ac_status); }; } &&
12901          { ac_try='test -s conftest$ac_exeext'
12902   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12903   (eval $ac_try) 2>&5
12904   ac_status=$?
12905   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12906   (exit $ac_status); }; }; then
12907   ac_cv_lib_m_ceilf=yes
12908 else
12909   echo "$as_me: failed program was:" >&5
12910 sed 's/^/| /' conftest.$ac_ext >&5
12911
12912 ac_cv_lib_m_ceilf=no
12913 fi
12914 rm -f conftest.err conftest.$ac_objext \
12915       conftest$ac_exeext conftest.$ac_ext
12916 LIBS=$ac_check_lib_save_LIBS
12917 fi
12918 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceilf" >&5
12919 echo "${ECHO_T}$ac_cv_lib_m_ceilf" >&6
12920 if test $ac_cv_lib_m_ceilf = yes; then
12921
12922 cat >>confdefs.h <<\_ACEOF
12923 #define HAVE_CEILF 1
12924 _ACEOF
12925
12926 fi
12927
12928 echo "$as_me:$LINENO: checking for ceil in -lm" >&5
12929 echo $ECHO_N "checking for ceil in -lm... $ECHO_C" >&6
12930 if test "${ac_cv_lib_m_ceil+set}" = set; then
12931   echo $ECHO_N "(cached) $ECHO_C" >&6
12932 else
12933   ac_check_lib_save_LIBS=$LIBS
12934 LIBS="-lm  $LIBS"
12935 if test x$gcc_no_link = xyes; then
12936   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12937 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12938    { (exit 1); exit 1; }; }
12939 fi
12940 cat >conftest.$ac_ext <<_ACEOF
12941 /* confdefs.h.  */
12942 _ACEOF
12943 cat confdefs.h >>conftest.$ac_ext
12944 cat >>conftest.$ac_ext <<_ACEOF
12945 /* end confdefs.h.  */
12946
12947 /* Override any gcc2 internal prototype to avoid an error.  */
12948 #ifdef __cplusplus
12949 extern "C"
12950 #endif
12951 /* We use char because int might match the return type of a gcc2
12952    builtin and then its argument prototype would still apply.  */
12953 char ceil ();
12954 int
12955 main ()
12956 {
12957 ceil ();
12958   ;
12959   return 0;
12960 }
12961 _ACEOF
12962 rm -f conftest.$ac_objext conftest$ac_exeext
12963 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12964   (eval $ac_link) 2>conftest.er1
12965   ac_status=$?
12966   grep -v '^ *+' conftest.er1 >conftest.err
12967   rm -f conftest.er1
12968   cat conftest.err >&5
12969   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12970   (exit $ac_status); } &&
12971          { ac_try='test -z "$ac_c_werror_flag"
12972                          || test ! -s conftest.err'
12973   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12974   (eval $ac_try) 2>&5
12975   ac_status=$?
12976   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12977   (exit $ac_status); }; } &&
12978          { ac_try='test -s conftest$ac_exeext'
12979   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12980   (eval $ac_try) 2>&5
12981   ac_status=$?
12982   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12983   (exit $ac_status); }; }; then
12984   ac_cv_lib_m_ceil=yes
12985 else
12986   echo "$as_me: failed program was:" >&5
12987 sed 's/^/| /' conftest.$ac_ext >&5
12988
12989 ac_cv_lib_m_ceil=no
12990 fi
12991 rm -f conftest.err conftest.$ac_objext \
12992       conftest$ac_exeext conftest.$ac_ext
12993 LIBS=$ac_check_lib_save_LIBS
12994 fi
12995 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceil" >&5
12996 echo "${ECHO_T}$ac_cv_lib_m_ceil" >&6
12997 if test $ac_cv_lib_m_ceil = yes; then
12998
12999 cat >>confdefs.h <<\_ACEOF
13000 #define HAVE_CEIL 1
13001 _ACEOF
13002
13003 fi
13004
13005 echo "$as_me:$LINENO: checking for ceill in -lm" >&5
13006 echo $ECHO_N "checking for ceill in -lm... $ECHO_C" >&6
13007 if test "${ac_cv_lib_m_ceill+set}" = set; then
13008   echo $ECHO_N "(cached) $ECHO_C" >&6
13009 else
13010   ac_check_lib_save_LIBS=$LIBS
13011 LIBS="-lm  $LIBS"
13012 if test x$gcc_no_link = xyes; then
13013   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13014 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13015    { (exit 1); exit 1; }; }
13016 fi
13017 cat >conftest.$ac_ext <<_ACEOF
13018 /* confdefs.h.  */
13019 _ACEOF
13020 cat confdefs.h >>conftest.$ac_ext
13021 cat >>conftest.$ac_ext <<_ACEOF
13022 /* end confdefs.h.  */
13023
13024 /* Override any gcc2 internal prototype to avoid an error.  */
13025 #ifdef __cplusplus
13026 extern "C"
13027 #endif
13028 /* We use char because int might match the return type of a gcc2
13029    builtin and then its argument prototype would still apply.  */
13030 char ceill ();
13031 int
13032 main ()
13033 {
13034 ceill ();
13035   ;
13036   return 0;
13037 }
13038 _ACEOF
13039 rm -f conftest.$ac_objext conftest$ac_exeext
13040 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13041   (eval $ac_link) 2>conftest.er1
13042   ac_status=$?
13043   grep -v '^ *+' conftest.er1 >conftest.err
13044   rm -f conftest.er1
13045   cat conftest.err >&5
13046   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13047   (exit $ac_status); } &&
13048          { ac_try='test -z "$ac_c_werror_flag"
13049                          || test ! -s conftest.err'
13050   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13051   (eval $ac_try) 2>&5
13052   ac_status=$?
13053   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13054   (exit $ac_status); }; } &&
13055          { ac_try='test -s conftest$ac_exeext'
13056   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13057   (eval $ac_try) 2>&5
13058   ac_status=$?
13059   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13060   (exit $ac_status); }; }; then
13061   ac_cv_lib_m_ceill=yes
13062 else
13063   echo "$as_me: failed program was:" >&5
13064 sed 's/^/| /' conftest.$ac_ext >&5
13065
13066 ac_cv_lib_m_ceill=no
13067 fi
13068 rm -f conftest.err conftest.$ac_objext \
13069       conftest$ac_exeext conftest.$ac_ext
13070 LIBS=$ac_check_lib_save_LIBS
13071 fi
13072 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceill" >&5
13073 echo "${ECHO_T}$ac_cv_lib_m_ceill" >&6
13074 if test $ac_cv_lib_m_ceill = yes; then
13075
13076 cat >>confdefs.h <<\_ACEOF
13077 #define HAVE_CEILL 1
13078 _ACEOF
13079
13080 fi
13081
13082 echo "$as_me:$LINENO: checking for copysignf in -lm" >&5
13083 echo $ECHO_N "checking for copysignf in -lm... $ECHO_C" >&6
13084 if test "${ac_cv_lib_m_copysignf+set}" = set; then
13085   echo $ECHO_N "(cached) $ECHO_C" >&6
13086 else
13087   ac_check_lib_save_LIBS=$LIBS
13088 LIBS="-lm  $LIBS"
13089 if test x$gcc_no_link = xyes; then
13090   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13091 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13092    { (exit 1); exit 1; }; }
13093 fi
13094 cat >conftest.$ac_ext <<_ACEOF
13095 /* confdefs.h.  */
13096 _ACEOF
13097 cat confdefs.h >>conftest.$ac_ext
13098 cat >>conftest.$ac_ext <<_ACEOF
13099 /* end confdefs.h.  */
13100
13101 /* Override any gcc2 internal prototype to avoid an error.  */
13102 #ifdef __cplusplus
13103 extern "C"
13104 #endif
13105 /* We use char because int might match the return type of a gcc2
13106    builtin and then its argument prototype would still apply.  */
13107 char copysignf ();
13108 int
13109 main ()
13110 {
13111 copysignf ();
13112   ;
13113   return 0;
13114 }
13115 _ACEOF
13116 rm -f conftest.$ac_objext conftest$ac_exeext
13117 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13118   (eval $ac_link) 2>conftest.er1
13119   ac_status=$?
13120   grep -v '^ *+' conftest.er1 >conftest.err
13121   rm -f conftest.er1
13122   cat conftest.err >&5
13123   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13124   (exit $ac_status); } &&
13125          { ac_try='test -z "$ac_c_werror_flag"
13126                          || test ! -s conftest.err'
13127   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13128   (eval $ac_try) 2>&5
13129   ac_status=$?
13130   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13131   (exit $ac_status); }; } &&
13132          { ac_try='test -s conftest$ac_exeext'
13133   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13134   (eval $ac_try) 2>&5
13135   ac_status=$?
13136   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13137   (exit $ac_status); }; }; then
13138   ac_cv_lib_m_copysignf=yes
13139 else
13140   echo "$as_me: failed program was:" >&5
13141 sed 's/^/| /' conftest.$ac_ext >&5
13142
13143 ac_cv_lib_m_copysignf=no
13144 fi
13145 rm -f conftest.err conftest.$ac_objext \
13146       conftest$ac_exeext conftest.$ac_ext
13147 LIBS=$ac_check_lib_save_LIBS
13148 fi
13149 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysignf" >&5
13150 echo "${ECHO_T}$ac_cv_lib_m_copysignf" >&6
13151 if test $ac_cv_lib_m_copysignf = yes; then
13152
13153 cat >>confdefs.h <<\_ACEOF
13154 #define HAVE_COPYSIGNF 1
13155 _ACEOF
13156
13157 fi
13158
13159 echo "$as_me:$LINENO: checking for copysign in -lm" >&5
13160 echo $ECHO_N "checking for copysign in -lm... $ECHO_C" >&6
13161 if test "${ac_cv_lib_m_copysign+set}" = set; then
13162   echo $ECHO_N "(cached) $ECHO_C" >&6
13163 else
13164   ac_check_lib_save_LIBS=$LIBS
13165 LIBS="-lm  $LIBS"
13166 if test x$gcc_no_link = xyes; then
13167   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13168 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13169    { (exit 1); exit 1; }; }
13170 fi
13171 cat >conftest.$ac_ext <<_ACEOF
13172 /* confdefs.h.  */
13173 _ACEOF
13174 cat confdefs.h >>conftest.$ac_ext
13175 cat >>conftest.$ac_ext <<_ACEOF
13176 /* end confdefs.h.  */
13177
13178 /* Override any gcc2 internal prototype to avoid an error.  */
13179 #ifdef __cplusplus
13180 extern "C"
13181 #endif
13182 /* We use char because int might match the return type of a gcc2
13183    builtin and then its argument prototype would still apply.  */
13184 char copysign ();
13185 int
13186 main ()
13187 {
13188 copysign ();
13189   ;
13190   return 0;
13191 }
13192 _ACEOF
13193 rm -f conftest.$ac_objext conftest$ac_exeext
13194 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13195   (eval $ac_link) 2>conftest.er1
13196   ac_status=$?
13197   grep -v '^ *+' conftest.er1 >conftest.err
13198   rm -f conftest.er1
13199   cat conftest.err >&5
13200   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13201   (exit $ac_status); } &&
13202          { ac_try='test -z "$ac_c_werror_flag"
13203                          || test ! -s conftest.err'
13204   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13205   (eval $ac_try) 2>&5
13206   ac_status=$?
13207   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13208   (exit $ac_status); }; } &&
13209          { ac_try='test -s conftest$ac_exeext'
13210   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13211   (eval $ac_try) 2>&5
13212   ac_status=$?
13213   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13214   (exit $ac_status); }; }; then
13215   ac_cv_lib_m_copysign=yes
13216 else
13217   echo "$as_me: failed program was:" >&5
13218 sed 's/^/| /' conftest.$ac_ext >&5
13219
13220 ac_cv_lib_m_copysign=no
13221 fi
13222 rm -f conftest.err conftest.$ac_objext \
13223       conftest$ac_exeext conftest.$ac_ext
13224 LIBS=$ac_check_lib_save_LIBS
13225 fi
13226 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysign" >&5
13227 echo "${ECHO_T}$ac_cv_lib_m_copysign" >&6
13228 if test $ac_cv_lib_m_copysign = yes; then
13229
13230 cat >>confdefs.h <<\_ACEOF
13231 #define HAVE_COPYSIGN 1
13232 _ACEOF
13233
13234 fi
13235
13236 echo "$as_me:$LINENO: checking for copysignl in -lm" >&5
13237 echo $ECHO_N "checking for copysignl in -lm... $ECHO_C" >&6
13238 if test "${ac_cv_lib_m_copysignl+set}" = set; then
13239   echo $ECHO_N "(cached) $ECHO_C" >&6
13240 else
13241   ac_check_lib_save_LIBS=$LIBS
13242 LIBS="-lm  $LIBS"
13243 if test x$gcc_no_link = xyes; then
13244   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13245 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13246    { (exit 1); exit 1; }; }
13247 fi
13248 cat >conftest.$ac_ext <<_ACEOF
13249 /* confdefs.h.  */
13250 _ACEOF
13251 cat confdefs.h >>conftest.$ac_ext
13252 cat >>conftest.$ac_ext <<_ACEOF
13253 /* end confdefs.h.  */
13254
13255 /* Override any gcc2 internal prototype to avoid an error.  */
13256 #ifdef __cplusplus
13257 extern "C"
13258 #endif
13259 /* We use char because int might match the return type of a gcc2
13260    builtin and then its argument prototype would still apply.  */
13261 char copysignl ();
13262 int
13263 main ()
13264 {
13265 copysignl ();
13266   ;
13267   return 0;
13268 }
13269 _ACEOF
13270 rm -f conftest.$ac_objext conftest$ac_exeext
13271 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13272   (eval $ac_link) 2>conftest.er1
13273   ac_status=$?
13274   grep -v '^ *+' conftest.er1 >conftest.err
13275   rm -f conftest.er1
13276   cat conftest.err >&5
13277   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13278   (exit $ac_status); } &&
13279          { ac_try='test -z "$ac_c_werror_flag"
13280                          || test ! -s conftest.err'
13281   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13282   (eval $ac_try) 2>&5
13283   ac_status=$?
13284   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13285   (exit $ac_status); }; } &&
13286          { ac_try='test -s conftest$ac_exeext'
13287   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13288   (eval $ac_try) 2>&5
13289   ac_status=$?
13290   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13291   (exit $ac_status); }; }; then
13292   ac_cv_lib_m_copysignl=yes
13293 else
13294   echo "$as_me: failed program was:" >&5
13295 sed 's/^/| /' conftest.$ac_ext >&5
13296
13297 ac_cv_lib_m_copysignl=no
13298 fi
13299 rm -f conftest.err conftest.$ac_objext \
13300       conftest$ac_exeext conftest.$ac_ext
13301 LIBS=$ac_check_lib_save_LIBS
13302 fi
13303 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysignl" >&5
13304 echo "${ECHO_T}$ac_cv_lib_m_copysignl" >&6
13305 if test $ac_cv_lib_m_copysignl = yes; then
13306
13307 cat >>confdefs.h <<\_ACEOF
13308 #define HAVE_COPYSIGNL 1
13309 _ACEOF
13310
13311 fi
13312
13313 echo "$as_me:$LINENO: checking for cosf in -lm" >&5
13314 echo $ECHO_N "checking for cosf in -lm... $ECHO_C" >&6
13315 if test "${ac_cv_lib_m_cosf+set}" = set; then
13316   echo $ECHO_N "(cached) $ECHO_C" >&6
13317 else
13318   ac_check_lib_save_LIBS=$LIBS
13319 LIBS="-lm  $LIBS"
13320 if test x$gcc_no_link = xyes; then
13321   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13322 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13323    { (exit 1); exit 1; }; }
13324 fi
13325 cat >conftest.$ac_ext <<_ACEOF
13326 /* confdefs.h.  */
13327 _ACEOF
13328 cat confdefs.h >>conftest.$ac_ext
13329 cat >>conftest.$ac_ext <<_ACEOF
13330 /* end confdefs.h.  */
13331
13332 /* Override any gcc2 internal prototype to avoid an error.  */
13333 #ifdef __cplusplus
13334 extern "C"
13335 #endif
13336 /* We use char because int might match the return type of a gcc2
13337    builtin and then its argument prototype would still apply.  */
13338 char cosf ();
13339 int
13340 main ()
13341 {
13342 cosf ();
13343   ;
13344   return 0;
13345 }
13346 _ACEOF
13347 rm -f conftest.$ac_objext conftest$ac_exeext
13348 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13349   (eval $ac_link) 2>conftest.er1
13350   ac_status=$?
13351   grep -v '^ *+' conftest.er1 >conftest.err
13352   rm -f conftest.er1
13353   cat conftest.err >&5
13354   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13355   (exit $ac_status); } &&
13356          { ac_try='test -z "$ac_c_werror_flag"
13357                          || test ! -s conftest.err'
13358   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13359   (eval $ac_try) 2>&5
13360   ac_status=$?
13361   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13362   (exit $ac_status); }; } &&
13363          { ac_try='test -s conftest$ac_exeext'
13364   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13365   (eval $ac_try) 2>&5
13366   ac_status=$?
13367   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13368   (exit $ac_status); }; }; then
13369   ac_cv_lib_m_cosf=yes
13370 else
13371   echo "$as_me: failed program was:" >&5
13372 sed 's/^/| /' conftest.$ac_ext >&5
13373
13374 ac_cv_lib_m_cosf=no
13375 fi
13376 rm -f conftest.err conftest.$ac_objext \
13377       conftest$ac_exeext conftest.$ac_ext
13378 LIBS=$ac_check_lib_save_LIBS
13379 fi
13380 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosf" >&5
13381 echo "${ECHO_T}$ac_cv_lib_m_cosf" >&6
13382 if test $ac_cv_lib_m_cosf = yes; then
13383
13384 cat >>confdefs.h <<\_ACEOF
13385 #define HAVE_COSF 1
13386 _ACEOF
13387
13388 fi
13389
13390 echo "$as_me:$LINENO: checking for cos in -lm" >&5
13391 echo $ECHO_N "checking for cos in -lm... $ECHO_C" >&6
13392 if test "${ac_cv_lib_m_cos+set}" = set; then
13393   echo $ECHO_N "(cached) $ECHO_C" >&6
13394 else
13395   ac_check_lib_save_LIBS=$LIBS
13396 LIBS="-lm  $LIBS"
13397 if test x$gcc_no_link = xyes; then
13398   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13399 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13400    { (exit 1); exit 1; }; }
13401 fi
13402 cat >conftest.$ac_ext <<_ACEOF
13403 /* confdefs.h.  */
13404 _ACEOF
13405 cat confdefs.h >>conftest.$ac_ext
13406 cat >>conftest.$ac_ext <<_ACEOF
13407 /* end confdefs.h.  */
13408
13409 /* Override any gcc2 internal prototype to avoid an error.  */
13410 #ifdef __cplusplus
13411 extern "C"
13412 #endif
13413 /* We use char because int might match the return type of a gcc2
13414    builtin and then its argument prototype would still apply.  */
13415 char cos ();
13416 int
13417 main ()
13418 {
13419 cos ();
13420   ;
13421   return 0;
13422 }
13423 _ACEOF
13424 rm -f conftest.$ac_objext conftest$ac_exeext
13425 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13426   (eval $ac_link) 2>conftest.er1
13427   ac_status=$?
13428   grep -v '^ *+' conftest.er1 >conftest.err
13429   rm -f conftest.er1
13430   cat conftest.err >&5
13431   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13432   (exit $ac_status); } &&
13433          { ac_try='test -z "$ac_c_werror_flag"
13434                          || test ! -s conftest.err'
13435   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13436   (eval $ac_try) 2>&5
13437   ac_status=$?
13438   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13439   (exit $ac_status); }; } &&
13440          { ac_try='test -s conftest$ac_exeext'
13441   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13442   (eval $ac_try) 2>&5
13443   ac_status=$?
13444   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13445   (exit $ac_status); }; }; then
13446   ac_cv_lib_m_cos=yes
13447 else
13448   echo "$as_me: failed program was:" >&5
13449 sed 's/^/| /' conftest.$ac_ext >&5
13450
13451 ac_cv_lib_m_cos=no
13452 fi
13453 rm -f conftest.err conftest.$ac_objext \
13454       conftest$ac_exeext conftest.$ac_ext
13455 LIBS=$ac_check_lib_save_LIBS
13456 fi
13457 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cos" >&5
13458 echo "${ECHO_T}$ac_cv_lib_m_cos" >&6
13459 if test $ac_cv_lib_m_cos = yes; then
13460
13461 cat >>confdefs.h <<\_ACEOF
13462 #define HAVE_COS 1
13463 _ACEOF
13464
13465 fi
13466
13467 echo "$as_me:$LINENO: checking for cosl in -lm" >&5
13468 echo $ECHO_N "checking for cosl in -lm... $ECHO_C" >&6
13469 if test "${ac_cv_lib_m_cosl+set}" = set; then
13470   echo $ECHO_N "(cached) $ECHO_C" >&6
13471 else
13472   ac_check_lib_save_LIBS=$LIBS
13473 LIBS="-lm  $LIBS"
13474 if test x$gcc_no_link = xyes; then
13475   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13476 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13477    { (exit 1); exit 1; }; }
13478 fi
13479 cat >conftest.$ac_ext <<_ACEOF
13480 /* confdefs.h.  */
13481 _ACEOF
13482 cat confdefs.h >>conftest.$ac_ext
13483 cat >>conftest.$ac_ext <<_ACEOF
13484 /* end confdefs.h.  */
13485
13486 /* Override any gcc2 internal prototype to avoid an error.  */
13487 #ifdef __cplusplus
13488 extern "C"
13489 #endif
13490 /* We use char because int might match the return type of a gcc2
13491    builtin and then its argument prototype would still apply.  */
13492 char cosl ();
13493 int
13494 main ()
13495 {
13496 cosl ();
13497   ;
13498   return 0;
13499 }
13500 _ACEOF
13501 rm -f conftest.$ac_objext conftest$ac_exeext
13502 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13503   (eval $ac_link) 2>conftest.er1
13504   ac_status=$?
13505   grep -v '^ *+' conftest.er1 >conftest.err
13506   rm -f conftest.er1
13507   cat conftest.err >&5
13508   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13509   (exit $ac_status); } &&
13510          { ac_try='test -z "$ac_c_werror_flag"
13511                          || test ! -s conftest.err'
13512   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13513   (eval $ac_try) 2>&5
13514   ac_status=$?
13515   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13516   (exit $ac_status); }; } &&
13517          { ac_try='test -s conftest$ac_exeext'
13518   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13519   (eval $ac_try) 2>&5
13520   ac_status=$?
13521   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13522   (exit $ac_status); }; }; then
13523   ac_cv_lib_m_cosl=yes
13524 else
13525   echo "$as_me: failed program was:" >&5
13526 sed 's/^/| /' conftest.$ac_ext >&5
13527
13528 ac_cv_lib_m_cosl=no
13529 fi
13530 rm -f conftest.err conftest.$ac_objext \
13531       conftest$ac_exeext conftest.$ac_ext
13532 LIBS=$ac_check_lib_save_LIBS
13533 fi
13534 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosl" >&5
13535 echo "${ECHO_T}$ac_cv_lib_m_cosl" >&6
13536 if test $ac_cv_lib_m_cosl = yes; then
13537
13538 cat >>confdefs.h <<\_ACEOF
13539 #define HAVE_COSL 1
13540 _ACEOF
13541
13542 fi
13543
13544 echo "$as_me:$LINENO: checking for ccosf in -lm" >&5
13545 echo $ECHO_N "checking for ccosf in -lm... $ECHO_C" >&6
13546 if test "${ac_cv_lib_m_ccosf+set}" = set; then
13547   echo $ECHO_N "(cached) $ECHO_C" >&6
13548 else
13549   ac_check_lib_save_LIBS=$LIBS
13550 LIBS="-lm  $LIBS"
13551 if test x$gcc_no_link = xyes; then
13552   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13553 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13554    { (exit 1); exit 1; }; }
13555 fi
13556 cat >conftest.$ac_ext <<_ACEOF
13557 /* confdefs.h.  */
13558 _ACEOF
13559 cat confdefs.h >>conftest.$ac_ext
13560 cat >>conftest.$ac_ext <<_ACEOF
13561 /* end confdefs.h.  */
13562
13563 /* Override any gcc2 internal prototype to avoid an error.  */
13564 #ifdef __cplusplus
13565 extern "C"
13566 #endif
13567 /* We use char because int might match the return type of a gcc2
13568    builtin and then its argument prototype would still apply.  */
13569 char ccosf ();
13570 int
13571 main ()
13572 {
13573 ccosf ();
13574   ;
13575   return 0;
13576 }
13577 _ACEOF
13578 rm -f conftest.$ac_objext conftest$ac_exeext
13579 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13580   (eval $ac_link) 2>conftest.er1
13581   ac_status=$?
13582   grep -v '^ *+' conftest.er1 >conftest.err
13583   rm -f conftest.er1
13584   cat conftest.err >&5
13585   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13586   (exit $ac_status); } &&
13587          { ac_try='test -z "$ac_c_werror_flag"
13588                          || test ! -s conftest.err'
13589   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13590   (eval $ac_try) 2>&5
13591   ac_status=$?
13592   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13593   (exit $ac_status); }; } &&
13594          { ac_try='test -s conftest$ac_exeext'
13595   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13596   (eval $ac_try) 2>&5
13597   ac_status=$?
13598   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13599   (exit $ac_status); }; }; then
13600   ac_cv_lib_m_ccosf=yes
13601 else
13602   echo "$as_me: failed program was:" >&5
13603 sed 's/^/| /' conftest.$ac_ext >&5
13604
13605 ac_cv_lib_m_ccosf=no
13606 fi
13607 rm -f conftest.err conftest.$ac_objext \
13608       conftest$ac_exeext conftest.$ac_ext
13609 LIBS=$ac_check_lib_save_LIBS
13610 fi
13611 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosf" >&5
13612 echo "${ECHO_T}$ac_cv_lib_m_ccosf" >&6
13613 if test $ac_cv_lib_m_ccosf = yes; then
13614
13615 cat >>confdefs.h <<\_ACEOF
13616 #define HAVE_CCOSF 1
13617 _ACEOF
13618
13619 fi
13620
13621 echo "$as_me:$LINENO: checking for ccos in -lm" >&5
13622 echo $ECHO_N "checking for ccos in -lm... $ECHO_C" >&6
13623 if test "${ac_cv_lib_m_ccos+set}" = set; then
13624   echo $ECHO_N "(cached) $ECHO_C" >&6
13625 else
13626   ac_check_lib_save_LIBS=$LIBS
13627 LIBS="-lm  $LIBS"
13628 if test x$gcc_no_link = xyes; then
13629   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13630 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13631    { (exit 1); exit 1; }; }
13632 fi
13633 cat >conftest.$ac_ext <<_ACEOF
13634 /* confdefs.h.  */
13635 _ACEOF
13636 cat confdefs.h >>conftest.$ac_ext
13637 cat >>conftest.$ac_ext <<_ACEOF
13638 /* end confdefs.h.  */
13639
13640 /* Override any gcc2 internal prototype to avoid an error.  */
13641 #ifdef __cplusplus
13642 extern "C"
13643 #endif
13644 /* We use char because int might match the return type of a gcc2
13645    builtin and then its argument prototype would still apply.  */
13646 char ccos ();
13647 int
13648 main ()
13649 {
13650 ccos ();
13651   ;
13652   return 0;
13653 }
13654 _ACEOF
13655 rm -f conftest.$ac_objext conftest$ac_exeext
13656 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13657   (eval $ac_link) 2>conftest.er1
13658   ac_status=$?
13659   grep -v '^ *+' conftest.er1 >conftest.err
13660   rm -f conftest.er1
13661   cat conftest.err >&5
13662   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13663   (exit $ac_status); } &&
13664          { ac_try='test -z "$ac_c_werror_flag"
13665                          || test ! -s conftest.err'
13666   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13667   (eval $ac_try) 2>&5
13668   ac_status=$?
13669   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13670   (exit $ac_status); }; } &&
13671          { ac_try='test -s conftest$ac_exeext'
13672   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13673   (eval $ac_try) 2>&5
13674   ac_status=$?
13675   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13676   (exit $ac_status); }; }; then
13677   ac_cv_lib_m_ccos=yes
13678 else
13679   echo "$as_me: failed program was:" >&5
13680 sed 's/^/| /' conftest.$ac_ext >&5
13681
13682 ac_cv_lib_m_ccos=no
13683 fi
13684 rm -f conftest.err conftest.$ac_objext \
13685       conftest$ac_exeext conftest.$ac_ext
13686 LIBS=$ac_check_lib_save_LIBS
13687 fi
13688 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccos" >&5
13689 echo "${ECHO_T}$ac_cv_lib_m_ccos" >&6
13690 if test $ac_cv_lib_m_ccos = yes; then
13691
13692 cat >>confdefs.h <<\_ACEOF
13693 #define HAVE_CCOS 1
13694 _ACEOF
13695
13696 fi
13697
13698 echo "$as_me:$LINENO: checking for ccosl in -lm" >&5
13699 echo $ECHO_N "checking for ccosl in -lm... $ECHO_C" >&6
13700 if test "${ac_cv_lib_m_ccosl+set}" = set; then
13701   echo $ECHO_N "(cached) $ECHO_C" >&6
13702 else
13703   ac_check_lib_save_LIBS=$LIBS
13704 LIBS="-lm  $LIBS"
13705 if test x$gcc_no_link = xyes; then
13706   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13707 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13708    { (exit 1); exit 1; }; }
13709 fi
13710 cat >conftest.$ac_ext <<_ACEOF
13711 /* confdefs.h.  */
13712 _ACEOF
13713 cat confdefs.h >>conftest.$ac_ext
13714 cat >>conftest.$ac_ext <<_ACEOF
13715 /* end confdefs.h.  */
13716
13717 /* Override any gcc2 internal prototype to avoid an error.  */
13718 #ifdef __cplusplus
13719 extern "C"
13720 #endif
13721 /* We use char because int might match the return type of a gcc2
13722    builtin and then its argument prototype would still apply.  */
13723 char ccosl ();
13724 int
13725 main ()
13726 {
13727 ccosl ();
13728   ;
13729   return 0;
13730 }
13731 _ACEOF
13732 rm -f conftest.$ac_objext conftest$ac_exeext
13733 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13734   (eval $ac_link) 2>conftest.er1
13735   ac_status=$?
13736   grep -v '^ *+' conftest.er1 >conftest.err
13737   rm -f conftest.er1
13738   cat conftest.err >&5
13739   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13740   (exit $ac_status); } &&
13741          { ac_try='test -z "$ac_c_werror_flag"
13742                          || test ! -s conftest.err'
13743   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13744   (eval $ac_try) 2>&5
13745   ac_status=$?
13746   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13747   (exit $ac_status); }; } &&
13748          { ac_try='test -s conftest$ac_exeext'
13749   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13750   (eval $ac_try) 2>&5
13751   ac_status=$?
13752   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13753   (exit $ac_status); }; }; then
13754   ac_cv_lib_m_ccosl=yes
13755 else
13756   echo "$as_me: failed program was:" >&5
13757 sed 's/^/| /' conftest.$ac_ext >&5
13758
13759 ac_cv_lib_m_ccosl=no
13760 fi
13761 rm -f conftest.err conftest.$ac_objext \
13762       conftest$ac_exeext conftest.$ac_ext
13763 LIBS=$ac_check_lib_save_LIBS
13764 fi
13765 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosl" >&5
13766 echo "${ECHO_T}$ac_cv_lib_m_ccosl" >&6
13767 if test $ac_cv_lib_m_ccosl = yes; then
13768
13769 cat >>confdefs.h <<\_ACEOF
13770 #define HAVE_CCOSL 1
13771 _ACEOF
13772
13773 fi
13774
13775 echo "$as_me:$LINENO: checking for coshf in -lm" >&5
13776 echo $ECHO_N "checking for coshf in -lm... $ECHO_C" >&6
13777 if test "${ac_cv_lib_m_coshf+set}" = set; then
13778   echo $ECHO_N "(cached) $ECHO_C" >&6
13779 else
13780   ac_check_lib_save_LIBS=$LIBS
13781 LIBS="-lm  $LIBS"
13782 if test x$gcc_no_link = xyes; then
13783   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13784 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13785    { (exit 1); exit 1; }; }
13786 fi
13787 cat >conftest.$ac_ext <<_ACEOF
13788 /* confdefs.h.  */
13789 _ACEOF
13790 cat confdefs.h >>conftest.$ac_ext
13791 cat >>conftest.$ac_ext <<_ACEOF
13792 /* end confdefs.h.  */
13793
13794 /* Override any gcc2 internal prototype to avoid an error.  */
13795 #ifdef __cplusplus
13796 extern "C"
13797 #endif
13798 /* We use char because int might match the return type of a gcc2
13799    builtin and then its argument prototype would still apply.  */
13800 char coshf ();
13801 int
13802 main ()
13803 {
13804 coshf ();
13805   ;
13806   return 0;
13807 }
13808 _ACEOF
13809 rm -f conftest.$ac_objext conftest$ac_exeext
13810 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13811   (eval $ac_link) 2>conftest.er1
13812   ac_status=$?
13813   grep -v '^ *+' conftest.er1 >conftest.err
13814   rm -f conftest.er1
13815   cat conftest.err >&5
13816   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13817   (exit $ac_status); } &&
13818          { ac_try='test -z "$ac_c_werror_flag"
13819                          || test ! -s conftest.err'
13820   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13821   (eval $ac_try) 2>&5
13822   ac_status=$?
13823   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13824   (exit $ac_status); }; } &&
13825          { ac_try='test -s conftest$ac_exeext'
13826   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13827   (eval $ac_try) 2>&5
13828   ac_status=$?
13829   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13830   (exit $ac_status); }; }; then
13831   ac_cv_lib_m_coshf=yes
13832 else
13833   echo "$as_me: failed program was:" >&5
13834 sed 's/^/| /' conftest.$ac_ext >&5
13835
13836 ac_cv_lib_m_coshf=no
13837 fi
13838 rm -f conftest.err conftest.$ac_objext \
13839       conftest$ac_exeext conftest.$ac_ext
13840 LIBS=$ac_check_lib_save_LIBS
13841 fi
13842 echo "$as_me:$LINENO: result: $ac_cv_lib_m_coshf" >&5
13843 echo "${ECHO_T}$ac_cv_lib_m_coshf" >&6
13844 if test $ac_cv_lib_m_coshf = yes; then
13845
13846 cat >>confdefs.h <<\_ACEOF
13847 #define HAVE_COSHF 1
13848 _ACEOF
13849
13850 fi
13851
13852 echo "$as_me:$LINENO: checking for cosh in -lm" >&5
13853 echo $ECHO_N "checking for cosh in -lm... $ECHO_C" >&6
13854 if test "${ac_cv_lib_m_cosh+set}" = set; then
13855   echo $ECHO_N "(cached) $ECHO_C" >&6
13856 else
13857   ac_check_lib_save_LIBS=$LIBS
13858 LIBS="-lm  $LIBS"
13859 if test x$gcc_no_link = xyes; then
13860   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13861 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13862    { (exit 1); exit 1; }; }
13863 fi
13864 cat >conftest.$ac_ext <<_ACEOF
13865 /* confdefs.h.  */
13866 _ACEOF
13867 cat confdefs.h >>conftest.$ac_ext
13868 cat >>conftest.$ac_ext <<_ACEOF
13869 /* end confdefs.h.  */
13870
13871 /* Override any gcc2 internal prototype to avoid an error.  */
13872 #ifdef __cplusplus
13873 extern "C"
13874 #endif
13875 /* We use char because int might match the return type of a gcc2
13876    builtin and then its argument prototype would still apply.  */
13877 char cosh ();
13878 int
13879 main ()
13880 {
13881 cosh ();
13882   ;
13883   return 0;
13884 }
13885 _ACEOF
13886 rm -f conftest.$ac_objext conftest$ac_exeext
13887 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13888   (eval $ac_link) 2>conftest.er1
13889   ac_status=$?
13890   grep -v '^ *+' conftest.er1 >conftest.err
13891   rm -f conftest.er1
13892   cat conftest.err >&5
13893   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13894   (exit $ac_status); } &&
13895          { ac_try='test -z "$ac_c_werror_flag"
13896                          || test ! -s conftest.err'
13897   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13898   (eval $ac_try) 2>&5
13899   ac_status=$?
13900   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13901   (exit $ac_status); }; } &&
13902          { ac_try='test -s conftest$ac_exeext'
13903   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13904   (eval $ac_try) 2>&5
13905   ac_status=$?
13906   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13907   (exit $ac_status); }; }; then
13908   ac_cv_lib_m_cosh=yes
13909 else
13910   echo "$as_me: failed program was:" >&5
13911 sed 's/^/| /' conftest.$ac_ext >&5
13912
13913 ac_cv_lib_m_cosh=no
13914 fi
13915 rm -f conftest.err conftest.$ac_objext \
13916       conftest$ac_exeext conftest.$ac_ext
13917 LIBS=$ac_check_lib_save_LIBS
13918 fi
13919 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosh" >&5
13920 echo "${ECHO_T}$ac_cv_lib_m_cosh" >&6
13921 if test $ac_cv_lib_m_cosh = yes; then
13922
13923 cat >>confdefs.h <<\_ACEOF
13924 #define HAVE_COSH 1
13925 _ACEOF
13926
13927 fi
13928
13929 echo "$as_me:$LINENO: checking for coshl in -lm" >&5
13930 echo $ECHO_N "checking for coshl in -lm... $ECHO_C" >&6
13931 if test "${ac_cv_lib_m_coshl+set}" = set; then
13932   echo $ECHO_N "(cached) $ECHO_C" >&6
13933 else
13934   ac_check_lib_save_LIBS=$LIBS
13935 LIBS="-lm  $LIBS"
13936 if test x$gcc_no_link = xyes; then
13937   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13938 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13939    { (exit 1); exit 1; }; }
13940 fi
13941 cat >conftest.$ac_ext <<_ACEOF
13942 /* confdefs.h.  */
13943 _ACEOF
13944 cat confdefs.h >>conftest.$ac_ext
13945 cat >>conftest.$ac_ext <<_ACEOF
13946 /* end confdefs.h.  */
13947
13948 /* Override any gcc2 internal prototype to avoid an error.  */
13949 #ifdef __cplusplus
13950 extern "C"
13951 #endif
13952 /* We use char because int might match the return type of a gcc2
13953    builtin and then its argument prototype would still apply.  */
13954 char coshl ();
13955 int
13956 main ()
13957 {
13958 coshl ();
13959   ;
13960   return 0;
13961 }
13962 _ACEOF
13963 rm -f conftest.$ac_objext conftest$ac_exeext
13964 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13965   (eval $ac_link) 2>conftest.er1
13966   ac_status=$?
13967   grep -v '^ *+' conftest.er1 >conftest.err
13968   rm -f conftest.er1
13969   cat conftest.err >&5
13970   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13971   (exit $ac_status); } &&
13972          { ac_try='test -z "$ac_c_werror_flag"
13973                          || test ! -s conftest.err'
13974   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13975   (eval $ac_try) 2>&5
13976   ac_status=$?
13977   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13978   (exit $ac_status); }; } &&
13979          { ac_try='test -s conftest$ac_exeext'
13980   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13981   (eval $ac_try) 2>&5
13982   ac_status=$?
13983   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13984   (exit $ac_status); }; }; then
13985   ac_cv_lib_m_coshl=yes
13986 else
13987   echo "$as_me: failed program was:" >&5
13988 sed 's/^/| /' conftest.$ac_ext >&5
13989
13990 ac_cv_lib_m_coshl=no
13991 fi
13992 rm -f conftest.err conftest.$ac_objext \
13993       conftest$ac_exeext conftest.$ac_ext
13994 LIBS=$ac_check_lib_save_LIBS
13995 fi
13996 echo "$as_me:$LINENO: result: $ac_cv_lib_m_coshl" >&5
13997 echo "${ECHO_T}$ac_cv_lib_m_coshl" >&6
13998 if test $ac_cv_lib_m_coshl = yes; then
13999
14000 cat >>confdefs.h <<\_ACEOF
14001 #define HAVE_COSHL 1
14002 _ACEOF
14003
14004 fi
14005
14006 echo "$as_me:$LINENO: checking for ccoshf in -lm" >&5
14007 echo $ECHO_N "checking for ccoshf in -lm... $ECHO_C" >&6
14008 if test "${ac_cv_lib_m_ccoshf+set}" = set; then
14009   echo $ECHO_N "(cached) $ECHO_C" >&6
14010 else
14011   ac_check_lib_save_LIBS=$LIBS
14012 LIBS="-lm  $LIBS"
14013 if test x$gcc_no_link = xyes; then
14014   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14015 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14016    { (exit 1); exit 1; }; }
14017 fi
14018 cat >conftest.$ac_ext <<_ACEOF
14019 /* confdefs.h.  */
14020 _ACEOF
14021 cat confdefs.h >>conftest.$ac_ext
14022 cat >>conftest.$ac_ext <<_ACEOF
14023 /* end confdefs.h.  */
14024
14025 /* Override any gcc2 internal prototype to avoid an error.  */
14026 #ifdef __cplusplus
14027 extern "C"
14028 #endif
14029 /* We use char because int might match the return type of a gcc2
14030    builtin and then its argument prototype would still apply.  */
14031 char ccoshf ();
14032 int
14033 main ()
14034 {
14035 ccoshf ();
14036   ;
14037   return 0;
14038 }
14039 _ACEOF
14040 rm -f conftest.$ac_objext conftest$ac_exeext
14041 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14042   (eval $ac_link) 2>conftest.er1
14043   ac_status=$?
14044   grep -v '^ *+' conftest.er1 >conftest.err
14045   rm -f conftest.er1
14046   cat conftest.err >&5
14047   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14048   (exit $ac_status); } &&
14049          { ac_try='test -z "$ac_c_werror_flag"
14050                          || test ! -s conftest.err'
14051   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14052   (eval $ac_try) 2>&5
14053   ac_status=$?
14054   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14055   (exit $ac_status); }; } &&
14056          { ac_try='test -s conftest$ac_exeext'
14057   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14058   (eval $ac_try) 2>&5
14059   ac_status=$?
14060   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14061   (exit $ac_status); }; }; then
14062   ac_cv_lib_m_ccoshf=yes
14063 else
14064   echo "$as_me: failed program was:" >&5
14065 sed 's/^/| /' conftest.$ac_ext >&5
14066
14067 ac_cv_lib_m_ccoshf=no
14068 fi
14069 rm -f conftest.err conftest.$ac_objext \
14070       conftest$ac_exeext conftest.$ac_ext
14071 LIBS=$ac_check_lib_save_LIBS
14072 fi
14073 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccoshf" >&5
14074 echo "${ECHO_T}$ac_cv_lib_m_ccoshf" >&6
14075 if test $ac_cv_lib_m_ccoshf = yes; then
14076
14077 cat >>confdefs.h <<\_ACEOF
14078 #define HAVE_CCOSHF 1
14079 _ACEOF
14080
14081 fi
14082
14083 echo "$as_me:$LINENO: checking for ccosh in -lm" >&5
14084 echo $ECHO_N "checking for ccosh in -lm... $ECHO_C" >&6
14085 if test "${ac_cv_lib_m_ccosh+set}" = set; then
14086   echo $ECHO_N "(cached) $ECHO_C" >&6
14087 else
14088   ac_check_lib_save_LIBS=$LIBS
14089 LIBS="-lm  $LIBS"
14090 if test x$gcc_no_link = xyes; then
14091   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14092 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14093    { (exit 1); exit 1; }; }
14094 fi
14095 cat >conftest.$ac_ext <<_ACEOF
14096 /* confdefs.h.  */
14097 _ACEOF
14098 cat confdefs.h >>conftest.$ac_ext
14099 cat >>conftest.$ac_ext <<_ACEOF
14100 /* end confdefs.h.  */
14101
14102 /* Override any gcc2 internal prototype to avoid an error.  */
14103 #ifdef __cplusplus
14104 extern "C"
14105 #endif
14106 /* We use char because int might match the return type of a gcc2
14107    builtin and then its argument prototype would still apply.  */
14108 char ccosh ();
14109 int
14110 main ()
14111 {
14112 ccosh ();
14113   ;
14114   return 0;
14115 }
14116 _ACEOF
14117 rm -f conftest.$ac_objext conftest$ac_exeext
14118 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14119   (eval $ac_link) 2>conftest.er1
14120   ac_status=$?
14121   grep -v '^ *+' conftest.er1 >conftest.err
14122   rm -f conftest.er1
14123   cat conftest.err >&5
14124   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14125   (exit $ac_status); } &&
14126          { ac_try='test -z "$ac_c_werror_flag"
14127                          || test ! -s conftest.err'
14128   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14129   (eval $ac_try) 2>&5
14130   ac_status=$?
14131   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14132   (exit $ac_status); }; } &&
14133          { ac_try='test -s conftest$ac_exeext'
14134   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14135   (eval $ac_try) 2>&5
14136   ac_status=$?
14137   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14138   (exit $ac_status); }; }; then
14139   ac_cv_lib_m_ccosh=yes
14140 else
14141   echo "$as_me: failed program was:" >&5
14142 sed 's/^/| /' conftest.$ac_ext >&5
14143
14144 ac_cv_lib_m_ccosh=no
14145 fi
14146 rm -f conftest.err conftest.$ac_objext \
14147       conftest$ac_exeext conftest.$ac_ext
14148 LIBS=$ac_check_lib_save_LIBS
14149 fi
14150 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosh" >&5
14151 echo "${ECHO_T}$ac_cv_lib_m_ccosh" >&6
14152 if test $ac_cv_lib_m_ccosh = yes; then
14153
14154 cat >>confdefs.h <<\_ACEOF
14155 #define HAVE_CCOSH 1
14156 _ACEOF
14157
14158 fi
14159
14160 echo "$as_me:$LINENO: checking for ccoshl in -lm" >&5
14161 echo $ECHO_N "checking for ccoshl in -lm... $ECHO_C" >&6
14162 if test "${ac_cv_lib_m_ccoshl+set}" = set; then
14163   echo $ECHO_N "(cached) $ECHO_C" >&6
14164 else
14165   ac_check_lib_save_LIBS=$LIBS
14166 LIBS="-lm  $LIBS"
14167 if test x$gcc_no_link = xyes; then
14168   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14169 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14170    { (exit 1); exit 1; }; }
14171 fi
14172 cat >conftest.$ac_ext <<_ACEOF
14173 /* confdefs.h.  */
14174 _ACEOF
14175 cat confdefs.h >>conftest.$ac_ext
14176 cat >>conftest.$ac_ext <<_ACEOF
14177 /* end confdefs.h.  */
14178
14179 /* Override any gcc2 internal prototype to avoid an error.  */
14180 #ifdef __cplusplus
14181 extern "C"
14182 #endif
14183 /* We use char because int might match the return type of a gcc2
14184    builtin and then its argument prototype would still apply.  */
14185 char ccoshl ();
14186 int
14187 main ()
14188 {
14189 ccoshl ();
14190   ;
14191   return 0;
14192 }
14193 _ACEOF
14194 rm -f conftest.$ac_objext conftest$ac_exeext
14195 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14196   (eval $ac_link) 2>conftest.er1
14197   ac_status=$?
14198   grep -v '^ *+' conftest.er1 >conftest.err
14199   rm -f conftest.er1
14200   cat conftest.err >&5
14201   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14202   (exit $ac_status); } &&
14203          { ac_try='test -z "$ac_c_werror_flag"
14204                          || test ! -s conftest.err'
14205   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14206   (eval $ac_try) 2>&5
14207   ac_status=$?
14208   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14209   (exit $ac_status); }; } &&
14210          { ac_try='test -s conftest$ac_exeext'
14211   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14212   (eval $ac_try) 2>&5
14213   ac_status=$?
14214   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14215   (exit $ac_status); }; }; then
14216   ac_cv_lib_m_ccoshl=yes
14217 else
14218   echo "$as_me: failed program was:" >&5
14219 sed 's/^/| /' conftest.$ac_ext >&5
14220
14221 ac_cv_lib_m_ccoshl=no
14222 fi
14223 rm -f conftest.err conftest.$ac_objext \
14224       conftest$ac_exeext conftest.$ac_ext
14225 LIBS=$ac_check_lib_save_LIBS
14226 fi
14227 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccoshl" >&5
14228 echo "${ECHO_T}$ac_cv_lib_m_ccoshl" >&6
14229 if test $ac_cv_lib_m_ccoshl = yes; then
14230
14231 cat >>confdefs.h <<\_ACEOF
14232 #define HAVE_CCOSHL 1
14233 _ACEOF
14234
14235 fi
14236
14237 echo "$as_me:$LINENO: checking for expf in -lm" >&5
14238 echo $ECHO_N "checking for expf in -lm... $ECHO_C" >&6
14239 if test "${ac_cv_lib_m_expf+set}" = set; then
14240   echo $ECHO_N "(cached) $ECHO_C" >&6
14241 else
14242   ac_check_lib_save_LIBS=$LIBS
14243 LIBS="-lm  $LIBS"
14244 if test x$gcc_no_link = xyes; then
14245   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14246 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14247    { (exit 1); exit 1; }; }
14248 fi
14249 cat >conftest.$ac_ext <<_ACEOF
14250 /* confdefs.h.  */
14251 _ACEOF
14252 cat confdefs.h >>conftest.$ac_ext
14253 cat >>conftest.$ac_ext <<_ACEOF
14254 /* end confdefs.h.  */
14255
14256 /* Override any gcc2 internal prototype to avoid an error.  */
14257 #ifdef __cplusplus
14258 extern "C"
14259 #endif
14260 /* We use char because int might match the return type of a gcc2
14261    builtin and then its argument prototype would still apply.  */
14262 char expf ();
14263 int
14264 main ()
14265 {
14266 expf ();
14267   ;
14268   return 0;
14269 }
14270 _ACEOF
14271 rm -f conftest.$ac_objext conftest$ac_exeext
14272 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14273   (eval $ac_link) 2>conftest.er1
14274   ac_status=$?
14275   grep -v '^ *+' conftest.er1 >conftest.err
14276   rm -f conftest.er1
14277   cat conftest.err >&5
14278   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14279   (exit $ac_status); } &&
14280          { ac_try='test -z "$ac_c_werror_flag"
14281                          || test ! -s conftest.err'
14282   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14283   (eval $ac_try) 2>&5
14284   ac_status=$?
14285   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14286   (exit $ac_status); }; } &&
14287          { ac_try='test -s conftest$ac_exeext'
14288   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14289   (eval $ac_try) 2>&5
14290   ac_status=$?
14291   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14292   (exit $ac_status); }; }; then
14293   ac_cv_lib_m_expf=yes
14294 else
14295   echo "$as_me: failed program was:" >&5
14296 sed 's/^/| /' conftest.$ac_ext >&5
14297
14298 ac_cv_lib_m_expf=no
14299 fi
14300 rm -f conftest.err conftest.$ac_objext \
14301       conftest$ac_exeext conftest.$ac_ext
14302 LIBS=$ac_check_lib_save_LIBS
14303 fi
14304 echo "$as_me:$LINENO: result: $ac_cv_lib_m_expf" >&5
14305 echo "${ECHO_T}$ac_cv_lib_m_expf" >&6
14306 if test $ac_cv_lib_m_expf = yes; then
14307
14308 cat >>confdefs.h <<\_ACEOF
14309 #define HAVE_EXPF 1
14310 _ACEOF
14311
14312 fi
14313
14314 echo "$as_me:$LINENO: checking for exp in -lm" >&5
14315 echo $ECHO_N "checking for exp in -lm... $ECHO_C" >&6
14316 if test "${ac_cv_lib_m_exp+set}" = set; then
14317   echo $ECHO_N "(cached) $ECHO_C" >&6
14318 else
14319   ac_check_lib_save_LIBS=$LIBS
14320 LIBS="-lm  $LIBS"
14321 if test x$gcc_no_link = xyes; then
14322   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14323 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14324    { (exit 1); exit 1; }; }
14325 fi
14326 cat >conftest.$ac_ext <<_ACEOF
14327 /* confdefs.h.  */
14328 _ACEOF
14329 cat confdefs.h >>conftest.$ac_ext
14330 cat >>conftest.$ac_ext <<_ACEOF
14331 /* end confdefs.h.  */
14332
14333 /* Override any gcc2 internal prototype to avoid an error.  */
14334 #ifdef __cplusplus
14335 extern "C"
14336 #endif
14337 /* We use char because int might match the return type of a gcc2
14338    builtin and then its argument prototype would still apply.  */
14339 char exp ();
14340 int
14341 main ()
14342 {
14343 exp ();
14344   ;
14345   return 0;
14346 }
14347 _ACEOF
14348 rm -f conftest.$ac_objext conftest$ac_exeext
14349 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14350   (eval $ac_link) 2>conftest.er1
14351   ac_status=$?
14352   grep -v '^ *+' conftest.er1 >conftest.err
14353   rm -f conftest.er1
14354   cat conftest.err >&5
14355   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14356   (exit $ac_status); } &&
14357          { ac_try='test -z "$ac_c_werror_flag"
14358                          || test ! -s conftest.err'
14359   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14360   (eval $ac_try) 2>&5
14361   ac_status=$?
14362   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14363   (exit $ac_status); }; } &&
14364          { ac_try='test -s conftest$ac_exeext'
14365   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14366   (eval $ac_try) 2>&5
14367   ac_status=$?
14368   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14369   (exit $ac_status); }; }; then
14370   ac_cv_lib_m_exp=yes
14371 else
14372   echo "$as_me: failed program was:" >&5
14373 sed 's/^/| /' conftest.$ac_ext >&5
14374
14375 ac_cv_lib_m_exp=no
14376 fi
14377 rm -f conftest.err conftest.$ac_objext \
14378       conftest$ac_exeext conftest.$ac_ext
14379 LIBS=$ac_check_lib_save_LIBS
14380 fi
14381 echo "$as_me:$LINENO: result: $ac_cv_lib_m_exp" >&5
14382 echo "${ECHO_T}$ac_cv_lib_m_exp" >&6
14383 if test $ac_cv_lib_m_exp = yes; then
14384
14385 cat >>confdefs.h <<\_ACEOF
14386 #define HAVE_EXP 1
14387 _ACEOF
14388
14389 fi
14390
14391 echo "$as_me:$LINENO: checking for expl in -lm" >&5
14392 echo $ECHO_N "checking for expl in -lm... $ECHO_C" >&6
14393 if test "${ac_cv_lib_m_expl+set}" = set; then
14394   echo $ECHO_N "(cached) $ECHO_C" >&6
14395 else
14396   ac_check_lib_save_LIBS=$LIBS
14397 LIBS="-lm  $LIBS"
14398 if test x$gcc_no_link = xyes; then
14399   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14400 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14401    { (exit 1); exit 1; }; }
14402 fi
14403 cat >conftest.$ac_ext <<_ACEOF
14404 /* confdefs.h.  */
14405 _ACEOF
14406 cat confdefs.h >>conftest.$ac_ext
14407 cat >>conftest.$ac_ext <<_ACEOF
14408 /* end confdefs.h.  */
14409
14410 /* Override any gcc2 internal prototype to avoid an error.  */
14411 #ifdef __cplusplus
14412 extern "C"
14413 #endif
14414 /* We use char because int might match the return type of a gcc2
14415    builtin and then its argument prototype would still apply.  */
14416 char expl ();
14417 int
14418 main ()
14419 {
14420 expl ();
14421   ;
14422   return 0;
14423 }
14424 _ACEOF
14425 rm -f conftest.$ac_objext conftest$ac_exeext
14426 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14427   (eval $ac_link) 2>conftest.er1
14428   ac_status=$?
14429   grep -v '^ *+' conftest.er1 >conftest.err
14430   rm -f conftest.er1
14431   cat conftest.err >&5
14432   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14433   (exit $ac_status); } &&
14434          { ac_try='test -z "$ac_c_werror_flag"
14435                          || test ! -s conftest.err'
14436   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14437   (eval $ac_try) 2>&5
14438   ac_status=$?
14439   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14440   (exit $ac_status); }; } &&
14441          { ac_try='test -s conftest$ac_exeext'
14442   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14443   (eval $ac_try) 2>&5
14444   ac_status=$?
14445   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14446   (exit $ac_status); }; }; then
14447   ac_cv_lib_m_expl=yes
14448 else
14449   echo "$as_me: failed program was:" >&5
14450 sed 's/^/| /' conftest.$ac_ext >&5
14451
14452 ac_cv_lib_m_expl=no
14453 fi
14454 rm -f conftest.err conftest.$ac_objext \
14455       conftest$ac_exeext conftest.$ac_ext
14456 LIBS=$ac_check_lib_save_LIBS
14457 fi
14458 echo "$as_me:$LINENO: result: $ac_cv_lib_m_expl" >&5
14459 echo "${ECHO_T}$ac_cv_lib_m_expl" >&6
14460 if test $ac_cv_lib_m_expl = yes; then
14461
14462 cat >>confdefs.h <<\_ACEOF
14463 #define HAVE_EXPL 1
14464 _ACEOF
14465
14466 fi
14467
14468 echo "$as_me:$LINENO: checking for cexpf in -lm" >&5
14469 echo $ECHO_N "checking for cexpf in -lm... $ECHO_C" >&6
14470 if test "${ac_cv_lib_m_cexpf+set}" = set; then
14471   echo $ECHO_N "(cached) $ECHO_C" >&6
14472 else
14473   ac_check_lib_save_LIBS=$LIBS
14474 LIBS="-lm  $LIBS"
14475 if test x$gcc_no_link = xyes; then
14476   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14477 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14478    { (exit 1); exit 1; }; }
14479 fi
14480 cat >conftest.$ac_ext <<_ACEOF
14481 /* confdefs.h.  */
14482 _ACEOF
14483 cat confdefs.h >>conftest.$ac_ext
14484 cat >>conftest.$ac_ext <<_ACEOF
14485 /* end confdefs.h.  */
14486
14487 /* Override any gcc2 internal prototype to avoid an error.  */
14488 #ifdef __cplusplus
14489 extern "C"
14490 #endif
14491 /* We use char because int might match the return type of a gcc2
14492    builtin and then its argument prototype would still apply.  */
14493 char cexpf ();
14494 int
14495 main ()
14496 {
14497 cexpf ();
14498   ;
14499   return 0;
14500 }
14501 _ACEOF
14502 rm -f conftest.$ac_objext conftest$ac_exeext
14503 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14504   (eval $ac_link) 2>conftest.er1
14505   ac_status=$?
14506   grep -v '^ *+' conftest.er1 >conftest.err
14507   rm -f conftest.er1
14508   cat conftest.err >&5
14509   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14510   (exit $ac_status); } &&
14511          { ac_try='test -z "$ac_c_werror_flag"
14512                          || test ! -s conftest.err'
14513   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14514   (eval $ac_try) 2>&5
14515   ac_status=$?
14516   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14517   (exit $ac_status); }; } &&
14518          { ac_try='test -s conftest$ac_exeext'
14519   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14520   (eval $ac_try) 2>&5
14521   ac_status=$?
14522   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14523   (exit $ac_status); }; }; then
14524   ac_cv_lib_m_cexpf=yes
14525 else
14526   echo "$as_me: failed program was:" >&5
14527 sed 's/^/| /' conftest.$ac_ext >&5
14528
14529 ac_cv_lib_m_cexpf=no
14530 fi
14531 rm -f conftest.err conftest.$ac_objext \
14532       conftest$ac_exeext conftest.$ac_ext
14533 LIBS=$ac_check_lib_save_LIBS
14534 fi
14535 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexpf" >&5
14536 echo "${ECHO_T}$ac_cv_lib_m_cexpf" >&6
14537 if test $ac_cv_lib_m_cexpf = yes; then
14538
14539 cat >>confdefs.h <<\_ACEOF
14540 #define HAVE_CEXPF 1
14541 _ACEOF
14542
14543 fi
14544
14545 echo "$as_me:$LINENO: checking for cexp in -lm" >&5
14546 echo $ECHO_N "checking for cexp in -lm... $ECHO_C" >&6
14547 if test "${ac_cv_lib_m_cexp+set}" = set; then
14548   echo $ECHO_N "(cached) $ECHO_C" >&6
14549 else
14550   ac_check_lib_save_LIBS=$LIBS
14551 LIBS="-lm  $LIBS"
14552 if test x$gcc_no_link = xyes; then
14553   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14554 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14555    { (exit 1); exit 1; }; }
14556 fi
14557 cat >conftest.$ac_ext <<_ACEOF
14558 /* confdefs.h.  */
14559 _ACEOF
14560 cat confdefs.h >>conftest.$ac_ext
14561 cat >>conftest.$ac_ext <<_ACEOF
14562 /* end confdefs.h.  */
14563
14564 /* Override any gcc2 internal prototype to avoid an error.  */
14565 #ifdef __cplusplus
14566 extern "C"
14567 #endif
14568 /* We use char because int might match the return type of a gcc2
14569    builtin and then its argument prototype would still apply.  */
14570 char cexp ();
14571 int
14572 main ()
14573 {
14574 cexp ();
14575   ;
14576   return 0;
14577 }
14578 _ACEOF
14579 rm -f conftest.$ac_objext conftest$ac_exeext
14580 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14581   (eval $ac_link) 2>conftest.er1
14582   ac_status=$?
14583   grep -v '^ *+' conftest.er1 >conftest.err
14584   rm -f conftest.er1
14585   cat conftest.err >&5
14586   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14587   (exit $ac_status); } &&
14588          { ac_try='test -z "$ac_c_werror_flag"
14589                          || test ! -s conftest.err'
14590   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14591   (eval $ac_try) 2>&5
14592   ac_status=$?
14593   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14594   (exit $ac_status); }; } &&
14595          { ac_try='test -s conftest$ac_exeext'
14596   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14597   (eval $ac_try) 2>&5
14598   ac_status=$?
14599   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14600   (exit $ac_status); }; }; then
14601   ac_cv_lib_m_cexp=yes
14602 else
14603   echo "$as_me: failed program was:" >&5
14604 sed 's/^/| /' conftest.$ac_ext >&5
14605
14606 ac_cv_lib_m_cexp=no
14607 fi
14608 rm -f conftest.err conftest.$ac_objext \
14609       conftest$ac_exeext conftest.$ac_ext
14610 LIBS=$ac_check_lib_save_LIBS
14611 fi
14612 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexp" >&5
14613 echo "${ECHO_T}$ac_cv_lib_m_cexp" >&6
14614 if test $ac_cv_lib_m_cexp = yes; then
14615
14616 cat >>confdefs.h <<\_ACEOF
14617 #define HAVE_CEXP 1
14618 _ACEOF
14619
14620 fi
14621
14622 echo "$as_me:$LINENO: checking for cexpl in -lm" >&5
14623 echo $ECHO_N "checking for cexpl in -lm... $ECHO_C" >&6
14624 if test "${ac_cv_lib_m_cexpl+set}" = set; then
14625   echo $ECHO_N "(cached) $ECHO_C" >&6
14626 else
14627   ac_check_lib_save_LIBS=$LIBS
14628 LIBS="-lm  $LIBS"
14629 if test x$gcc_no_link = xyes; then
14630   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14631 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14632    { (exit 1); exit 1; }; }
14633 fi
14634 cat >conftest.$ac_ext <<_ACEOF
14635 /* confdefs.h.  */
14636 _ACEOF
14637 cat confdefs.h >>conftest.$ac_ext
14638 cat >>conftest.$ac_ext <<_ACEOF
14639 /* end confdefs.h.  */
14640
14641 /* Override any gcc2 internal prototype to avoid an error.  */
14642 #ifdef __cplusplus
14643 extern "C"
14644 #endif
14645 /* We use char because int might match the return type of a gcc2
14646    builtin and then its argument prototype would still apply.  */
14647 char cexpl ();
14648 int
14649 main ()
14650 {
14651 cexpl ();
14652   ;
14653   return 0;
14654 }
14655 _ACEOF
14656 rm -f conftest.$ac_objext conftest$ac_exeext
14657 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14658   (eval $ac_link) 2>conftest.er1
14659   ac_status=$?
14660   grep -v '^ *+' conftest.er1 >conftest.err
14661   rm -f conftest.er1
14662   cat conftest.err >&5
14663   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14664   (exit $ac_status); } &&
14665          { ac_try='test -z "$ac_c_werror_flag"
14666                          || test ! -s conftest.err'
14667   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14668   (eval $ac_try) 2>&5
14669   ac_status=$?
14670   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14671   (exit $ac_status); }; } &&
14672          { ac_try='test -s conftest$ac_exeext'
14673   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14674   (eval $ac_try) 2>&5
14675   ac_status=$?
14676   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14677   (exit $ac_status); }; }; then
14678   ac_cv_lib_m_cexpl=yes
14679 else
14680   echo "$as_me: failed program was:" >&5
14681 sed 's/^/| /' conftest.$ac_ext >&5
14682
14683 ac_cv_lib_m_cexpl=no
14684 fi
14685 rm -f conftest.err conftest.$ac_objext \
14686       conftest$ac_exeext conftest.$ac_ext
14687 LIBS=$ac_check_lib_save_LIBS
14688 fi
14689 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexpl" >&5
14690 echo "${ECHO_T}$ac_cv_lib_m_cexpl" >&6
14691 if test $ac_cv_lib_m_cexpl = yes; then
14692
14693 cat >>confdefs.h <<\_ACEOF
14694 #define HAVE_CEXPL 1
14695 _ACEOF
14696
14697 fi
14698
14699 echo "$as_me:$LINENO: checking for fabsf in -lm" >&5
14700 echo $ECHO_N "checking for fabsf in -lm... $ECHO_C" >&6
14701 if test "${ac_cv_lib_m_fabsf+set}" = set; then
14702   echo $ECHO_N "(cached) $ECHO_C" >&6
14703 else
14704   ac_check_lib_save_LIBS=$LIBS
14705 LIBS="-lm  $LIBS"
14706 if test x$gcc_no_link = xyes; then
14707   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14708 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14709    { (exit 1); exit 1; }; }
14710 fi
14711 cat >conftest.$ac_ext <<_ACEOF
14712 /* confdefs.h.  */
14713 _ACEOF
14714 cat confdefs.h >>conftest.$ac_ext
14715 cat >>conftest.$ac_ext <<_ACEOF
14716 /* end confdefs.h.  */
14717
14718 /* Override any gcc2 internal prototype to avoid an error.  */
14719 #ifdef __cplusplus
14720 extern "C"
14721 #endif
14722 /* We use char because int might match the return type of a gcc2
14723    builtin and then its argument prototype would still apply.  */
14724 char fabsf ();
14725 int
14726 main ()
14727 {
14728 fabsf ();
14729   ;
14730   return 0;
14731 }
14732 _ACEOF
14733 rm -f conftest.$ac_objext conftest$ac_exeext
14734 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14735   (eval $ac_link) 2>conftest.er1
14736   ac_status=$?
14737   grep -v '^ *+' conftest.er1 >conftest.err
14738   rm -f conftest.er1
14739   cat conftest.err >&5
14740   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14741   (exit $ac_status); } &&
14742          { ac_try='test -z "$ac_c_werror_flag"
14743                          || test ! -s conftest.err'
14744   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14745   (eval $ac_try) 2>&5
14746   ac_status=$?
14747   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14748   (exit $ac_status); }; } &&
14749          { ac_try='test -s conftest$ac_exeext'
14750   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14751   (eval $ac_try) 2>&5
14752   ac_status=$?
14753   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14754   (exit $ac_status); }; }; then
14755   ac_cv_lib_m_fabsf=yes
14756 else
14757   echo "$as_me: failed program was:" >&5
14758 sed 's/^/| /' conftest.$ac_ext >&5
14759
14760 ac_cv_lib_m_fabsf=no
14761 fi
14762 rm -f conftest.err conftest.$ac_objext \
14763       conftest$ac_exeext conftest.$ac_ext
14764 LIBS=$ac_check_lib_save_LIBS
14765 fi
14766 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabsf" >&5
14767 echo "${ECHO_T}$ac_cv_lib_m_fabsf" >&6
14768 if test $ac_cv_lib_m_fabsf = yes; then
14769
14770 cat >>confdefs.h <<\_ACEOF
14771 #define HAVE_FABSF 1
14772 _ACEOF
14773
14774 fi
14775
14776 echo "$as_me:$LINENO: checking for fabs in -lm" >&5
14777 echo $ECHO_N "checking for fabs in -lm... $ECHO_C" >&6
14778 if test "${ac_cv_lib_m_fabs+set}" = set; then
14779   echo $ECHO_N "(cached) $ECHO_C" >&6
14780 else
14781   ac_check_lib_save_LIBS=$LIBS
14782 LIBS="-lm  $LIBS"
14783 if test x$gcc_no_link = xyes; then
14784   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14785 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14786    { (exit 1); exit 1; }; }
14787 fi
14788 cat >conftest.$ac_ext <<_ACEOF
14789 /* confdefs.h.  */
14790 _ACEOF
14791 cat confdefs.h >>conftest.$ac_ext
14792 cat >>conftest.$ac_ext <<_ACEOF
14793 /* end confdefs.h.  */
14794
14795 /* Override any gcc2 internal prototype to avoid an error.  */
14796 #ifdef __cplusplus
14797 extern "C"
14798 #endif
14799 /* We use char because int might match the return type of a gcc2
14800    builtin and then its argument prototype would still apply.  */
14801 char fabs ();
14802 int
14803 main ()
14804 {
14805 fabs ();
14806   ;
14807   return 0;
14808 }
14809 _ACEOF
14810 rm -f conftest.$ac_objext conftest$ac_exeext
14811 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14812   (eval $ac_link) 2>conftest.er1
14813   ac_status=$?
14814   grep -v '^ *+' conftest.er1 >conftest.err
14815   rm -f conftest.er1
14816   cat conftest.err >&5
14817   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14818   (exit $ac_status); } &&
14819          { ac_try='test -z "$ac_c_werror_flag"
14820                          || test ! -s conftest.err'
14821   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14822   (eval $ac_try) 2>&5
14823   ac_status=$?
14824   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14825   (exit $ac_status); }; } &&
14826          { ac_try='test -s conftest$ac_exeext'
14827   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14828   (eval $ac_try) 2>&5
14829   ac_status=$?
14830   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14831   (exit $ac_status); }; }; then
14832   ac_cv_lib_m_fabs=yes
14833 else
14834   echo "$as_me: failed program was:" >&5
14835 sed 's/^/| /' conftest.$ac_ext >&5
14836
14837 ac_cv_lib_m_fabs=no
14838 fi
14839 rm -f conftest.err conftest.$ac_objext \
14840       conftest$ac_exeext conftest.$ac_ext
14841 LIBS=$ac_check_lib_save_LIBS
14842 fi
14843 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabs" >&5
14844 echo "${ECHO_T}$ac_cv_lib_m_fabs" >&6
14845 if test $ac_cv_lib_m_fabs = yes; then
14846
14847 cat >>confdefs.h <<\_ACEOF
14848 #define HAVE_FABS 1
14849 _ACEOF
14850
14851 fi
14852
14853 echo "$as_me:$LINENO: checking for fabsl in -lm" >&5
14854 echo $ECHO_N "checking for fabsl in -lm... $ECHO_C" >&6
14855 if test "${ac_cv_lib_m_fabsl+set}" = set; then
14856   echo $ECHO_N "(cached) $ECHO_C" >&6
14857 else
14858   ac_check_lib_save_LIBS=$LIBS
14859 LIBS="-lm  $LIBS"
14860 if test x$gcc_no_link = xyes; then
14861   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14862 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14863    { (exit 1); exit 1; }; }
14864 fi
14865 cat >conftest.$ac_ext <<_ACEOF
14866 /* confdefs.h.  */
14867 _ACEOF
14868 cat confdefs.h >>conftest.$ac_ext
14869 cat >>conftest.$ac_ext <<_ACEOF
14870 /* end confdefs.h.  */
14871
14872 /* Override any gcc2 internal prototype to avoid an error.  */
14873 #ifdef __cplusplus
14874 extern "C"
14875 #endif
14876 /* We use char because int might match the return type of a gcc2
14877    builtin and then its argument prototype would still apply.  */
14878 char fabsl ();
14879 int
14880 main ()
14881 {
14882 fabsl ();
14883   ;
14884   return 0;
14885 }
14886 _ACEOF
14887 rm -f conftest.$ac_objext conftest$ac_exeext
14888 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14889   (eval $ac_link) 2>conftest.er1
14890   ac_status=$?
14891   grep -v '^ *+' conftest.er1 >conftest.err
14892   rm -f conftest.er1
14893   cat conftest.err >&5
14894   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14895   (exit $ac_status); } &&
14896          { ac_try='test -z "$ac_c_werror_flag"
14897                          || test ! -s conftest.err'
14898   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14899   (eval $ac_try) 2>&5
14900   ac_status=$?
14901   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14902   (exit $ac_status); }; } &&
14903          { ac_try='test -s conftest$ac_exeext'
14904   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14905   (eval $ac_try) 2>&5
14906   ac_status=$?
14907   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14908   (exit $ac_status); }; }; then
14909   ac_cv_lib_m_fabsl=yes
14910 else
14911   echo "$as_me: failed program was:" >&5
14912 sed 's/^/| /' conftest.$ac_ext >&5
14913
14914 ac_cv_lib_m_fabsl=no
14915 fi
14916 rm -f conftest.err conftest.$ac_objext \
14917       conftest$ac_exeext conftest.$ac_ext
14918 LIBS=$ac_check_lib_save_LIBS
14919 fi
14920 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabsl" >&5
14921 echo "${ECHO_T}$ac_cv_lib_m_fabsl" >&6
14922 if test $ac_cv_lib_m_fabsl = yes; then
14923
14924 cat >>confdefs.h <<\_ACEOF
14925 #define HAVE_FABSL 1
14926 _ACEOF
14927
14928 fi
14929
14930 echo "$as_me:$LINENO: checking for cabsf in -lm" >&5
14931 echo $ECHO_N "checking for cabsf in -lm... $ECHO_C" >&6
14932 if test "${ac_cv_lib_m_cabsf+set}" = set; then
14933   echo $ECHO_N "(cached) $ECHO_C" >&6
14934 else
14935   ac_check_lib_save_LIBS=$LIBS
14936 LIBS="-lm  $LIBS"
14937 if test x$gcc_no_link = xyes; then
14938   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14939 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14940    { (exit 1); exit 1; }; }
14941 fi
14942 cat >conftest.$ac_ext <<_ACEOF
14943 /* confdefs.h.  */
14944 _ACEOF
14945 cat confdefs.h >>conftest.$ac_ext
14946 cat >>conftest.$ac_ext <<_ACEOF
14947 /* end confdefs.h.  */
14948
14949 /* Override any gcc2 internal prototype to avoid an error.  */
14950 #ifdef __cplusplus
14951 extern "C"
14952 #endif
14953 /* We use char because int might match the return type of a gcc2
14954    builtin and then its argument prototype would still apply.  */
14955 char cabsf ();
14956 int
14957 main ()
14958 {
14959 cabsf ();
14960   ;
14961   return 0;
14962 }
14963 _ACEOF
14964 rm -f conftest.$ac_objext conftest$ac_exeext
14965 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14966   (eval $ac_link) 2>conftest.er1
14967   ac_status=$?
14968   grep -v '^ *+' conftest.er1 >conftest.err
14969   rm -f conftest.er1
14970   cat conftest.err >&5
14971   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14972   (exit $ac_status); } &&
14973          { ac_try='test -z "$ac_c_werror_flag"
14974                          || test ! -s conftest.err'
14975   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14976   (eval $ac_try) 2>&5
14977   ac_status=$?
14978   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14979   (exit $ac_status); }; } &&
14980          { ac_try='test -s conftest$ac_exeext'
14981   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14982   (eval $ac_try) 2>&5
14983   ac_status=$?
14984   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14985   (exit $ac_status); }; }; then
14986   ac_cv_lib_m_cabsf=yes
14987 else
14988   echo "$as_me: failed program was:" >&5
14989 sed 's/^/| /' conftest.$ac_ext >&5
14990
14991 ac_cv_lib_m_cabsf=no
14992 fi
14993 rm -f conftest.err conftest.$ac_objext \
14994       conftest$ac_exeext conftest.$ac_ext
14995 LIBS=$ac_check_lib_save_LIBS
14996 fi
14997 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabsf" >&5
14998 echo "${ECHO_T}$ac_cv_lib_m_cabsf" >&6
14999 if test $ac_cv_lib_m_cabsf = yes; then
15000
15001 cat >>confdefs.h <<\_ACEOF
15002 #define HAVE_CABSF 1
15003 _ACEOF
15004
15005 fi
15006
15007 echo "$as_me:$LINENO: checking for cabs in -lm" >&5
15008 echo $ECHO_N "checking for cabs in -lm... $ECHO_C" >&6
15009 if test "${ac_cv_lib_m_cabs+set}" = set; then
15010   echo $ECHO_N "(cached) $ECHO_C" >&6
15011 else
15012   ac_check_lib_save_LIBS=$LIBS
15013 LIBS="-lm  $LIBS"
15014 if test x$gcc_no_link = xyes; then
15015   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15016 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15017    { (exit 1); exit 1; }; }
15018 fi
15019 cat >conftest.$ac_ext <<_ACEOF
15020 /* confdefs.h.  */
15021 _ACEOF
15022 cat confdefs.h >>conftest.$ac_ext
15023 cat >>conftest.$ac_ext <<_ACEOF
15024 /* end confdefs.h.  */
15025
15026 /* Override any gcc2 internal prototype to avoid an error.  */
15027 #ifdef __cplusplus
15028 extern "C"
15029 #endif
15030 /* We use char because int might match the return type of a gcc2
15031    builtin and then its argument prototype would still apply.  */
15032 char cabs ();
15033 int
15034 main ()
15035 {
15036 cabs ();
15037   ;
15038   return 0;
15039 }
15040 _ACEOF
15041 rm -f conftest.$ac_objext conftest$ac_exeext
15042 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15043   (eval $ac_link) 2>conftest.er1
15044   ac_status=$?
15045   grep -v '^ *+' conftest.er1 >conftest.err
15046   rm -f conftest.er1
15047   cat conftest.err >&5
15048   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15049   (exit $ac_status); } &&
15050          { ac_try='test -z "$ac_c_werror_flag"
15051                          || test ! -s conftest.err'
15052   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15053   (eval $ac_try) 2>&5
15054   ac_status=$?
15055   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15056   (exit $ac_status); }; } &&
15057          { ac_try='test -s conftest$ac_exeext'
15058   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15059   (eval $ac_try) 2>&5
15060   ac_status=$?
15061   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15062   (exit $ac_status); }; }; then
15063   ac_cv_lib_m_cabs=yes
15064 else
15065   echo "$as_me: failed program was:" >&5
15066 sed 's/^/| /' conftest.$ac_ext >&5
15067
15068 ac_cv_lib_m_cabs=no
15069 fi
15070 rm -f conftest.err conftest.$ac_objext \
15071       conftest$ac_exeext conftest.$ac_ext
15072 LIBS=$ac_check_lib_save_LIBS
15073 fi
15074 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabs" >&5
15075 echo "${ECHO_T}$ac_cv_lib_m_cabs" >&6
15076 if test $ac_cv_lib_m_cabs = yes; then
15077
15078 cat >>confdefs.h <<\_ACEOF
15079 #define HAVE_CABS 1
15080 _ACEOF
15081
15082 fi
15083
15084 echo "$as_me:$LINENO: checking for cabsl in -lm" >&5
15085 echo $ECHO_N "checking for cabsl in -lm... $ECHO_C" >&6
15086 if test "${ac_cv_lib_m_cabsl+set}" = set; then
15087   echo $ECHO_N "(cached) $ECHO_C" >&6
15088 else
15089   ac_check_lib_save_LIBS=$LIBS
15090 LIBS="-lm  $LIBS"
15091 if test x$gcc_no_link = xyes; then
15092   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15093 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15094    { (exit 1); exit 1; }; }
15095 fi
15096 cat >conftest.$ac_ext <<_ACEOF
15097 /* confdefs.h.  */
15098 _ACEOF
15099 cat confdefs.h >>conftest.$ac_ext
15100 cat >>conftest.$ac_ext <<_ACEOF
15101 /* end confdefs.h.  */
15102
15103 /* Override any gcc2 internal prototype to avoid an error.  */
15104 #ifdef __cplusplus
15105 extern "C"
15106 #endif
15107 /* We use char because int might match the return type of a gcc2
15108    builtin and then its argument prototype would still apply.  */
15109 char cabsl ();
15110 int
15111 main ()
15112 {
15113 cabsl ();
15114   ;
15115   return 0;
15116 }
15117 _ACEOF
15118 rm -f conftest.$ac_objext conftest$ac_exeext
15119 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15120   (eval $ac_link) 2>conftest.er1
15121   ac_status=$?
15122   grep -v '^ *+' conftest.er1 >conftest.err
15123   rm -f conftest.er1
15124   cat conftest.err >&5
15125   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15126   (exit $ac_status); } &&
15127          { ac_try='test -z "$ac_c_werror_flag"
15128                          || test ! -s conftest.err'
15129   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15130   (eval $ac_try) 2>&5
15131   ac_status=$?
15132   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15133   (exit $ac_status); }; } &&
15134          { ac_try='test -s conftest$ac_exeext'
15135   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15136   (eval $ac_try) 2>&5
15137   ac_status=$?
15138   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15139   (exit $ac_status); }; }; then
15140   ac_cv_lib_m_cabsl=yes
15141 else
15142   echo "$as_me: failed program was:" >&5
15143 sed 's/^/| /' conftest.$ac_ext >&5
15144
15145 ac_cv_lib_m_cabsl=no
15146 fi
15147 rm -f conftest.err conftest.$ac_objext \
15148       conftest$ac_exeext conftest.$ac_ext
15149 LIBS=$ac_check_lib_save_LIBS
15150 fi
15151 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabsl" >&5
15152 echo "${ECHO_T}$ac_cv_lib_m_cabsl" >&6
15153 if test $ac_cv_lib_m_cabsl = yes; then
15154
15155 cat >>confdefs.h <<\_ACEOF
15156 #define HAVE_CABSL 1
15157 _ACEOF
15158
15159 fi
15160
15161 echo "$as_me:$LINENO: checking for floorf in -lm" >&5
15162 echo $ECHO_N "checking for floorf in -lm... $ECHO_C" >&6
15163 if test "${ac_cv_lib_m_floorf+set}" = set; then
15164   echo $ECHO_N "(cached) $ECHO_C" >&6
15165 else
15166   ac_check_lib_save_LIBS=$LIBS
15167 LIBS="-lm  $LIBS"
15168 if test x$gcc_no_link = xyes; then
15169   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15170 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15171    { (exit 1); exit 1; }; }
15172 fi
15173 cat >conftest.$ac_ext <<_ACEOF
15174 /* confdefs.h.  */
15175 _ACEOF
15176 cat confdefs.h >>conftest.$ac_ext
15177 cat >>conftest.$ac_ext <<_ACEOF
15178 /* end confdefs.h.  */
15179
15180 /* Override any gcc2 internal prototype to avoid an error.  */
15181 #ifdef __cplusplus
15182 extern "C"
15183 #endif
15184 /* We use char because int might match the return type of a gcc2
15185    builtin and then its argument prototype would still apply.  */
15186 char floorf ();
15187 int
15188 main ()
15189 {
15190 floorf ();
15191   ;
15192   return 0;
15193 }
15194 _ACEOF
15195 rm -f conftest.$ac_objext conftest$ac_exeext
15196 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15197   (eval $ac_link) 2>conftest.er1
15198   ac_status=$?
15199   grep -v '^ *+' conftest.er1 >conftest.err
15200   rm -f conftest.er1
15201   cat conftest.err >&5
15202   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15203   (exit $ac_status); } &&
15204          { ac_try='test -z "$ac_c_werror_flag"
15205                          || test ! -s conftest.err'
15206   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15207   (eval $ac_try) 2>&5
15208   ac_status=$?
15209   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15210   (exit $ac_status); }; } &&
15211          { ac_try='test -s conftest$ac_exeext'
15212   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15213   (eval $ac_try) 2>&5
15214   ac_status=$?
15215   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15216   (exit $ac_status); }; }; then
15217   ac_cv_lib_m_floorf=yes
15218 else
15219   echo "$as_me: failed program was:" >&5
15220 sed 's/^/| /' conftest.$ac_ext >&5
15221
15222 ac_cv_lib_m_floorf=no
15223 fi
15224 rm -f conftest.err conftest.$ac_objext \
15225       conftest$ac_exeext conftest.$ac_ext
15226 LIBS=$ac_check_lib_save_LIBS
15227 fi
15228 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floorf" >&5
15229 echo "${ECHO_T}$ac_cv_lib_m_floorf" >&6
15230 if test $ac_cv_lib_m_floorf = yes; then
15231
15232 cat >>confdefs.h <<\_ACEOF
15233 #define HAVE_FLOORF 1
15234 _ACEOF
15235
15236 fi
15237
15238 echo "$as_me:$LINENO: checking for floor in -lm" >&5
15239 echo $ECHO_N "checking for floor in -lm... $ECHO_C" >&6
15240 if test "${ac_cv_lib_m_floor+set}" = set; then
15241   echo $ECHO_N "(cached) $ECHO_C" >&6
15242 else
15243   ac_check_lib_save_LIBS=$LIBS
15244 LIBS="-lm  $LIBS"
15245 if test x$gcc_no_link = xyes; then
15246   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15247 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15248    { (exit 1); exit 1; }; }
15249 fi
15250 cat >conftest.$ac_ext <<_ACEOF
15251 /* confdefs.h.  */
15252 _ACEOF
15253 cat confdefs.h >>conftest.$ac_ext
15254 cat >>conftest.$ac_ext <<_ACEOF
15255 /* end confdefs.h.  */
15256
15257 /* Override any gcc2 internal prototype to avoid an error.  */
15258 #ifdef __cplusplus
15259 extern "C"
15260 #endif
15261 /* We use char because int might match the return type of a gcc2
15262    builtin and then its argument prototype would still apply.  */
15263 char floor ();
15264 int
15265 main ()
15266 {
15267 floor ();
15268   ;
15269   return 0;
15270 }
15271 _ACEOF
15272 rm -f conftest.$ac_objext conftest$ac_exeext
15273 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15274   (eval $ac_link) 2>conftest.er1
15275   ac_status=$?
15276   grep -v '^ *+' conftest.er1 >conftest.err
15277   rm -f conftest.er1
15278   cat conftest.err >&5
15279   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15280   (exit $ac_status); } &&
15281          { ac_try='test -z "$ac_c_werror_flag"
15282                          || test ! -s conftest.err'
15283   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15284   (eval $ac_try) 2>&5
15285   ac_status=$?
15286   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15287   (exit $ac_status); }; } &&
15288          { ac_try='test -s conftest$ac_exeext'
15289   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15290   (eval $ac_try) 2>&5
15291   ac_status=$?
15292   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15293   (exit $ac_status); }; }; then
15294   ac_cv_lib_m_floor=yes
15295 else
15296   echo "$as_me: failed program was:" >&5
15297 sed 's/^/| /' conftest.$ac_ext >&5
15298
15299 ac_cv_lib_m_floor=no
15300 fi
15301 rm -f conftest.err conftest.$ac_objext \
15302       conftest$ac_exeext conftest.$ac_ext
15303 LIBS=$ac_check_lib_save_LIBS
15304 fi
15305 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floor" >&5
15306 echo "${ECHO_T}$ac_cv_lib_m_floor" >&6
15307 if test $ac_cv_lib_m_floor = yes; then
15308
15309 cat >>confdefs.h <<\_ACEOF
15310 #define HAVE_FLOOR 1
15311 _ACEOF
15312
15313 fi
15314
15315 echo "$as_me:$LINENO: checking for floorl in -lm" >&5
15316 echo $ECHO_N "checking for floorl in -lm... $ECHO_C" >&6
15317 if test "${ac_cv_lib_m_floorl+set}" = set; then
15318   echo $ECHO_N "(cached) $ECHO_C" >&6
15319 else
15320   ac_check_lib_save_LIBS=$LIBS
15321 LIBS="-lm  $LIBS"
15322 if test x$gcc_no_link = xyes; then
15323   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15324 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15325    { (exit 1); exit 1; }; }
15326 fi
15327 cat >conftest.$ac_ext <<_ACEOF
15328 /* confdefs.h.  */
15329 _ACEOF
15330 cat confdefs.h >>conftest.$ac_ext
15331 cat >>conftest.$ac_ext <<_ACEOF
15332 /* end confdefs.h.  */
15333
15334 /* Override any gcc2 internal prototype to avoid an error.  */
15335 #ifdef __cplusplus
15336 extern "C"
15337 #endif
15338 /* We use char because int might match the return type of a gcc2
15339    builtin and then its argument prototype would still apply.  */
15340 char floorl ();
15341 int
15342 main ()
15343 {
15344 floorl ();
15345   ;
15346   return 0;
15347 }
15348 _ACEOF
15349 rm -f conftest.$ac_objext conftest$ac_exeext
15350 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15351   (eval $ac_link) 2>conftest.er1
15352   ac_status=$?
15353   grep -v '^ *+' conftest.er1 >conftest.err
15354   rm -f conftest.er1
15355   cat conftest.err >&5
15356   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15357   (exit $ac_status); } &&
15358          { ac_try='test -z "$ac_c_werror_flag"
15359                          || test ! -s conftest.err'
15360   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15361   (eval $ac_try) 2>&5
15362   ac_status=$?
15363   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15364   (exit $ac_status); }; } &&
15365          { ac_try='test -s conftest$ac_exeext'
15366   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15367   (eval $ac_try) 2>&5
15368   ac_status=$?
15369   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15370   (exit $ac_status); }; }; then
15371   ac_cv_lib_m_floorl=yes
15372 else
15373   echo "$as_me: failed program was:" >&5
15374 sed 's/^/| /' conftest.$ac_ext >&5
15375
15376 ac_cv_lib_m_floorl=no
15377 fi
15378 rm -f conftest.err conftest.$ac_objext \
15379       conftest$ac_exeext conftest.$ac_ext
15380 LIBS=$ac_check_lib_save_LIBS
15381 fi
15382 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floorl" >&5
15383 echo "${ECHO_T}$ac_cv_lib_m_floorl" >&6
15384 if test $ac_cv_lib_m_floorl = yes; then
15385
15386 cat >>confdefs.h <<\_ACEOF
15387 #define HAVE_FLOORL 1
15388 _ACEOF
15389
15390 fi
15391
15392 echo "$as_me:$LINENO: checking for fmodf in -lm" >&5
15393 echo $ECHO_N "checking for fmodf in -lm... $ECHO_C" >&6
15394 if test "${ac_cv_lib_m_fmodf+set}" = set; then
15395   echo $ECHO_N "(cached) $ECHO_C" >&6
15396 else
15397   ac_check_lib_save_LIBS=$LIBS
15398 LIBS="-lm  $LIBS"
15399 if test x$gcc_no_link = xyes; then
15400   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15401 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15402    { (exit 1); exit 1; }; }
15403 fi
15404 cat >conftest.$ac_ext <<_ACEOF
15405 /* confdefs.h.  */
15406 _ACEOF
15407 cat confdefs.h >>conftest.$ac_ext
15408 cat >>conftest.$ac_ext <<_ACEOF
15409 /* end confdefs.h.  */
15410
15411 /* Override any gcc2 internal prototype to avoid an error.  */
15412 #ifdef __cplusplus
15413 extern "C"
15414 #endif
15415 /* We use char because int might match the return type of a gcc2
15416    builtin and then its argument prototype would still apply.  */
15417 char fmodf ();
15418 int
15419 main ()
15420 {
15421 fmodf ();
15422   ;
15423   return 0;
15424 }
15425 _ACEOF
15426 rm -f conftest.$ac_objext conftest$ac_exeext
15427 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15428   (eval $ac_link) 2>conftest.er1
15429   ac_status=$?
15430   grep -v '^ *+' conftest.er1 >conftest.err
15431   rm -f conftest.er1
15432   cat conftest.err >&5
15433   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15434   (exit $ac_status); } &&
15435          { ac_try='test -z "$ac_c_werror_flag"
15436                          || test ! -s conftest.err'
15437   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15438   (eval $ac_try) 2>&5
15439   ac_status=$?
15440   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15441   (exit $ac_status); }; } &&
15442          { ac_try='test -s conftest$ac_exeext'
15443   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15444   (eval $ac_try) 2>&5
15445   ac_status=$?
15446   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15447   (exit $ac_status); }; }; then
15448   ac_cv_lib_m_fmodf=yes
15449 else
15450   echo "$as_me: failed program was:" >&5
15451 sed 's/^/| /' conftest.$ac_ext >&5
15452
15453 ac_cv_lib_m_fmodf=no
15454 fi
15455 rm -f conftest.err conftest.$ac_objext \
15456       conftest$ac_exeext conftest.$ac_ext
15457 LIBS=$ac_check_lib_save_LIBS
15458 fi
15459 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fmodf" >&5
15460 echo "${ECHO_T}$ac_cv_lib_m_fmodf" >&6
15461 if test $ac_cv_lib_m_fmodf = yes; then
15462
15463 cat >>confdefs.h <<\_ACEOF
15464 #define HAVE_FMODF 1
15465 _ACEOF
15466
15467 fi
15468
15469 echo "$as_me:$LINENO: checking for fmod in -lm" >&5
15470 echo $ECHO_N "checking for fmod in -lm... $ECHO_C" >&6
15471 if test "${ac_cv_lib_m_fmod+set}" = set; then
15472   echo $ECHO_N "(cached) $ECHO_C" >&6
15473 else
15474   ac_check_lib_save_LIBS=$LIBS
15475 LIBS="-lm  $LIBS"
15476 if test x$gcc_no_link = xyes; then
15477   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15478 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15479    { (exit 1); exit 1; }; }
15480 fi
15481 cat >conftest.$ac_ext <<_ACEOF
15482 /* confdefs.h.  */
15483 _ACEOF
15484 cat confdefs.h >>conftest.$ac_ext
15485 cat >>conftest.$ac_ext <<_ACEOF
15486 /* end confdefs.h.  */
15487
15488 /* Override any gcc2 internal prototype to avoid an error.  */
15489 #ifdef __cplusplus
15490 extern "C"
15491 #endif
15492 /* We use char because int might match the return type of a gcc2
15493    builtin and then its argument prototype would still apply.  */
15494 char fmod ();
15495 int
15496 main ()
15497 {
15498 fmod ();
15499   ;
15500   return 0;
15501 }
15502 _ACEOF
15503 rm -f conftest.$ac_objext conftest$ac_exeext
15504 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15505   (eval $ac_link) 2>conftest.er1
15506   ac_status=$?
15507   grep -v '^ *+' conftest.er1 >conftest.err
15508   rm -f conftest.er1
15509   cat conftest.err >&5
15510   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15511   (exit $ac_status); } &&
15512          { ac_try='test -z "$ac_c_werror_flag"
15513                          || test ! -s conftest.err'
15514   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15515   (eval $ac_try) 2>&5
15516   ac_status=$?
15517   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15518   (exit $ac_status); }; } &&
15519          { ac_try='test -s conftest$ac_exeext'
15520   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15521   (eval $ac_try) 2>&5
15522   ac_status=$?
15523   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15524   (exit $ac_status); }; }; then
15525   ac_cv_lib_m_fmod=yes
15526 else
15527   echo "$as_me: failed program was:" >&5
15528 sed 's/^/| /' conftest.$ac_ext >&5
15529
15530 ac_cv_lib_m_fmod=no
15531 fi
15532 rm -f conftest.err conftest.$ac_objext \
15533       conftest$ac_exeext conftest.$ac_ext
15534 LIBS=$ac_check_lib_save_LIBS
15535 fi
15536 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fmod" >&5
15537 echo "${ECHO_T}$ac_cv_lib_m_fmod" >&6
15538 if test $ac_cv_lib_m_fmod = yes; then
15539
15540 cat >>confdefs.h <<\_ACEOF
15541 #define HAVE_FMOD 1
15542 _ACEOF
15543
15544 fi
15545
15546 echo "$as_me:$LINENO: checking for fmodl in -lm" >&5
15547 echo $ECHO_N "checking for fmodl in -lm... $ECHO_C" >&6
15548 if test "${ac_cv_lib_m_fmodl+set}" = set; then
15549   echo $ECHO_N "(cached) $ECHO_C" >&6
15550 else
15551   ac_check_lib_save_LIBS=$LIBS
15552 LIBS="-lm  $LIBS"
15553 if test x$gcc_no_link = xyes; then
15554   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15555 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15556    { (exit 1); exit 1; }; }
15557 fi
15558 cat >conftest.$ac_ext <<_ACEOF
15559 /* confdefs.h.  */
15560 _ACEOF
15561 cat confdefs.h >>conftest.$ac_ext
15562 cat >>conftest.$ac_ext <<_ACEOF
15563 /* end confdefs.h.  */
15564
15565 /* Override any gcc2 internal prototype to avoid an error.  */
15566 #ifdef __cplusplus
15567 extern "C"
15568 #endif
15569 /* We use char because int might match the return type of a gcc2
15570    builtin and then its argument prototype would still apply.  */
15571 char fmodl ();
15572 int
15573 main ()
15574 {
15575 fmodl ();
15576   ;
15577   return 0;
15578 }
15579 _ACEOF
15580 rm -f conftest.$ac_objext conftest$ac_exeext
15581 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15582   (eval $ac_link) 2>conftest.er1
15583   ac_status=$?
15584   grep -v '^ *+' conftest.er1 >conftest.err
15585   rm -f conftest.er1
15586   cat conftest.err >&5
15587   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15588   (exit $ac_status); } &&
15589          { ac_try='test -z "$ac_c_werror_flag"
15590                          || test ! -s conftest.err'
15591   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15592   (eval $ac_try) 2>&5
15593   ac_status=$?
15594   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15595   (exit $ac_status); }; } &&
15596          { ac_try='test -s conftest$ac_exeext'
15597   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15598   (eval $ac_try) 2>&5
15599   ac_status=$?
15600   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15601   (exit $ac_status); }; }; then
15602   ac_cv_lib_m_fmodl=yes
15603 else
15604   echo "$as_me: failed program was:" >&5
15605 sed 's/^/| /' conftest.$ac_ext >&5
15606
15607 ac_cv_lib_m_fmodl=no
15608 fi
15609 rm -f conftest.err conftest.$ac_objext \
15610       conftest$ac_exeext conftest.$ac_ext
15611 LIBS=$ac_check_lib_save_LIBS
15612 fi
15613 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fmodl" >&5
15614 echo "${ECHO_T}$ac_cv_lib_m_fmodl" >&6
15615 if test $ac_cv_lib_m_fmodl = yes; then
15616
15617 cat >>confdefs.h <<\_ACEOF
15618 #define HAVE_FMODL 1
15619 _ACEOF
15620
15621 fi
15622
15623 echo "$as_me:$LINENO: checking for frexpf in -lm" >&5
15624 echo $ECHO_N "checking for frexpf in -lm... $ECHO_C" >&6
15625 if test "${ac_cv_lib_m_frexpf+set}" = set; then
15626   echo $ECHO_N "(cached) $ECHO_C" >&6
15627 else
15628   ac_check_lib_save_LIBS=$LIBS
15629 LIBS="-lm  $LIBS"
15630 if test x$gcc_no_link = xyes; then
15631   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15632 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15633    { (exit 1); exit 1; }; }
15634 fi
15635 cat >conftest.$ac_ext <<_ACEOF
15636 /* confdefs.h.  */
15637 _ACEOF
15638 cat confdefs.h >>conftest.$ac_ext
15639 cat >>conftest.$ac_ext <<_ACEOF
15640 /* end confdefs.h.  */
15641
15642 /* Override any gcc2 internal prototype to avoid an error.  */
15643 #ifdef __cplusplus
15644 extern "C"
15645 #endif
15646 /* We use char because int might match the return type of a gcc2
15647    builtin and then its argument prototype would still apply.  */
15648 char frexpf ();
15649 int
15650 main ()
15651 {
15652 frexpf ();
15653   ;
15654   return 0;
15655 }
15656 _ACEOF
15657 rm -f conftest.$ac_objext conftest$ac_exeext
15658 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15659   (eval $ac_link) 2>conftest.er1
15660   ac_status=$?
15661   grep -v '^ *+' conftest.er1 >conftest.err
15662   rm -f conftest.er1
15663   cat conftest.err >&5
15664   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15665   (exit $ac_status); } &&
15666          { ac_try='test -z "$ac_c_werror_flag"
15667                          || test ! -s conftest.err'
15668   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15669   (eval $ac_try) 2>&5
15670   ac_status=$?
15671   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15672   (exit $ac_status); }; } &&
15673          { ac_try='test -s conftest$ac_exeext'
15674   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15675   (eval $ac_try) 2>&5
15676   ac_status=$?
15677   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15678   (exit $ac_status); }; }; then
15679   ac_cv_lib_m_frexpf=yes
15680 else
15681   echo "$as_me: failed program was:" >&5
15682 sed 's/^/| /' conftest.$ac_ext >&5
15683
15684 ac_cv_lib_m_frexpf=no
15685 fi
15686 rm -f conftest.err conftest.$ac_objext \
15687       conftest$ac_exeext conftest.$ac_ext
15688 LIBS=$ac_check_lib_save_LIBS
15689 fi
15690 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexpf" >&5
15691 echo "${ECHO_T}$ac_cv_lib_m_frexpf" >&6
15692 if test $ac_cv_lib_m_frexpf = yes; then
15693
15694 cat >>confdefs.h <<\_ACEOF
15695 #define HAVE_FREXPF 1
15696 _ACEOF
15697
15698 fi
15699
15700 echo "$as_me:$LINENO: checking for frexp in -lm" >&5
15701 echo $ECHO_N "checking for frexp in -lm... $ECHO_C" >&6
15702 if test "${ac_cv_lib_m_frexp+set}" = set; then
15703   echo $ECHO_N "(cached) $ECHO_C" >&6
15704 else
15705   ac_check_lib_save_LIBS=$LIBS
15706 LIBS="-lm  $LIBS"
15707 if test x$gcc_no_link = xyes; then
15708   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15709 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15710    { (exit 1); exit 1; }; }
15711 fi
15712 cat >conftest.$ac_ext <<_ACEOF
15713 /* confdefs.h.  */
15714 _ACEOF
15715 cat confdefs.h >>conftest.$ac_ext
15716 cat >>conftest.$ac_ext <<_ACEOF
15717 /* end confdefs.h.  */
15718
15719 /* Override any gcc2 internal prototype to avoid an error.  */
15720 #ifdef __cplusplus
15721 extern "C"
15722 #endif
15723 /* We use char because int might match the return type of a gcc2
15724    builtin and then its argument prototype would still apply.  */
15725 char frexp ();
15726 int
15727 main ()
15728 {
15729 frexp ();
15730   ;
15731   return 0;
15732 }
15733 _ACEOF
15734 rm -f conftest.$ac_objext conftest$ac_exeext
15735 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15736   (eval $ac_link) 2>conftest.er1
15737   ac_status=$?
15738   grep -v '^ *+' conftest.er1 >conftest.err
15739   rm -f conftest.er1
15740   cat conftest.err >&5
15741   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15742   (exit $ac_status); } &&
15743          { ac_try='test -z "$ac_c_werror_flag"
15744                          || test ! -s conftest.err'
15745   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15746   (eval $ac_try) 2>&5
15747   ac_status=$?
15748   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15749   (exit $ac_status); }; } &&
15750          { ac_try='test -s conftest$ac_exeext'
15751   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15752   (eval $ac_try) 2>&5
15753   ac_status=$?
15754   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15755   (exit $ac_status); }; }; then
15756   ac_cv_lib_m_frexp=yes
15757 else
15758   echo "$as_me: failed program was:" >&5
15759 sed 's/^/| /' conftest.$ac_ext >&5
15760
15761 ac_cv_lib_m_frexp=no
15762 fi
15763 rm -f conftest.err conftest.$ac_objext \
15764       conftest$ac_exeext conftest.$ac_ext
15765 LIBS=$ac_check_lib_save_LIBS
15766 fi
15767 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexp" >&5
15768 echo "${ECHO_T}$ac_cv_lib_m_frexp" >&6
15769 if test $ac_cv_lib_m_frexp = yes; then
15770
15771 cat >>confdefs.h <<\_ACEOF
15772 #define HAVE_FREXP 1
15773 _ACEOF
15774
15775 fi
15776
15777 echo "$as_me:$LINENO: checking for frexpl in -lm" >&5
15778 echo $ECHO_N "checking for frexpl in -lm... $ECHO_C" >&6
15779 if test "${ac_cv_lib_m_frexpl+set}" = set; then
15780   echo $ECHO_N "(cached) $ECHO_C" >&6
15781 else
15782   ac_check_lib_save_LIBS=$LIBS
15783 LIBS="-lm  $LIBS"
15784 if test x$gcc_no_link = xyes; then
15785   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15786 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15787    { (exit 1); exit 1; }; }
15788 fi
15789 cat >conftest.$ac_ext <<_ACEOF
15790 /* confdefs.h.  */
15791 _ACEOF
15792 cat confdefs.h >>conftest.$ac_ext
15793 cat >>conftest.$ac_ext <<_ACEOF
15794 /* end confdefs.h.  */
15795
15796 /* Override any gcc2 internal prototype to avoid an error.  */
15797 #ifdef __cplusplus
15798 extern "C"
15799 #endif
15800 /* We use char because int might match the return type of a gcc2
15801    builtin and then its argument prototype would still apply.  */
15802 char frexpl ();
15803 int
15804 main ()
15805 {
15806 frexpl ();
15807   ;
15808   return 0;
15809 }
15810 _ACEOF
15811 rm -f conftest.$ac_objext conftest$ac_exeext
15812 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15813   (eval $ac_link) 2>conftest.er1
15814   ac_status=$?
15815   grep -v '^ *+' conftest.er1 >conftest.err
15816   rm -f conftest.er1
15817   cat conftest.err >&5
15818   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15819   (exit $ac_status); } &&
15820          { ac_try='test -z "$ac_c_werror_flag"
15821                          || test ! -s conftest.err'
15822   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15823   (eval $ac_try) 2>&5
15824   ac_status=$?
15825   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15826   (exit $ac_status); }; } &&
15827          { ac_try='test -s conftest$ac_exeext'
15828   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15829   (eval $ac_try) 2>&5
15830   ac_status=$?
15831   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15832   (exit $ac_status); }; }; then
15833   ac_cv_lib_m_frexpl=yes
15834 else
15835   echo "$as_me: failed program was:" >&5
15836 sed 's/^/| /' conftest.$ac_ext >&5
15837
15838 ac_cv_lib_m_frexpl=no
15839 fi
15840 rm -f conftest.err conftest.$ac_objext \
15841       conftest$ac_exeext conftest.$ac_ext
15842 LIBS=$ac_check_lib_save_LIBS
15843 fi
15844 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexpl" >&5
15845 echo "${ECHO_T}$ac_cv_lib_m_frexpl" >&6
15846 if test $ac_cv_lib_m_frexpl = yes; then
15847
15848 cat >>confdefs.h <<\_ACEOF
15849 #define HAVE_FREXPL 1
15850 _ACEOF
15851
15852 fi
15853
15854 echo "$as_me:$LINENO: checking for hypotf in -lm" >&5
15855 echo $ECHO_N "checking for hypotf in -lm... $ECHO_C" >&6
15856 if test "${ac_cv_lib_m_hypotf+set}" = set; then
15857   echo $ECHO_N "(cached) $ECHO_C" >&6
15858 else
15859   ac_check_lib_save_LIBS=$LIBS
15860 LIBS="-lm  $LIBS"
15861 if test x$gcc_no_link = xyes; then
15862   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15863 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15864    { (exit 1); exit 1; }; }
15865 fi
15866 cat >conftest.$ac_ext <<_ACEOF
15867 /* confdefs.h.  */
15868 _ACEOF
15869 cat confdefs.h >>conftest.$ac_ext
15870 cat >>conftest.$ac_ext <<_ACEOF
15871 /* end confdefs.h.  */
15872
15873 /* Override any gcc2 internal prototype to avoid an error.  */
15874 #ifdef __cplusplus
15875 extern "C"
15876 #endif
15877 /* We use char because int might match the return type of a gcc2
15878    builtin and then its argument prototype would still apply.  */
15879 char hypotf ();
15880 int
15881 main ()
15882 {
15883 hypotf ();
15884   ;
15885   return 0;
15886 }
15887 _ACEOF
15888 rm -f conftest.$ac_objext conftest$ac_exeext
15889 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15890   (eval $ac_link) 2>conftest.er1
15891   ac_status=$?
15892   grep -v '^ *+' conftest.er1 >conftest.err
15893   rm -f conftest.er1
15894   cat conftest.err >&5
15895   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15896   (exit $ac_status); } &&
15897          { ac_try='test -z "$ac_c_werror_flag"
15898                          || test ! -s conftest.err'
15899   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15900   (eval $ac_try) 2>&5
15901   ac_status=$?
15902   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15903   (exit $ac_status); }; } &&
15904          { ac_try='test -s conftest$ac_exeext'
15905   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15906   (eval $ac_try) 2>&5
15907   ac_status=$?
15908   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15909   (exit $ac_status); }; }; then
15910   ac_cv_lib_m_hypotf=yes
15911 else
15912   echo "$as_me: failed program was:" >&5
15913 sed 's/^/| /' conftest.$ac_ext >&5
15914
15915 ac_cv_lib_m_hypotf=no
15916 fi
15917 rm -f conftest.err conftest.$ac_objext \
15918       conftest$ac_exeext conftest.$ac_ext
15919 LIBS=$ac_check_lib_save_LIBS
15920 fi
15921 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypotf" >&5
15922 echo "${ECHO_T}$ac_cv_lib_m_hypotf" >&6
15923 if test $ac_cv_lib_m_hypotf = yes; then
15924
15925 cat >>confdefs.h <<\_ACEOF
15926 #define HAVE_HYPOTF 1
15927 _ACEOF
15928
15929 fi
15930
15931 echo "$as_me:$LINENO: checking for hypot in -lm" >&5
15932 echo $ECHO_N "checking for hypot in -lm... $ECHO_C" >&6
15933 if test "${ac_cv_lib_m_hypot+set}" = set; then
15934   echo $ECHO_N "(cached) $ECHO_C" >&6
15935 else
15936   ac_check_lib_save_LIBS=$LIBS
15937 LIBS="-lm  $LIBS"
15938 if test x$gcc_no_link = xyes; then
15939   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15940 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15941    { (exit 1); exit 1; }; }
15942 fi
15943 cat >conftest.$ac_ext <<_ACEOF
15944 /* confdefs.h.  */
15945 _ACEOF
15946 cat confdefs.h >>conftest.$ac_ext
15947 cat >>conftest.$ac_ext <<_ACEOF
15948 /* end confdefs.h.  */
15949
15950 /* Override any gcc2 internal prototype to avoid an error.  */
15951 #ifdef __cplusplus
15952 extern "C"
15953 #endif
15954 /* We use char because int might match the return type of a gcc2
15955    builtin and then its argument prototype would still apply.  */
15956 char hypot ();
15957 int
15958 main ()
15959 {
15960 hypot ();
15961   ;
15962   return 0;
15963 }
15964 _ACEOF
15965 rm -f conftest.$ac_objext conftest$ac_exeext
15966 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15967   (eval $ac_link) 2>conftest.er1
15968   ac_status=$?
15969   grep -v '^ *+' conftest.er1 >conftest.err
15970   rm -f conftest.er1
15971   cat conftest.err >&5
15972   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15973   (exit $ac_status); } &&
15974          { ac_try='test -z "$ac_c_werror_flag"
15975                          || test ! -s conftest.err'
15976   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15977   (eval $ac_try) 2>&5
15978   ac_status=$?
15979   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15980   (exit $ac_status); }; } &&
15981          { ac_try='test -s conftest$ac_exeext'
15982   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15983   (eval $ac_try) 2>&5
15984   ac_status=$?
15985   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15986   (exit $ac_status); }; }; then
15987   ac_cv_lib_m_hypot=yes
15988 else
15989   echo "$as_me: failed program was:" >&5
15990 sed 's/^/| /' conftest.$ac_ext >&5
15991
15992 ac_cv_lib_m_hypot=no
15993 fi
15994 rm -f conftest.err conftest.$ac_objext \
15995       conftest$ac_exeext conftest.$ac_ext
15996 LIBS=$ac_check_lib_save_LIBS
15997 fi
15998 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypot" >&5
15999 echo "${ECHO_T}$ac_cv_lib_m_hypot" >&6
16000 if test $ac_cv_lib_m_hypot = yes; then
16001
16002 cat >>confdefs.h <<\_ACEOF
16003 #define HAVE_HYPOT 1
16004 _ACEOF
16005
16006 fi
16007
16008 echo "$as_me:$LINENO: checking for hypotl in -lm" >&5
16009 echo $ECHO_N "checking for hypotl in -lm... $ECHO_C" >&6
16010 if test "${ac_cv_lib_m_hypotl+set}" = set; then
16011   echo $ECHO_N "(cached) $ECHO_C" >&6
16012 else
16013   ac_check_lib_save_LIBS=$LIBS
16014 LIBS="-lm  $LIBS"
16015 if test x$gcc_no_link = xyes; then
16016   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16017 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16018    { (exit 1); exit 1; }; }
16019 fi
16020 cat >conftest.$ac_ext <<_ACEOF
16021 /* confdefs.h.  */
16022 _ACEOF
16023 cat confdefs.h >>conftest.$ac_ext
16024 cat >>conftest.$ac_ext <<_ACEOF
16025 /* end confdefs.h.  */
16026
16027 /* Override any gcc2 internal prototype to avoid an error.  */
16028 #ifdef __cplusplus
16029 extern "C"
16030 #endif
16031 /* We use char because int might match the return type of a gcc2
16032    builtin and then its argument prototype would still apply.  */
16033 char hypotl ();
16034 int
16035 main ()
16036 {
16037 hypotl ();
16038   ;
16039   return 0;
16040 }
16041 _ACEOF
16042 rm -f conftest.$ac_objext conftest$ac_exeext
16043 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16044   (eval $ac_link) 2>conftest.er1
16045   ac_status=$?
16046   grep -v '^ *+' conftest.er1 >conftest.err
16047   rm -f conftest.er1
16048   cat conftest.err >&5
16049   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16050   (exit $ac_status); } &&
16051          { ac_try='test -z "$ac_c_werror_flag"
16052                          || test ! -s conftest.err'
16053   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16054   (eval $ac_try) 2>&5
16055   ac_status=$?
16056   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16057   (exit $ac_status); }; } &&
16058          { ac_try='test -s conftest$ac_exeext'
16059   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16060   (eval $ac_try) 2>&5
16061   ac_status=$?
16062   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16063   (exit $ac_status); }; }; then
16064   ac_cv_lib_m_hypotl=yes
16065 else
16066   echo "$as_me: failed program was:" >&5
16067 sed 's/^/| /' conftest.$ac_ext >&5
16068
16069 ac_cv_lib_m_hypotl=no
16070 fi
16071 rm -f conftest.err conftest.$ac_objext \
16072       conftest$ac_exeext conftest.$ac_ext
16073 LIBS=$ac_check_lib_save_LIBS
16074 fi
16075 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypotl" >&5
16076 echo "${ECHO_T}$ac_cv_lib_m_hypotl" >&6
16077 if test $ac_cv_lib_m_hypotl = yes; then
16078
16079 cat >>confdefs.h <<\_ACEOF
16080 #define HAVE_HYPOTL 1
16081 _ACEOF
16082
16083 fi
16084
16085 echo "$as_me:$LINENO: checking for ldexpf in -lm" >&5
16086 echo $ECHO_N "checking for ldexpf in -lm... $ECHO_C" >&6
16087 if test "${ac_cv_lib_m_ldexpf+set}" = set; then
16088   echo $ECHO_N "(cached) $ECHO_C" >&6
16089 else
16090   ac_check_lib_save_LIBS=$LIBS
16091 LIBS="-lm  $LIBS"
16092 if test x$gcc_no_link = xyes; then
16093   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16094 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16095    { (exit 1); exit 1; }; }
16096 fi
16097 cat >conftest.$ac_ext <<_ACEOF
16098 /* confdefs.h.  */
16099 _ACEOF
16100 cat confdefs.h >>conftest.$ac_ext
16101 cat >>conftest.$ac_ext <<_ACEOF
16102 /* end confdefs.h.  */
16103
16104 /* Override any gcc2 internal prototype to avoid an error.  */
16105 #ifdef __cplusplus
16106 extern "C"
16107 #endif
16108 /* We use char because int might match the return type of a gcc2
16109    builtin and then its argument prototype would still apply.  */
16110 char ldexpf ();
16111 int
16112 main ()
16113 {
16114 ldexpf ();
16115   ;
16116   return 0;
16117 }
16118 _ACEOF
16119 rm -f conftest.$ac_objext conftest$ac_exeext
16120 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16121   (eval $ac_link) 2>conftest.er1
16122   ac_status=$?
16123   grep -v '^ *+' conftest.er1 >conftest.err
16124   rm -f conftest.er1
16125   cat conftest.err >&5
16126   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16127   (exit $ac_status); } &&
16128          { ac_try='test -z "$ac_c_werror_flag"
16129                          || test ! -s conftest.err'
16130   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16131   (eval $ac_try) 2>&5
16132   ac_status=$?
16133   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16134   (exit $ac_status); }; } &&
16135          { ac_try='test -s conftest$ac_exeext'
16136   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16137   (eval $ac_try) 2>&5
16138   ac_status=$?
16139   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16140   (exit $ac_status); }; }; then
16141   ac_cv_lib_m_ldexpf=yes
16142 else
16143   echo "$as_me: failed program was:" >&5
16144 sed 's/^/| /' conftest.$ac_ext >&5
16145
16146 ac_cv_lib_m_ldexpf=no
16147 fi
16148 rm -f conftest.err conftest.$ac_objext \
16149       conftest$ac_exeext conftest.$ac_ext
16150 LIBS=$ac_check_lib_save_LIBS
16151 fi
16152 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ldexpf" >&5
16153 echo "${ECHO_T}$ac_cv_lib_m_ldexpf" >&6
16154 if test $ac_cv_lib_m_ldexpf = yes; then
16155
16156 cat >>confdefs.h <<\_ACEOF
16157 #define HAVE_LDEXPF 1
16158 _ACEOF
16159
16160 fi
16161
16162 echo "$as_me:$LINENO: checking for ldexp in -lm" >&5
16163 echo $ECHO_N "checking for ldexp in -lm... $ECHO_C" >&6
16164 if test "${ac_cv_lib_m_ldexp+set}" = set; then
16165   echo $ECHO_N "(cached) $ECHO_C" >&6
16166 else
16167   ac_check_lib_save_LIBS=$LIBS
16168 LIBS="-lm  $LIBS"
16169 if test x$gcc_no_link = xyes; then
16170   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16171 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16172    { (exit 1); exit 1; }; }
16173 fi
16174 cat >conftest.$ac_ext <<_ACEOF
16175 /* confdefs.h.  */
16176 _ACEOF
16177 cat confdefs.h >>conftest.$ac_ext
16178 cat >>conftest.$ac_ext <<_ACEOF
16179 /* end confdefs.h.  */
16180
16181 /* Override any gcc2 internal prototype to avoid an error.  */
16182 #ifdef __cplusplus
16183 extern "C"
16184 #endif
16185 /* We use char because int might match the return type of a gcc2
16186    builtin and then its argument prototype would still apply.  */
16187 char ldexp ();
16188 int
16189 main ()
16190 {
16191 ldexp ();
16192   ;
16193   return 0;
16194 }
16195 _ACEOF
16196 rm -f conftest.$ac_objext conftest$ac_exeext
16197 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16198   (eval $ac_link) 2>conftest.er1
16199   ac_status=$?
16200   grep -v '^ *+' conftest.er1 >conftest.err
16201   rm -f conftest.er1
16202   cat conftest.err >&5
16203   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16204   (exit $ac_status); } &&
16205          { ac_try='test -z "$ac_c_werror_flag"
16206                          || test ! -s conftest.err'
16207   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16208   (eval $ac_try) 2>&5
16209   ac_status=$?
16210   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16211   (exit $ac_status); }; } &&
16212          { ac_try='test -s conftest$ac_exeext'
16213   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16214   (eval $ac_try) 2>&5
16215   ac_status=$?
16216   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16217   (exit $ac_status); }; }; then
16218   ac_cv_lib_m_ldexp=yes
16219 else
16220   echo "$as_me: failed program was:" >&5
16221 sed 's/^/| /' conftest.$ac_ext >&5
16222
16223 ac_cv_lib_m_ldexp=no
16224 fi
16225 rm -f conftest.err conftest.$ac_objext \
16226       conftest$ac_exeext conftest.$ac_ext
16227 LIBS=$ac_check_lib_save_LIBS
16228 fi
16229 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ldexp" >&5
16230 echo "${ECHO_T}$ac_cv_lib_m_ldexp" >&6
16231 if test $ac_cv_lib_m_ldexp = yes; then
16232
16233 cat >>confdefs.h <<\_ACEOF
16234 #define HAVE_LDEXP 1
16235 _ACEOF
16236
16237 fi
16238
16239 echo "$as_me:$LINENO: checking for ldexpl in -lm" >&5
16240 echo $ECHO_N "checking for ldexpl in -lm... $ECHO_C" >&6
16241 if test "${ac_cv_lib_m_ldexpl+set}" = set; then
16242   echo $ECHO_N "(cached) $ECHO_C" >&6
16243 else
16244   ac_check_lib_save_LIBS=$LIBS
16245 LIBS="-lm  $LIBS"
16246 if test x$gcc_no_link = xyes; then
16247   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16248 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16249    { (exit 1); exit 1; }; }
16250 fi
16251 cat >conftest.$ac_ext <<_ACEOF
16252 /* confdefs.h.  */
16253 _ACEOF
16254 cat confdefs.h >>conftest.$ac_ext
16255 cat >>conftest.$ac_ext <<_ACEOF
16256 /* end confdefs.h.  */
16257
16258 /* Override any gcc2 internal prototype to avoid an error.  */
16259 #ifdef __cplusplus
16260 extern "C"
16261 #endif
16262 /* We use char because int might match the return type of a gcc2
16263    builtin and then its argument prototype would still apply.  */
16264 char ldexpl ();
16265 int
16266 main ()
16267 {
16268 ldexpl ();
16269   ;
16270   return 0;
16271 }
16272 _ACEOF
16273 rm -f conftest.$ac_objext conftest$ac_exeext
16274 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16275   (eval $ac_link) 2>conftest.er1
16276   ac_status=$?
16277   grep -v '^ *+' conftest.er1 >conftest.err
16278   rm -f conftest.er1
16279   cat conftest.err >&5
16280   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16281   (exit $ac_status); } &&
16282          { ac_try='test -z "$ac_c_werror_flag"
16283                          || test ! -s conftest.err'
16284   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16285   (eval $ac_try) 2>&5
16286   ac_status=$?
16287   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16288   (exit $ac_status); }; } &&
16289          { ac_try='test -s conftest$ac_exeext'
16290   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16291   (eval $ac_try) 2>&5
16292   ac_status=$?
16293   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16294   (exit $ac_status); }; }; then
16295   ac_cv_lib_m_ldexpl=yes
16296 else
16297   echo "$as_me: failed program was:" >&5
16298 sed 's/^/| /' conftest.$ac_ext >&5
16299
16300 ac_cv_lib_m_ldexpl=no
16301 fi
16302 rm -f conftest.err conftest.$ac_objext \
16303       conftest$ac_exeext conftest.$ac_ext
16304 LIBS=$ac_check_lib_save_LIBS
16305 fi
16306 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ldexpl" >&5
16307 echo "${ECHO_T}$ac_cv_lib_m_ldexpl" >&6
16308 if test $ac_cv_lib_m_ldexpl = yes; then
16309
16310 cat >>confdefs.h <<\_ACEOF
16311 #define HAVE_LDEXPL 1
16312 _ACEOF
16313
16314 fi
16315
16316 echo "$as_me:$LINENO: checking for logf in -lm" >&5
16317 echo $ECHO_N "checking for logf in -lm... $ECHO_C" >&6
16318 if test "${ac_cv_lib_m_logf+set}" = set; then
16319   echo $ECHO_N "(cached) $ECHO_C" >&6
16320 else
16321   ac_check_lib_save_LIBS=$LIBS
16322 LIBS="-lm  $LIBS"
16323 if test x$gcc_no_link = xyes; then
16324   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16325 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16326    { (exit 1); exit 1; }; }
16327 fi
16328 cat >conftest.$ac_ext <<_ACEOF
16329 /* confdefs.h.  */
16330 _ACEOF
16331 cat confdefs.h >>conftest.$ac_ext
16332 cat >>conftest.$ac_ext <<_ACEOF
16333 /* end confdefs.h.  */
16334
16335 /* Override any gcc2 internal prototype to avoid an error.  */
16336 #ifdef __cplusplus
16337 extern "C"
16338 #endif
16339 /* We use char because int might match the return type of a gcc2
16340    builtin and then its argument prototype would still apply.  */
16341 char logf ();
16342 int
16343 main ()
16344 {
16345 logf ();
16346   ;
16347   return 0;
16348 }
16349 _ACEOF
16350 rm -f conftest.$ac_objext conftest$ac_exeext
16351 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16352   (eval $ac_link) 2>conftest.er1
16353   ac_status=$?
16354   grep -v '^ *+' conftest.er1 >conftest.err
16355   rm -f conftest.er1
16356   cat conftest.err >&5
16357   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16358   (exit $ac_status); } &&
16359          { ac_try='test -z "$ac_c_werror_flag"
16360                          || test ! -s conftest.err'
16361   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16362   (eval $ac_try) 2>&5
16363   ac_status=$?
16364   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16365   (exit $ac_status); }; } &&
16366          { ac_try='test -s conftest$ac_exeext'
16367   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16368   (eval $ac_try) 2>&5
16369   ac_status=$?
16370   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16371   (exit $ac_status); }; }; then
16372   ac_cv_lib_m_logf=yes
16373 else
16374   echo "$as_me: failed program was:" >&5
16375 sed 's/^/| /' conftest.$ac_ext >&5
16376
16377 ac_cv_lib_m_logf=no
16378 fi
16379 rm -f conftest.err conftest.$ac_objext \
16380       conftest$ac_exeext conftest.$ac_ext
16381 LIBS=$ac_check_lib_save_LIBS
16382 fi
16383 echo "$as_me:$LINENO: result: $ac_cv_lib_m_logf" >&5
16384 echo "${ECHO_T}$ac_cv_lib_m_logf" >&6
16385 if test $ac_cv_lib_m_logf = yes; then
16386
16387 cat >>confdefs.h <<\_ACEOF
16388 #define HAVE_LOGF 1
16389 _ACEOF
16390
16391 fi
16392
16393 echo "$as_me:$LINENO: checking for log in -lm" >&5
16394 echo $ECHO_N "checking for log in -lm... $ECHO_C" >&6
16395 if test "${ac_cv_lib_m_log+set}" = set; then
16396   echo $ECHO_N "(cached) $ECHO_C" >&6
16397 else
16398   ac_check_lib_save_LIBS=$LIBS
16399 LIBS="-lm  $LIBS"
16400 if test x$gcc_no_link = xyes; then
16401   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16402 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16403    { (exit 1); exit 1; }; }
16404 fi
16405 cat >conftest.$ac_ext <<_ACEOF
16406 /* confdefs.h.  */
16407 _ACEOF
16408 cat confdefs.h >>conftest.$ac_ext
16409 cat >>conftest.$ac_ext <<_ACEOF
16410 /* end confdefs.h.  */
16411
16412 /* Override any gcc2 internal prototype to avoid an error.  */
16413 #ifdef __cplusplus
16414 extern "C"
16415 #endif
16416 /* We use char because int might match the return type of a gcc2
16417    builtin and then its argument prototype would still apply.  */
16418 char log ();
16419 int
16420 main ()
16421 {
16422 log ();
16423   ;
16424   return 0;
16425 }
16426 _ACEOF
16427 rm -f conftest.$ac_objext conftest$ac_exeext
16428 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16429   (eval $ac_link) 2>conftest.er1
16430   ac_status=$?
16431   grep -v '^ *+' conftest.er1 >conftest.err
16432   rm -f conftest.er1
16433   cat conftest.err >&5
16434   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16435   (exit $ac_status); } &&
16436          { ac_try='test -z "$ac_c_werror_flag"
16437                          || test ! -s conftest.err'
16438   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16439   (eval $ac_try) 2>&5
16440   ac_status=$?
16441   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16442   (exit $ac_status); }; } &&
16443          { ac_try='test -s conftest$ac_exeext'
16444   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16445   (eval $ac_try) 2>&5
16446   ac_status=$?
16447   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16448   (exit $ac_status); }; }; then
16449   ac_cv_lib_m_log=yes
16450 else
16451   echo "$as_me: failed program was:" >&5
16452 sed 's/^/| /' conftest.$ac_ext >&5
16453
16454 ac_cv_lib_m_log=no
16455 fi
16456 rm -f conftest.err conftest.$ac_objext \
16457       conftest$ac_exeext conftest.$ac_ext
16458 LIBS=$ac_check_lib_save_LIBS
16459 fi
16460 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log" >&5
16461 echo "${ECHO_T}$ac_cv_lib_m_log" >&6
16462 if test $ac_cv_lib_m_log = yes; then
16463
16464 cat >>confdefs.h <<\_ACEOF
16465 #define HAVE_LOG 1
16466 _ACEOF
16467
16468 fi
16469
16470 echo "$as_me:$LINENO: checking for logl in -lm" >&5
16471 echo $ECHO_N "checking for logl in -lm... $ECHO_C" >&6
16472 if test "${ac_cv_lib_m_logl+set}" = set; then
16473   echo $ECHO_N "(cached) $ECHO_C" >&6
16474 else
16475   ac_check_lib_save_LIBS=$LIBS
16476 LIBS="-lm  $LIBS"
16477 if test x$gcc_no_link = xyes; then
16478   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16479 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16480    { (exit 1); exit 1; }; }
16481 fi
16482 cat >conftest.$ac_ext <<_ACEOF
16483 /* confdefs.h.  */
16484 _ACEOF
16485 cat confdefs.h >>conftest.$ac_ext
16486 cat >>conftest.$ac_ext <<_ACEOF
16487 /* end confdefs.h.  */
16488
16489 /* Override any gcc2 internal prototype to avoid an error.  */
16490 #ifdef __cplusplus
16491 extern "C"
16492 #endif
16493 /* We use char because int might match the return type of a gcc2
16494    builtin and then its argument prototype would still apply.  */
16495 char logl ();
16496 int
16497 main ()
16498 {
16499 logl ();
16500   ;
16501   return 0;
16502 }
16503 _ACEOF
16504 rm -f conftest.$ac_objext conftest$ac_exeext
16505 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16506   (eval $ac_link) 2>conftest.er1
16507   ac_status=$?
16508   grep -v '^ *+' conftest.er1 >conftest.err
16509   rm -f conftest.er1
16510   cat conftest.err >&5
16511   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16512   (exit $ac_status); } &&
16513          { ac_try='test -z "$ac_c_werror_flag"
16514                          || test ! -s conftest.err'
16515   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16516   (eval $ac_try) 2>&5
16517   ac_status=$?
16518   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16519   (exit $ac_status); }; } &&
16520          { ac_try='test -s conftest$ac_exeext'
16521   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16522   (eval $ac_try) 2>&5
16523   ac_status=$?
16524   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16525   (exit $ac_status); }; }; then
16526   ac_cv_lib_m_logl=yes
16527 else
16528   echo "$as_me: failed program was:" >&5
16529 sed 's/^/| /' conftest.$ac_ext >&5
16530
16531 ac_cv_lib_m_logl=no
16532 fi
16533 rm -f conftest.err conftest.$ac_objext \
16534       conftest$ac_exeext conftest.$ac_ext
16535 LIBS=$ac_check_lib_save_LIBS
16536 fi
16537 echo "$as_me:$LINENO: result: $ac_cv_lib_m_logl" >&5
16538 echo "${ECHO_T}$ac_cv_lib_m_logl" >&6
16539 if test $ac_cv_lib_m_logl = yes; then
16540
16541 cat >>confdefs.h <<\_ACEOF
16542 #define HAVE_LOGL 1
16543 _ACEOF
16544
16545 fi
16546
16547 echo "$as_me:$LINENO: checking for clogf in -lm" >&5
16548 echo $ECHO_N "checking for clogf in -lm... $ECHO_C" >&6
16549 if test "${ac_cv_lib_m_clogf+set}" = set; then
16550   echo $ECHO_N "(cached) $ECHO_C" >&6
16551 else
16552   ac_check_lib_save_LIBS=$LIBS
16553 LIBS="-lm  $LIBS"
16554 if test x$gcc_no_link = xyes; then
16555   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16556 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16557    { (exit 1); exit 1; }; }
16558 fi
16559 cat >conftest.$ac_ext <<_ACEOF
16560 /* confdefs.h.  */
16561 _ACEOF
16562 cat confdefs.h >>conftest.$ac_ext
16563 cat >>conftest.$ac_ext <<_ACEOF
16564 /* end confdefs.h.  */
16565
16566 /* Override any gcc2 internal prototype to avoid an error.  */
16567 #ifdef __cplusplus
16568 extern "C"
16569 #endif
16570 /* We use char because int might match the return type of a gcc2
16571    builtin and then its argument prototype would still apply.  */
16572 char clogf ();
16573 int
16574 main ()
16575 {
16576 clogf ();
16577   ;
16578   return 0;
16579 }
16580 _ACEOF
16581 rm -f conftest.$ac_objext conftest$ac_exeext
16582 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16583   (eval $ac_link) 2>conftest.er1
16584   ac_status=$?
16585   grep -v '^ *+' conftest.er1 >conftest.err
16586   rm -f conftest.er1
16587   cat conftest.err >&5
16588   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16589   (exit $ac_status); } &&
16590          { ac_try='test -z "$ac_c_werror_flag"
16591                          || test ! -s conftest.err'
16592   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16593   (eval $ac_try) 2>&5
16594   ac_status=$?
16595   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16596   (exit $ac_status); }; } &&
16597          { ac_try='test -s conftest$ac_exeext'
16598   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16599   (eval $ac_try) 2>&5
16600   ac_status=$?
16601   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16602   (exit $ac_status); }; }; then
16603   ac_cv_lib_m_clogf=yes
16604 else
16605   echo "$as_me: failed program was:" >&5
16606 sed 's/^/| /' conftest.$ac_ext >&5
16607
16608 ac_cv_lib_m_clogf=no
16609 fi
16610 rm -f conftest.err conftest.$ac_objext \
16611       conftest$ac_exeext conftest.$ac_ext
16612 LIBS=$ac_check_lib_save_LIBS
16613 fi
16614 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clogf" >&5
16615 echo "${ECHO_T}$ac_cv_lib_m_clogf" >&6
16616 if test $ac_cv_lib_m_clogf = yes; then
16617
16618 cat >>confdefs.h <<\_ACEOF
16619 #define HAVE_CLOGF 1
16620 _ACEOF
16621
16622 fi
16623
16624 echo "$as_me:$LINENO: checking for clog in -lm" >&5
16625 echo $ECHO_N "checking for clog in -lm... $ECHO_C" >&6
16626 if test "${ac_cv_lib_m_clog+set}" = set; then
16627   echo $ECHO_N "(cached) $ECHO_C" >&6
16628 else
16629   ac_check_lib_save_LIBS=$LIBS
16630 LIBS="-lm  $LIBS"
16631 if test x$gcc_no_link = xyes; then
16632   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16633 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16634    { (exit 1); exit 1; }; }
16635 fi
16636 cat >conftest.$ac_ext <<_ACEOF
16637 /* confdefs.h.  */
16638 _ACEOF
16639 cat confdefs.h >>conftest.$ac_ext
16640 cat >>conftest.$ac_ext <<_ACEOF
16641 /* end confdefs.h.  */
16642
16643 /* Override any gcc2 internal prototype to avoid an error.  */
16644 #ifdef __cplusplus
16645 extern "C"
16646 #endif
16647 /* We use char because int might match the return type of a gcc2
16648    builtin and then its argument prototype would still apply.  */
16649 char clog ();
16650 int
16651 main ()
16652 {
16653 clog ();
16654   ;
16655   return 0;
16656 }
16657 _ACEOF
16658 rm -f conftest.$ac_objext conftest$ac_exeext
16659 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16660   (eval $ac_link) 2>conftest.er1
16661   ac_status=$?
16662   grep -v '^ *+' conftest.er1 >conftest.err
16663   rm -f conftest.er1
16664   cat conftest.err >&5
16665   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16666   (exit $ac_status); } &&
16667          { ac_try='test -z "$ac_c_werror_flag"
16668                          || test ! -s conftest.err'
16669   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16670   (eval $ac_try) 2>&5
16671   ac_status=$?
16672   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16673   (exit $ac_status); }; } &&
16674          { ac_try='test -s conftest$ac_exeext'
16675   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16676   (eval $ac_try) 2>&5
16677   ac_status=$?
16678   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16679   (exit $ac_status); }; }; then
16680   ac_cv_lib_m_clog=yes
16681 else
16682   echo "$as_me: failed program was:" >&5
16683 sed 's/^/| /' conftest.$ac_ext >&5
16684
16685 ac_cv_lib_m_clog=no
16686 fi
16687 rm -f conftest.err conftest.$ac_objext \
16688       conftest$ac_exeext conftest.$ac_ext
16689 LIBS=$ac_check_lib_save_LIBS
16690 fi
16691 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog" >&5
16692 echo "${ECHO_T}$ac_cv_lib_m_clog" >&6
16693 if test $ac_cv_lib_m_clog = yes; then
16694
16695 cat >>confdefs.h <<\_ACEOF
16696 #define HAVE_CLOG 1
16697 _ACEOF
16698
16699 fi
16700
16701 echo "$as_me:$LINENO: checking for clogl in -lm" >&5
16702 echo $ECHO_N "checking for clogl in -lm... $ECHO_C" >&6
16703 if test "${ac_cv_lib_m_clogl+set}" = set; then
16704   echo $ECHO_N "(cached) $ECHO_C" >&6
16705 else
16706   ac_check_lib_save_LIBS=$LIBS
16707 LIBS="-lm  $LIBS"
16708 if test x$gcc_no_link = xyes; then
16709   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16710 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16711    { (exit 1); exit 1; }; }
16712 fi
16713 cat >conftest.$ac_ext <<_ACEOF
16714 /* confdefs.h.  */
16715 _ACEOF
16716 cat confdefs.h >>conftest.$ac_ext
16717 cat >>conftest.$ac_ext <<_ACEOF
16718 /* end confdefs.h.  */
16719
16720 /* Override any gcc2 internal prototype to avoid an error.  */
16721 #ifdef __cplusplus
16722 extern "C"
16723 #endif
16724 /* We use char because int might match the return type of a gcc2
16725    builtin and then its argument prototype would still apply.  */
16726 char clogl ();
16727 int
16728 main ()
16729 {
16730 clogl ();
16731   ;
16732   return 0;
16733 }
16734 _ACEOF
16735 rm -f conftest.$ac_objext conftest$ac_exeext
16736 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16737   (eval $ac_link) 2>conftest.er1
16738   ac_status=$?
16739   grep -v '^ *+' conftest.er1 >conftest.err
16740   rm -f conftest.er1
16741   cat conftest.err >&5
16742   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16743   (exit $ac_status); } &&
16744          { ac_try='test -z "$ac_c_werror_flag"
16745                          || test ! -s conftest.err'
16746   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16747   (eval $ac_try) 2>&5
16748   ac_status=$?
16749   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16750   (exit $ac_status); }; } &&
16751          { ac_try='test -s conftest$ac_exeext'
16752   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16753   (eval $ac_try) 2>&5
16754   ac_status=$?
16755   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16756   (exit $ac_status); }; }; then
16757   ac_cv_lib_m_clogl=yes
16758 else
16759   echo "$as_me: failed program was:" >&5
16760 sed 's/^/| /' conftest.$ac_ext >&5
16761
16762 ac_cv_lib_m_clogl=no
16763 fi
16764 rm -f conftest.err conftest.$ac_objext \
16765       conftest$ac_exeext conftest.$ac_ext
16766 LIBS=$ac_check_lib_save_LIBS
16767 fi
16768 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clogl" >&5
16769 echo "${ECHO_T}$ac_cv_lib_m_clogl" >&6
16770 if test $ac_cv_lib_m_clogl = yes; then
16771
16772 cat >>confdefs.h <<\_ACEOF
16773 #define HAVE_CLOGL 1
16774 _ACEOF
16775
16776 fi
16777
16778 echo "$as_me:$LINENO: checking for log10f in -lm" >&5
16779 echo $ECHO_N "checking for log10f in -lm... $ECHO_C" >&6
16780 if test "${ac_cv_lib_m_log10f+set}" = set; then
16781   echo $ECHO_N "(cached) $ECHO_C" >&6
16782 else
16783   ac_check_lib_save_LIBS=$LIBS
16784 LIBS="-lm  $LIBS"
16785 if test x$gcc_no_link = xyes; then
16786   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16787 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16788    { (exit 1); exit 1; }; }
16789 fi
16790 cat >conftest.$ac_ext <<_ACEOF
16791 /* confdefs.h.  */
16792 _ACEOF
16793 cat confdefs.h >>conftest.$ac_ext
16794 cat >>conftest.$ac_ext <<_ACEOF
16795 /* end confdefs.h.  */
16796
16797 /* Override any gcc2 internal prototype to avoid an error.  */
16798 #ifdef __cplusplus
16799 extern "C"
16800 #endif
16801 /* We use char because int might match the return type of a gcc2
16802    builtin and then its argument prototype would still apply.  */
16803 char log10f ();
16804 int
16805 main ()
16806 {
16807 log10f ();
16808   ;
16809   return 0;
16810 }
16811 _ACEOF
16812 rm -f conftest.$ac_objext conftest$ac_exeext
16813 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16814   (eval $ac_link) 2>conftest.er1
16815   ac_status=$?
16816   grep -v '^ *+' conftest.er1 >conftest.err
16817   rm -f conftest.er1
16818   cat conftest.err >&5
16819   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16820   (exit $ac_status); } &&
16821          { ac_try='test -z "$ac_c_werror_flag"
16822                          || test ! -s conftest.err'
16823   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16824   (eval $ac_try) 2>&5
16825   ac_status=$?
16826   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16827   (exit $ac_status); }; } &&
16828          { ac_try='test -s conftest$ac_exeext'
16829   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16830   (eval $ac_try) 2>&5
16831   ac_status=$?
16832   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16833   (exit $ac_status); }; }; then
16834   ac_cv_lib_m_log10f=yes
16835 else
16836   echo "$as_me: failed program was:" >&5
16837 sed 's/^/| /' conftest.$ac_ext >&5
16838
16839 ac_cv_lib_m_log10f=no
16840 fi
16841 rm -f conftest.err conftest.$ac_objext \
16842       conftest$ac_exeext conftest.$ac_ext
16843 LIBS=$ac_check_lib_save_LIBS
16844 fi
16845 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10f" >&5
16846 echo "${ECHO_T}$ac_cv_lib_m_log10f" >&6
16847 if test $ac_cv_lib_m_log10f = yes; then
16848
16849 cat >>confdefs.h <<\_ACEOF
16850 #define HAVE_LOG10F 1
16851 _ACEOF
16852
16853 fi
16854
16855 echo "$as_me:$LINENO: checking for log10 in -lm" >&5
16856 echo $ECHO_N "checking for log10 in -lm... $ECHO_C" >&6
16857 if test "${ac_cv_lib_m_log10+set}" = set; then
16858   echo $ECHO_N "(cached) $ECHO_C" >&6
16859 else
16860   ac_check_lib_save_LIBS=$LIBS
16861 LIBS="-lm  $LIBS"
16862 if test x$gcc_no_link = xyes; then
16863   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16864 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16865    { (exit 1); exit 1; }; }
16866 fi
16867 cat >conftest.$ac_ext <<_ACEOF
16868 /* confdefs.h.  */
16869 _ACEOF
16870 cat confdefs.h >>conftest.$ac_ext
16871 cat >>conftest.$ac_ext <<_ACEOF
16872 /* end confdefs.h.  */
16873
16874 /* Override any gcc2 internal prototype to avoid an error.  */
16875 #ifdef __cplusplus
16876 extern "C"
16877 #endif
16878 /* We use char because int might match the return type of a gcc2
16879    builtin and then its argument prototype would still apply.  */
16880 char log10 ();
16881 int
16882 main ()
16883 {
16884 log10 ();
16885   ;
16886   return 0;
16887 }
16888 _ACEOF
16889 rm -f conftest.$ac_objext conftest$ac_exeext
16890 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16891   (eval $ac_link) 2>conftest.er1
16892   ac_status=$?
16893   grep -v '^ *+' conftest.er1 >conftest.err
16894   rm -f conftest.er1
16895   cat conftest.err >&5
16896   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16897   (exit $ac_status); } &&
16898          { ac_try='test -z "$ac_c_werror_flag"
16899                          || test ! -s conftest.err'
16900   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16901   (eval $ac_try) 2>&5
16902   ac_status=$?
16903   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16904   (exit $ac_status); }; } &&
16905          { ac_try='test -s conftest$ac_exeext'
16906   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16907   (eval $ac_try) 2>&5
16908   ac_status=$?
16909   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16910   (exit $ac_status); }; }; then
16911   ac_cv_lib_m_log10=yes
16912 else
16913   echo "$as_me: failed program was:" >&5
16914 sed 's/^/| /' conftest.$ac_ext >&5
16915
16916 ac_cv_lib_m_log10=no
16917 fi
16918 rm -f conftest.err conftest.$ac_objext \
16919       conftest$ac_exeext conftest.$ac_ext
16920 LIBS=$ac_check_lib_save_LIBS
16921 fi
16922 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10" >&5
16923 echo "${ECHO_T}$ac_cv_lib_m_log10" >&6
16924 if test $ac_cv_lib_m_log10 = yes; then
16925
16926 cat >>confdefs.h <<\_ACEOF
16927 #define HAVE_LOG10 1
16928 _ACEOF
16929
16930 fi
16931
16932 echo "$as_me:$LINENO: checking for log10l in -lm" >&5
16933 echo $ECHO_N "checking for log10l in -lm... $ECHO_C" >&6
16934 if test "${ac_cv_lib_m_log10l+set}" = set; then
16935   echo $ECHO_N "(cached) $ECHO_C" >&6
16936 else
16937   ac_check_lib_save_LIBS=$LIBS
16938 LIBS="-lm  $LIBS"
16939 if test x$gcc_no_link = xyes; then
16940   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16941 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16942    { (exit 1); exit 1; }; }
16943 fi
16944 cat >conftest.$ac_ext <<_ACEOF
16945 /* confdefs.h.  */
16946 _ACEOF
16947 cat confdefs.h >>conftest.$ac_ext
16948 cat >>conftest.$ac_ext <<_ACEOF
16949 /* end confdefs.h.  */
16950
16951 /* Override any gcc2 internal prototype to avoid an error.  */
16952 #ifdef __cplusplus
16953 extern "C"
16954 #endif
16955 /* We use char because int might match the return type of a gcc2
16956    builtin and then its argument prototype would still apply.  */
16957 char log10l ();
16958 int
16959 main ()
16960 {
16961 log10l ();
16962   ;
16963   return 0;
16964 }
16965 _ACEOF
16966 rm -f conftest.$ac_objext conftest$ac_exeext
16967 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16968   (eval $ac_link) 2>conftest.er1
16969   ac_status=$?
16970   grep -v '^ *+' conftest.er1 >conftest.err
16971   rm -f conftest.er1
16972   cat conftest.err >&5
16973   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16974   (exit $ac_status); } &&
16975          { ac_try='test -z "$ac_c_werror_flag"
16976                          || test ! -s conftest.err'
16977   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16978   (eval $ac_try) 2>&5
16979   ac_status=$?
16980   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16981   (exit $ac_status); }; } &&
16982          { ac_try='test -s conftest$ac_exeext'
16983   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16984   (eval $ac_try) 2>&5
16985   ac_status=$?
16986   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16987   (exit $ac_status); }; }; then
16988   ac_cv_lib_m_log10l=yes
16989 else
16990   echo "$as_me: failed program was:" >&5
16991 sed 's/^/| /' conftest.$ac_ext >&5
16992
16993 ac_cv_lib_m_log10l=no
16994 fi
16995 rm -f conftest.err conftest.$ac_objext \
16996       conftest$ac_exeext conftest.$ac_ext
16997 LIBS=$ac_check_lib_save_LIBS
16998 fi
16999 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10l" >&5
17000 echo "${ECHO_T}$ac_cv_lib_m_log10l" >&6
17001 if test $ac_cv_lib_m_log10l = yes; then
17002
17003 cat >>confdefs.h <<\_ACEOF
17004 #define HAVE_LOG10L 1
17005 _ACEOF
17006
17007 fi
17008
17009 echo "$as_me:$LINENO: checking for clog10f in -lm" >&5
17010 echo $ECHO_N "checking for clog10f in -lm... $ECHO_C" >&6
17011 if test "${ac_cv_lib_m_clog10f+set}" = set; then
17012   echo $ECHO_N "(cached) $ECHO_C" >&6
17013 else
17014   ac_check_lib_save_LIBS=$LIBS
17015 LIBS="-lm  $LIBS"
17016 if test x$gcc_no_link = xyes; then
17017   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17018 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17019    { (exit 1); exit 1; }; }
17020 fi
17021 cat >conftest.$ac_ext <<_ACEOF
17022 /* confdefs.h.  */
17023 _ACEOF
17024 cat confdefs.h >>conftest.$ac_ext
17025 cat >>conftest.$ac_ext <<_ACEOF
17026 /* end confdefs.h.  */
17027
17028 /* Override any gcc2 internal prototype to avoid an error.  */
17029 #ifdef __cplusplus
17030 extern "C"
17031 #endif
17032 /* We use char because int might match the return type of a gcc2
17033    builtin and then its argument prototype would still apply.  */
17034 char clog10f ();
17035 int
17036 main ()
17037 {
17038 clog10f ();
17039   ;
17040   return 0;
17041 }
17042 _ACEOF
17043 rm -f conftest.$ac_objext conftest$ac_exeext
17044 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17045   (eval $ac_link) 2>conftest.er1
17046   ac_status=$?
17047   grep -v '^ *+' conftest.er1 >conftest.err
17048   rm -f conftest.er1
17049   cat conftest.err >&5
17050   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17051   (exit $ac_status); } &&
17052          { ac_try='test -z "$ac_c_werror_flag"
17053                          || test ! -s conftest.err'
17054   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17055   (eval $ac_try) 2>&5
17056   ac_status=$?
17057   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17058   (exit $ac_status); }; } &&
17059          { ac_try='test -s conftest$ac_exeext'
17060   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17061   (eval $ac_try) 2>&5
17062   ac_status=$?
17063   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17064   (exit $ac_status); }; }; then
17065   ac_cv_lib_m_clog10f=yes
17066 else
17067   echo "$as_me: failed program was:" >&5
17068 sed 's/^/| /' conftest.$ac_ext >&5
17069
17070 ac_cv_lib_m_clog10f=no
17071 fi
17072 rm -f conftest.err conftest.$ac_objext \
17073       conftest$ac_exeext conftest.$ac_ext
17074 LIBS=$ac_check_lib_save_LIBS
17075 fi
17076 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10f" >&5
17077 echo "${ECHO_T}$ac_cv_lib_m_clog10f" >&6
17078 if test $ac_cv_lib_m_clog10f = yes; then
17079
17080 cat >>confdefs.h <<\_ACEOF
17081 #define HAVE_CLOG10F 1
17082 _ACEOF
17083
17084 fi
17085
17086 echo "$as_me:$LINENO: checking for clog10 in -lm" >&5
17087 echo $ECHO_N "checking for clog10 in -lm... $ECHO_C" >&6
17088 if test "${ac_cv_lib_m_clog10+set}" = set; then
17089   echo $ECHO_N "(cached) $ECHO_C" >&6
17090 else
17091   ac_check_lib_save_LIBS=$LIBS
17092 LIBS="-lm  $LIBS"
17093 if test x$gcc_no_link = xyes; then
17094   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17095 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17096    { (exit 1); exit 1; }; }
17097 fi
17098 cat >conftest.$ac_ext <<_ACEOF
17099 /* confdefs.h.  */
17100 _ACEOF
17101 cat confdefs.h >>conftest.$ac_ext
17102 cat >>conftest.$ac_ext <<_ACEOF
17103 /* end confdefs.h.  */
17104
17105 /* Override any gcc2 internal prototype to avoid an error.  */
17106 #ifdef __cplusplus
17107 extern "C"
17108 #endif
17109 /* We use char because int might match the return type of a gcc2
17110    builtin and then its argument prototype would still apply.  */
17111 char clog10 ();
17112 int
17113 main ()
17114 {
17115 clog10 ();
17116   ;
17117   return 0;
17118 }
17119 _ACEOF
17120 rm -f conftest.$ac_objext conftest$ac_exeext
17121 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17122   (eval $ac_link) 2>conftest.er1
17123   ac_status=$?
17124   grep -v '^ *+' conftest.er1 >conftest.err
17125   rm -f conftest.er1
17126   cat conftest.err >&5
17127   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17128   (exit $ac_status); } &&
17129          { ac_try='test -z "$ac_c_werror_flag"
17130                          || test ! -s conftest.err'
17131   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17132   (eval $ac_try) 2>&5
17133   ac_status=$?
17134   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17135   (exit $ac_status); }; } &&
17136          { ac_try='test -s conftest$ac_exeext'
17137   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17138   (eval $ac_try) 2>&5
17139   ac_status=$?
17140   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17141   (exit $ac_status); }; }; then
17142   ac_cv_lib_m_clog10=yes
17143 else
17144   echo "$as_me: failed program was:" >&5
17145 sed 's/^/| /' conftest.$ac_ext >&5
17146
17147 ac_cv_lib_m_clog10=no
17148 fi
17149 rm -f conftest.err conftest.$ac_objext \
17150       conftest$ac_exeext conftest.$ac_ext
17151 LIBS=$ac_check_lib_save_LIBS
17152 fi
17153 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10" >&5
17154 echo "${ECHO_T}$ac_cv_lib_m_clog10" >&6
17155 if test $ac_cv_lib_m_clog10 = yes; then
17156
17157 cat >>confdefs.h <<\_ACEOF
17158 #define HAVE_CLOG10 1
17159 _ACEOF
17160
17161 fi
17162
17163 echo "$as_me:$LINENO: checking for clog10l in -lm" >&5
17164 echo $ECHO_N "checking for clog10l in -lm... $ECHO_C" >&6
17165 if test "${ac_cv_lib_m_clog10l+set}" = set; then
17166   echo $ECHO_N "(cached) $ECHO_C" >&6
17167 else
17168   ac_check_lib_save_LIBS=$LIBS
17169 LIBS="-lm  $LIBS"
17170 if test x$gcc_no_link = xyes; then
17171   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17172 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17173    { (exit 1); exit 1; }; }
17174 fi
17175 cat >conftest.$ac_ext <<_ACEOF
17176 /* confdefs.h.  */
17177 _ACEOF
17178 cat confdefs.h >>conftest.$ac_ext
17179 cat >>conftest.$ac_ext <<_ACEOF
17180 /* end confdefs.h.  */
17181
17182 /* Override any gcc2 internal prototype to avoid an error.  */
17183 #ifdef __cplusplus
17184 extern "C"
17185 #endif
17186 /* We use char because int might match the return type of a gcc2
17187    builtin and then its argument prototype would still apply.  */
17188 char clog10l ();
17189 int
17190 main ()
17191 {
17192 clog10l ();
17193   ;
17194   return 0;
17195 }
17196 _ACEOF
17197 rm -f conftest.$ac_objext conftest$ac_exeext
17198 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17199   (eval $ac_link) 2>conftest.er1
17200   ac_status=$?
17201   grep -v '^ *+' conftest.er1 >conftest.err
17202   rm -f conftest.er1
17203   cat conftest.err >&5
17204   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17205   (exit $ac_status); } &&
17206          { ac_try='test -z "$ac_c_werror_flag"
17207                          || test ! -s conftest.err'
17208   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17209   (eval $ac_try) 2>&5
17210   ac_status=$?
17211   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17212   (exit $ac_status); }; } &&
17213          { ac_try='test -s conftest$ac_exeext'
17214   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17215   (eval $ac_try) 2>&5
17216   ac_status=$?
17217   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17218   (exit $ac_status); }; }; then
17219   ac_cv_lib_m_clog10l=yes
17220 else
17221   echo "$as_me: failed program was:" >&5
17222 sed 's/^/| /' conftest.$ac_ext >&5
17223
17224 ac_cv_lib_m_clog10l=no
17225 fi
17226 rm -f conftest.err conftest.$ac_objext \
17227       conftest$ac_exeext conftest.$ac_ext
17228 LIBS=$ac_check_lib_save_LIBS
17229 fi
17230 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10l" >&5
17231 echo "${ECHO_T}$ac_cv_lib_m_clog10l" >&6
17232 if test $ac_cv_lib_m_clog10l = yes; then
17233
17234 cat >>confdefs.h <<\_ACEOF
17235 #define HAVE_CLOG10L 1
17236 _ACEOF
17237
17238 fi
17239
17240 echo "$as_me:$LINENO: checking for nextafterf in -lm" >&5
17241 echo $ECHO_N "checking for nextafterf in -lm... $ECHO_C" >&6
17242 if test "${ac_cv_lib_m_nextafterf+set}" = set; then
17243   echo $ECHO_N "(cached) $ECHO_C" >&6
17244 else
17245   ac_check_lib_save_LIBS=$LIBS
17246 LIBS="-lm  $LIBS"
17247 if test x$gcc_no_link = xyes; then
17248   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17249 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17250    { (exit 1); exit 1; }; }
17251 fi
17252 cat >conftest.$ac_ext <<_ACEOF
17253 /* confdefs.h.  */
17254 _ACEOF
17255 cat confdefs.h >>conftest.$ac_ext
17256 cat >>conftest.$ac_ext <<_ACEOF
17257 /* end confdefs.h.  */
17258
17259 /* Override any gcc2 internal prototype to avoid an error.  */
17260 #ifdef __cplusplus
17261 extern "C"
17262 #endif
17263 /* We use char because int might match the return type of a gcc2
17264    builtin and then its argument prototype would still apply.  */
17265 char nextafterf ();
17266 int
17267 main ()
17268 {
17269 nextafterf ();
17270   ;
17271   return 0;
17272 }
17273 _ACEOF
17274 rm -f conftest.$ac_objext conftest$ac_exeext
17275 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17276   (eval $ac_link) 2>conftest.er1
17277   ac_status=$?
17278   grep -v '^ *+' conftest.er1 >conftest.err
17279   rm -f conftest.er1
17280   cat conftest.err >&5
17281   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17282   (exit $ac_status); } &&
17283          { ac_try='test -z "$ac_c_werror_flag"
17284                          || test ! -s conftest.err'
17285   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17286   (eval $ac_try) 2>&5
17287   ac_status=$?
17288   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17289   (exit $ac_status); }; } &&
17290          { ac_try='test -s conftest$ac_exeext'
17291   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17292   (eval $ac_try) 2>&5
17293   ac_status=$?
17294   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17295   (exit $ac_status); }; }; then
17296   ac_cv_lib_m_nextafterf=yes
17297 else
17298   echo "$as_me: failed program was:" >&5
17299 sed 's/^/| /' conftest.$ac_ext >&5
17300
17301 ac_cv_lib_m_nextafterf=no
17302 fi
17303 rm -f conftest.err conftest.$ac_objext \
17304       conftest$ac_exeext conftest.$ac_ext
17305 LIBS=$ac_check_lib_save_LIBS
17306 fi
17307 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafterf" >&5
17308 echo "${ECHO_T}$ac_cv_lib_m_nextafterf" >&6
17309 if test $ac_cv_lib_m_nextafterf = yes; then
17310
17311 cat >>confdefs.h <<\_ACEOF
17312 #define HAVE_NEXTAFTERF 1
17313 _ACEOF
17314
17315 fi
17316
17317 echo "$as_me:$LINENO: checking for nextafter in -lm" >&5
17318 echo $ECHO_N "checking for nextafter in -lm... $ECHO_C" >&6
17319 if test "${ac_cv_lib_m_nextafter+set}" = set; then
17320   echo $ECHO_N "(cached) $ECHO_C" >&6
17321 else
17322   ac_check_lib_save_LIBS=$LIBS
17323 LIBS="-lm  $LIBS"
17324 if test x$gcc_no_link = xyes; then
17325   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17326 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17327    { (exit 1); exit 1; }; }
17328 fi
17329 cat >conftest.$ac_ext <<_ACEOF
17330 /* confdefs.h.  */
17331 _ACEOF
17332 cat confdefs.h >>conftest.$ac_ext
17333 cat >>conftest.$ac_ext <<_ACEOF
17334 /* end confdefs.h.  */
17335
17336 /* Override any gcc2 internal prototype to avoid an error.  */
17337 #ifdef __cplusplus
17338 extern "C"
17339 #endif
17340 /* We use char because int might match the return type of a gcc2
17341    builtin and then its argument prototype would still apply.  */
17342 char nextafter ();
17343 int
17344 main ()
17345 {
17346 nextafter ();
17347   ;
17348   return 0;
17349 }
17350 _ACEOF
17351 rm -f conftest.$ac_objext conftest$ac_exeext
17352 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17353   (eval $ac_link) 2>conftest.er1
17354   ac_status=$?
17355   grep -v '^ *+' conftest.er1 >conftest.err
17356   rm -f conftest.er1
17357   cat conftest.err >&5
17358   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17359   (exit $ac_status); } &&
17360          { ac_try='test -z "$ac_c_werror_flag"
17361                          || test ! -s conftest.err'
17362   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17363   (eval $ac_try) 2>&5
17364   ac_status=$?
17365   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17366   (exit $ac_status); }; } &&
17367          { ac_try='test -s conftest$ac_exeext'
17368   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17369   (eval $ac_try) 2>&5
17370   ac_status=$?
17371   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17372   (exit $ac_status); }; }; then
17373   ac_cv_lib_m_nextafter=yes
17374 else
17375   echo "$as_me: failed program was:" >&5
17376 sed 's/^/| /' conftest.$ac_ext >&5
17377
17378 ac_cv_lib_m_nextafter=no
17379 fi
17380 rm -f conftest.err conftest.$ac_objext \
17381       conftest$ac_exeext conftest.$ac_ext
17382 LIBS=$ac_check_lib_save_LIBS
17383 fi
17384 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafter" >&5
17385 echo "${ECHO_T}$ac_cv_lib_m_nextafter" >&6
17386 if test $ac_cv_lib_m_nextafter = yes; then
17387
17388 cat >>confdefs.h <<\_ACEOF
17389 #define HAVE_NEXTAFTER 1
17390 _ACEOF
17391
17392 fi
17393
17394 echo "$as_me:$LINENO: checking for nextafterl in -lm" >&5
17395 echo $ECHO_N "checking for nextafterl in -lm... $ECHO_C" >&6
17396 if test "${ac_cv_lib_m_nextafterl+set}" = set; then
17397   echo $ECHO_N "(cached) $ECHO_C" >&6
17398 else
17399   ac_check_lib_save_LIBS=$LIBS
17400 LIBS="-lm  $LIBS"
17401 if test x$gcc_no_link = xyes; then
17402   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17403 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17404    { (exit 1); exit 1; }; }
17405 fi
17406 cat >conftest.$ac_ext <<_ACEOF
17407 /* confdefs.h.  */
17408 _ACEOF
17409 cat confdefs.h >>conftest.$ac_ext
17410 cat >>conftest.$ac_ext <<_ACEOF
17411 /* end confdefs.h.  */
17412
17413 /* Override any gcc2 internal prototype to avoid an error.  */
17414 #ifdef __cplusplus
17415 extern "C"
17416 #endif
17417 /* We use char because int might match the return type of a gcc2
17418    builtin and then its argument prototype would still apply.  */
17419 char nextafterl ();
17420 int
17421 main ()
17422 {
17423 nextafterl ();
17424   ;
17425   return 0;
17426 }
17427 _ACEOF
17428 rm -f conftest.$ac_objext conftest$ac_exeext
17429 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17430   (eval $ac_link) 2>conftest.er1
17431   ac_status=$?
17432   grep -v '^ *+' conftest.er1 >conftest.err
17433   rm -f conftest.er1
17434   cat conftest.err >&5
17435   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17436   (exit $ac_status); } &&
17437          { ac_try='test -z "$ac_c_werror_flag"
17438                          || test ! -s conftest.err'
17439   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17440   (eval $ac_try) 2>&5
17441   ac_status=$?
17442   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17443   (exit $ac_status); }; } &&
17444          { ac_try='test -s conftest$ac_exeext'
17445   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17446   (eval $ac_try) 2>&5
17447   ac_status=$?
17448   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17449   (exit $ac_status); }; }; then
17450   ac_cv_lib_m_nextafterl=yes
17451 else
17452   echo "$as_me: failed program was:" >&5
17453 sed 's/^/| /' conftest.$ac_ext >&5
17454
17455 ac_cv_lib_m_nextafterl=no
17456 fi
17457 rm -f conftest.err conftest.$ac_objext \
17458       conftest$ac_exeext conftest.$ac_ext
17459 LIBS=$ac_check_lib_save_LIBS
17460 fi
17461 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafterl" >&5
17462 echo "${ECHO_T}$ac_cv_lib_m_nextafterl" >&6
17463 if test $ac_cv_lib_m_nextafterl = yes; then
17464
17465 cat >>confdefs.h <<\_ACEOF
17466 #define HAVE_NEXTAFTERL 1
17467 _ACEOF
17468
17469 fi
17470
17471 echo "$as_me:$LINENO: checking for powf in -lm" >&5
17472 echo $ECHO_N "checking for powf in -lm... $ECHO_C" >&6
17473 if test "${ac_cv_lib_m_powf+set}" = set; then
17474   echo $ECHO_N "(cached) $ECHO_C" >&6
17475 else
17476   ac_check_lib_save_LIBS=$LIBS
17477 LIBS="-lm  $LIBS"
17478 if test x$gcc_no_link = xyes; then
17479   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17480 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17481    { (exit 1); exit 1; }; }
17482 fi
17483 cat >conftest.$ac_ext <<_ACEOF
17484 /* confdefs.h.  */
17485 _ACEOF
17486 cat confdefs.h >>conftest.$ac_ext
17487 cat >>conftest.$ac_ext <<_ACEOF
17488 /* end confdefs.h.  */
17489
17490 /* Override any gcc2 internal prototype to avoid an error.  */
17491 #ifdef __cplusplus
17492 extern "C"
17493 #endif
17494 /* We use char because int might match the return type of a gcc2
17495    builtin and then its argument prototype would still apply.  */
17496 char powf ();
17497 int
17498 main ()
17499 {
17500 powf ();
17501   ;
17502   return 0;
17503 }
17504 _ACEOF
17505 rm -f conftest.$ac_objext conftest$ac_exeext
17506 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17507   (eval $ac_link) 2>conftest.er1
17508   ac_status=$?
17509   grep -v '^ *+' conftest.er1 >conftest.err
17510   rm -f conftest.er1
17511   cat conftest.err >&5
17512   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17513   (exit $ac_status); } &&
17514          { ac_try='test -z "$ac_c_werror_flag"
17515                          || test ! -s conftest.err'
17516   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17517   (eval $ac_try) 2>&5
17518   ac_status=$?
17519   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17520   (exit $ac_status); }; } &&
17521          { ac_try='test -s conftest$ac_exeext'
17522   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17523   (eval $ac_try) 2>&5
17524   ac_status=$?
17525   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17526   (exit $ac_status); }; }; then
17527   ac_cv_lib_m_powf=yes
17528 else
17529   echo "$as_me: failed program was:" >&5
17530 sed 's/^/| /' conftest.$ac_ext >&5
17531
17532 ac_cv_lib_m_powf=no
17533 fi
17534 rm -f conftest.err conftest.$ac_objext \
17535       conftest$ac_exeext conftest.$ac_ext
17536 LIBS=$ac_check_lib_save_LIBS
17537 fi
17538 echo "$as_me:$LINENO: result: $ac_cv_lib_m_powf" >&5
17539 echo "${ECHO_T}$ac_cv_lib_m_powf" >&6
17540 if test $ac_cv_lib_m_powf = yes; then
17541
17542 cat >>confdefs.h <<\_ACEOF
17543 #define HAVE_POWF 1
17544 _ACEOF
17545
17546 fi
17547
17548 echo "$as_me:$LINENO: checking for pow in -lm" >&5
17549 echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
17550 if test "${ac_cv_lib_m_pow+set}" = set; then
17551   echo $ECHO_N "(cached) $ECHO_C" >&6
17552 else
17553   ac_check_lib_save_LIBS=$LIBS
17554 LIBS="-lm  $LIBS"
17555 if test x$gcc_no_link = xyes; then
17556   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17557 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17558    { (exit 1); exit 1; }; }
17559 fi
17560 cat >conftest.$ac_ext <<_ACEOF
17561 /* confdefs.h.  */
17562 _ACEOF
17563 cat confdefs.h >>conftest.$ac_ext
17564 cat >>conftest.$ac_ext <<_ACEOF
17565 /* end confdefs.h.  */
17566
17567 /* Override any gcc2 internal prototype to avoid an error.  */
17568 #ifdef __cplusplus
17569 extern "C"
17570 #endif
17571 /* We use char because int might match the return type of a gcc2
17572    builtin and then its argument prototype would still apply.  */
17573 char pow ();
17574 int
17575 main ()
17576 {
17577 pow ();
17578   ;
17579   return 0;
17580 }
17581 _ACEOF
17582 rm -f conftest.$ac_objext conftest$ac_exeext
17583 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17584   (eval $ac_link) 2>conftest.er1
17585   ac_status=$?
17586   grep -v '^ *+' conftest.er1 >conftest.err
17587   rm -f conftest.er1
17588   cat conftest.err >&5
17589   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17590   (exit $ac_status); } &&
17591          { ac_try='test -z "$ac_c_werror_flag"
17592                          || test ! -s conftest.err'
17593   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17594   (eval $ac_try) 2>&5
17595   ac_status=$?
17596   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17597   (exit $ac_status); }; } &&
17598          { ac_try='test -s conftest$ac_exeext'
17599   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17600   (eval $ac_try) 2>&5
17601   ac_status=$?
17602   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17603   (exit $ac_status); }; }; then
17604   ac_cv_lib_m_pow=yes
17605 else
17606   echo "$as_me: failed program was:" >&5
17607 sed 's/^/| /' conftest.$ac_ext >&5
17608
17609 ac_cv_lib_m_pow=no
17610 fi
17611 rm -f conftest.err conftest.$ac_objext \
17612       conftest$ac_exeext conftest.$ac_ext
17613 LIBS=$ac_check_lib_save_LIBS
17614 fi
17615 echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
17616 echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
17617 if test $ac_cv_lib_m_pow = yes; then
17618
17619 cat >>confdefs.h <<\_ACEOF
17620 #define HAVE_POW 1
17621 _ACEOF
17622
17623 fi
17624
17625 echo "$as_me:$LINENO: checking for powl in -lm" >&5
17626 echo $ECHO_N "checking for powl in -lm... $ECHO_C" >&6
17627 if test "${ac_cv_lib_m_powl+set}" = set; then
17628   echo $ECHO_N "(cached) $ECHO_C" >&6
17629 else
17630   ac_check_lib_save_LIBS=$LIBS
17631 LIBS="-lm  $LIBS"
17632 if test x$gcc_no_link = xyes; then
17633   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17634 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17635    { (exit 1); exit 1; }; }
17636 fi
17637 cat >conftest.$ac_ext <<_ACEOF
17638 /* confdefs.h.  */
17639 _ACEOF
17640 cat confdefs.h >>conftest.$ac_ext
17641 cat >>conftest.$ac_ext <<_ACEOF
17642 /* end confdefs.h.  */
17643
17644 /* Override any gcc2 internal prototype to avoid an error.  */
17645 #ifdef __cplusplus
17646 extern "C"
17647 #endif
17648 /* We use char because int might match the return type of a gcc2
17649    builtin and then its argument prototype would still apply.  */
17650 char powl ();
17651 int
17652 main ()
17653 {
17654 powl ();
17655   ;
17656   return 0;
17657 }
17658 _ACEOF
17659 rm -f conftest.$ac_objext conftest$ac_exeext
17660 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17661   (eval $ac_link) 2>conftest.er1
17662   ac_status=$?
17663   grep -v '^ *+' conftest.er1 >conftest.err
17664   rm -f conftest.er1
17665   cat conftest.err >&5
17666   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17667   (exit $ac_status); } &&
17668          { ac_try='test -z "$ac_c_werror_flag"
17669                          || test ! -s conftest.err'
17670   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17671   (eval $ac_try) 2>&5
17672   ac_status=$?
17673   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17674   (exit $ac_status); }; } &&
17675          { ac_try='test -s conftest$ac_exeext'
17676   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17677   (eval $ac_try) 2>&5
17678   ac_status=$?
17679   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17680   (exit $ac_status); }; }; then
17681   ac_cv_lib_m_powl=yes
17682 else
17683   echo "$as_me: failed program was:" >&5
17684 sed 's/^/| /' conftest.$ac_ext >&5
17685
17686 ac_cv_lib_m_powl=no
17687 fi
17688 rm -f conftest.err conftest.$ac_objext \
17689       conftest$ac_exeext conftest.$ac_ext
17690 LIBS=$ac_check_lib_save_LIBS
17691 fi
17692 echo "$as_me:$LINENO: result: $ac_cv_lib_m_powl" >&5
17693 echo "${ECHO_T}$ac_cv_lib_m_powl" >&6
17694 if test $ac_cv_lib_m_powl = yes; then
17695
17696 cat >>confdefs.h <<\_ACEOF
17697 #define HAVE_POWL 1
17698 _ACEOF
17699
17700 fi
17701
17702 echo "$as_me:$LINENO: checking for cpowf in -lm" >&5
17703 echo $ECHO_N "checking for cpowf in -lm... $ECHO_C" >&6
17704 if test "${ac_cv_lib_m_cpowf+set}" = set; then
17705   echo $ECHO_N "(cached) $ECHO_C" >&6
17706 else
17707   ac_check_lib_save_LIBS=$LIBS
17708 LIBS="-lm  $LIBS"
17709 if test x$gcc_no_link = xyes; then
17710   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17711 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17712    { (exit 1); exit 1; }; }
17713 fi
17714 cat >conftest.$ac_ext <<_ACEOF
17715 /* confdefs.h.  */
17716 _ACEOF
17717 cat confdefs.h >>conftest.$ac_ext
17718 cat >>conftest.$ac_ext <<_ACEOF
17719 /* end confdefs.h.  */
17720
17721 /* Override any gcc2 internal prototype to avoid an error.  */
17722 #ifdef __cplusplus
17723 extern "C"
17724 #endif
17725 /* We use char because int might match the return type of a gcc2
17726    builtin and then its argument prototype would still apply.  */
17727 char cpowf ();
17728 int
17729 main ()
17730 {
17731 cpowf ();
17732   ;
17733   return 0;
17734 }
17735 _ACEOF
17736 rm -f conftest.$ac_objext conftest$ac_exeext
17737 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17738   (eval $ac_link) 2>conftest.er1
17739   ac_status=$?
17740   grep -v '^ *+' conftest.er1 >conftest.err
17741   rm -f conftest.er1
17742   cat conftest.err >&5
17743   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17744   (exit $ac_status); } &&
17745          { ac_try='test -z "$ac_c_werror_flag"
17746                          || test ! -s conftest.err'
17747   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17748   (eval $ac_try) 2>&5
17749   ac_status=$?
17750   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17751   (exit $ac_status); }; } &&
17752          { ac_try='test -s conftest$ac_exeext'
17753   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17754   (eval $ac_try) 2>&5
17755   ac_status=$?
17756   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17757   (exit $ac_status); }; }; then
17758   ac_cv_lib_m_cpowf=yes
17759 else
17760   echo "$as_me: failed program was:" >&5
17761 sed 's/^/| /' conftest.$ac_ext >&5
17762
17763 ac_cv_lib_m_cpowf=no
17764 fi
17765 rm -f conftest.err conftest.$ac_objext \
17766       conftest$ac_exeext conftest.$ac_ext
17767 LIBS=$ac_check_lib_save_LIBS
17768 fi
17769 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpowf" >&5
17770 echo "${ECHO_T}$ac_cv_lib_m_cpowf" >&6
17771 if test $ac_cv_lib_m_cpowf = yes; then
17772
17773 cat >>confdefs.h <<\_ACEOF
17774 #define HAVE_CPOWF 1
17775 _ACEOF
17776
17777 fi
17778
17779 echo "$as_me:$LINENO: checking for cpow in -lm" >&5
17780 echo $ECHO_N "checking for cpow in -lm... $ECHO_C" >&6
17781 if test "${ac_cv_lib_m_cpow+set}" = set; then
17782   echo $ECHO_N "(cached) $ECHO_C" >&6
17783 else
17784   ac_check_lib_save_LIBS=$LIBS
17785 LIBS="-lm  $LIBS"
17786 if test x$gcc_no_link = xyes; then
17787   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17788 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17789    { (exit 1); exit 1; }; }
17790 fi
17791 cat >conftest.$ac_ext <<_ACEOF
17792 /* confdefs.h.  */
17793 _ACEOF
17794 cat confdefs.h >>conftest.$ac_ext
17795 cat >>conftest.$ac_ext <<_ACEOF
17796 /* end confdefs.h.  */
17797
17798 /* Override any gcc2 internal prototype to avoid an error.  */
17799 #ifdef __cplusplus
17800 extern "C"
17801 #endif
17802 /* We use char because int might match the return type of a gcc2
17803    builtin and then its argument prototype would still apply.  */
17804 char cpow ();
17805 int
17806 main ()
17807 {
17808 cpow ();
17809   ;
17810   return 0;
17811 }
17812 _ACEOF
17813 rm -f conftest.$ac_objext conftest$ac_exeext
17814 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17815   (eval $ac_link) 2>conftest.er1
17816   ac_status=$?
17817   grep -v '^ *+' conftest.er1 >conftest.err
17818   rm -f conftest.er1
17819   cat conftest.err >&5
17820   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17821   (exit $ac_status); } &&
17822          { ac_try='test -z "$ac_c_werror_flag"
17823                          || test ! -s conftest.err'
17824   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17825   (eval $ac_try) 2>&5
17826   ac_status=$?
17827   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17828   (exit $ac_status); }; } &&
17829          { ac_try='test -s conftest$ac_exeext'
17830   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17831   (eval $ac_try) 2>&5
17832   ac_status=$?
17833   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17834   (exit $ac_status); }; }; then
17835   ac_cv_lib_m_cpow=yes
17836 else
17837   echo "$as_me: failed program was:" >&5
17838 sed 's/^/| /' conftest.$ac_ext >&5
17839
17840 ac_cv_lib_m_cpow=no
17841 fi
17842 rm -f conftest.err conftest.$ac_objext \
17843       conftest$ac_exeext conftest.$ac_ext
17844 LIBS=$ac_check_lib_save_LIBS
17845 fi
17846 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpow" >&5
17847 echo "${ECHO_T}$ac_cv_lib_m_cpow" >&6
17848 if test $ac_cv_lib_m_cpow = yes; then
17849
17850 cat >>confdefs.h <<\_ACEOF
17851 #define HAVE_CPOW 1
17852 _ACEOF
17853
17854 fi
17855
17856 echo "$as_me:$LINENO: checking for cpowl in -lm" >&5
17857 echo $ECHO_N "checking for cpowl in -lm... $ECHO_C" >&6
17858 if test "${ac_cv_lib_m_cpowl+set}" = set; then
17859   echo $ECHO_N "(cached) $ECHO_C" >&6
17860 else
17861   ac_check_lib_save_LIBS=$LIBS
17862 LIBS="-lm  $LIBS"
17863 if test x$gcc_no_link = xyes; then
17864   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17865 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17866    { (exit 1); exit 1; }; }
17867 fi
17868 cat >conftest.$ac_ext <<_ACEOF
17869 /* confdefs.h.  */
17870 _ACEOF
17871 cat confdefs.h >>conftest.$ac_ext
17872 cat >>conftest.$ac_ext <<_ACEOF
17873 /* end confdefs.h.  */
17874
17875 /* Override any gcc2 internal prototype to avoid an error.  */
17876 #ifdef __cplusplus
17877 extern "C"
17878 #endif
17879 /* We use char because int might match the return type of a gcc2
17880    builtin and then its argument prototype would still apply.  */
17881 char cpowl ();
17882 int
17883 main ()
17884 {
17885 cpowl ();
17886   ;
17887   return 0;
17888 }
17889 _ACEOF
17890 rm -f conftest.$ac_objext conftest$ac_exeext
17891 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17892   (eval $ac_link) 2>conftest.er1
17893   ac_status=$?
17894   grep -v '^ *+' conftest.er1 >conftest.err
17895   rm -f conftest.er1
17896   cat conftest.err >&5
17897   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17898   (exit $ac_status); } &&
17899          { ac_try='test -z "$ac_c_werror_flag"
17900                          || test ! -s conftest.err'
17901   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17902   (eval $ac_try) 2>&5
17903   ac_status=$?
17904   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17905   (exit $ac_status); }; } &&
17906          { ac_try='test -s conftest$ac_exeext'
17907   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17908   (eval $ac_try) 2>&5
17909   ac_status=$?
17910   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17911   (exit $ac_status); }; }; then
17912   ac_cv_lib_m_cpowl=yes
17913 else
17914   echo "$as_me: failed program was:" >&5
17915 sed 's/^/| /' conftest.$ac_ext >&5
17916
17917 ac_cv_lib_m_cpowl=no
17918 fi
17919 rm -f conftest.err conftest.$ac_objext \
17920       conftest$ac_exeext conftest.$ac_ext
17921 LIBS=$ac_check_lib_save_LIBS
17922 fi
17923 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpowl" >&5
17924 echo "${ECHO_T}$ac_cv_lib_m_cpowl" >&6
17925 if test $ac_cv_lib_m_cpowl = yes; then
17926
17927 cat >>confdefs.h <<\_ACEOF
17928 #define HAVE_CPOWL 1
17929 _ACEOF
17930
17931 fi
17932
17933 echo "$as_me:$LINENO: checking for roundf in -lm" >&5
17934 echo $ECHO_N "checking for roundf in -lm... $ECHO_C" >&6
17935 if test "${ac_cv_lib_m_roundf+set}" = set; then
17936   echo $ECHO_N "(cached) $ECHO_C" >&6
17937 else
17938   ac_check_lib_save_LIBS=$LIBS
17939 LIBS="-lm  $LIBS"
17940 if test x$gcc_no_link = xyes; then
17941   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17942 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17943    { (exit 1); exit 1; }; }
17944 fi
17945 cat >conftest.$ac_ext <<_ACEOF
17946 /* confdefs.h.  */
17947 _ACEOF
17948 cat confdefs.h >>conftest.$ac_ext
17949 cat >>conftest.$ac_ext <<_ACEOF
17950 /* end confdefs.h.  */
17951
17952 /* Override any gcc2 internal prototype to avoid an error.  */
17953 #ifdef __cplusplus
17954 extern "C"
17955 #endif
17956 /* We use char because int might match the return type of a gcc2
17957    builtin and then its argument prototype would still apply.  */
17958 char roundf ();
17959 int
17960 main ()
17961 {
17962 roundf ();
17963   ;
17964   return 0;
17965 }
17966 _ACEOF
17967 rm -f conftest.$ac_objext conftest$ac_exeext
17968 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17969   (eval $ac_link) 2>conftest.er1
17970   ac_status=$?
17971   grep -v '^ *+' conftest.er1 >conftest.err
17972   rm -f conftest.er1
17973   cat conftest.err >&5
17974   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17975   (exit $ac_status); } &&
17976          { ac_try='test -z "$ac_c_werror_flag"
17977                          || test ! -s conftest.err'
17978   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17979   (eval $ac_try) 2>&5
17980   ac_status=$?
17981   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17982   (exit $ac_status); }; } &&
17983          { ac_try='test -s conftest$ac_exeext'
17984   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17985   (eval $ac_try) 2>&5
17986   ac_status=$?
17987   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17988   (exit $ac_status); }; }; then
17989   ac_cv_lib_m_roundf=yes
17990 else
17991   echo "$as_me: failed program was:" >&5
17992 sed 's/^/| /' conftest.$ac_ext >&5
17993
17994 ac_cv_lib_m_roundf=no
17995 fi
17996 rm -f conftest.err conftest.$ac_objext \
17997       conftest$ac_exeext conftest.$ac_ext
17998 LIBS=$ac_check_lib_save_LIBS
17999 fi
18000 echo "$as_me:$LINENO: result: $ac_cv_lib_m_roundf" >&5
18001 echo "${ECHO_T}$ac_cv_lib_m_roundf" >&6
18002 if test $ac_cv_lib_m_roundf = yes; then
18003
18004 cat >>confdefs.h <<\_ACEOF
18005 #define HAVE_ROUNDF 1
18006 _ACEOF
18007
18008 fi
18009
18010 echo "$as_me:$LINENO: checking for round in -lm" >&5
18011 echo $ECHO_N "checking for round in -lm... $ECHO_C" >&6
18012 if test "${ac_cv_lib_m_round+set}" = set; then
18013   echo $ECHO_N "(cached) $ECHO_C" >&6
18014 else
18015   ac_check_lib_save_LIBS=$LIBS
18016 LIBS="-lm  $LIBS"
18017 if test x$gcc_no_link = xyes; then
18018   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18019 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18020    { (exit 1); exit 1; }; }
18021 fi
18022 cat >conftest.$ac_ext <<_ACEOF
18023 /* confdefs.h.  */
18024 _ACEOF
18025 cat confdefs.h >>conftest.$ac_ext
18026 cat >>conftest.$ac_ext <<_ACEOF
18027 /* end confdefs.h.  */
18028
18029 /* Override any gcc2 internal prototype to avoid an error.  */
18030 #ifdef __cplusplus
18031 extern "C"
18032 #endif
18033 /* We use char because int might match the return type of a gcc2
18034    builtin and then its argument prototype would still apply.  */
18035 char round ();
18036 int
18037 main ()
18038 {
18039 round ();
18040   ;
18041   return 0;
18042 }
18043 _ACEOF
18044 rm -f conftest.$ac_objext conftest$ac_exeext
18045 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18046   (eval $ac_link) 2>conftest.er1
18047   ac_status=$?
18048   grep -v '^ *+' conftest.er1 >conftest.err
18049   rm -f conftest.er1
18050   cat conftest.err >&5
18051   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18052   (exit $ac_status); } &&
18053          { ac_try='test -z "$ac_c_werror_flag"
18054                          || test ! -s conftest.err'
18055   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18056   (eval $ac_try) 2>&5
18057   ac_status=$?
18058   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18059   (exit $ac_status); }; } &&
18060          { ac_try='test -s conftest$ac_exeext'
18061   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18062   (eval $ac_try) 2>&5
18063   ac_status=$?
18064   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18065   (exit $ac_status); }; }; then
18066   ac_cv_lib_m_round=yes
18067 else
18068   echo "$as_me: failed program was:" >&5
18069 sed 's/^/| /' conftest.$ac_ext >&5
18070
18071 ac_cv_lib_m_round=no
18072 fi
18073 rm -f conftest.err conftest.$ac_objext \
18074       conftest$ac_exeext conftest.$ac_ext
18075 LIBS=$ac_check_lib_save_LIBS
18076 fi
18077 echo "$as_me:$LINENO: result: $ac_cv_lib_m_round" >&5
18078 echo "${ECHO_T}$ac_cv_lib_m_round" >&6
18079 if test $ac_cv_lib_m_round = yes; then
18080
18081 cat >>confdefs.h <<\_ACEOF
18082 #define HAVE_ROUND 1
18083 _ACEOF
18084
18085 fi
18086
18087 echo "$as_me:$LINENO: checking for roundl in -lm" >&5
18088 echo $ECHO_N "checking for roundl in -lm... $ECHO_C" >&6
18089 if test "${ac_cv_lib_m_roundl+set}" = set; then
18090   echo $ECHO_N "(cached) $ECHO_C" >&6
18091 else
18092   ac_check_lib_save_LIBS=$LIBS
18093 LIBS="-lm  $LIBS"
18094 if test x$gcc_no_link = xyes; then
18095   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18096 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18097    { (exit 1); exit 1; }; }
18098 fi
18099 cat >conftest.$ac_ext <<_ACEOF
18100 /* confdefs.h.  */
18101 _ACEOF
18102 cat confdefs.h >>conftest.$ac_ext
18103 cat >>conftest.$ac_ext <<_ACEOF
18104 /* end confdefs.h.  */
18105
18106 /* Override any gcc2 internal prototype to avoid an error.  */
18107 #ifdef __cplusplus
18108 extern "C"
18109 #endif
18110 /* We use char because int might match the return type of a gcc2
18111    builtin and then its argument prototype would still apply.  */
18112 char roundl ();
18113 int
18114 main ()
18115 {
18116 roundl ();
18117   ;
18118   return 0;
18119 }
18120 _ACEOF
18121 rm -f conftest.$ac_objext conftest$ac_exeext
18122 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18123   (eval $ac_link) 2>conftest.er1
18124   ac_status=$?
18125   grep -v '^ *+' conftest.er1 >conftest.err
18126   rm -f conftest.er1
18127   cat conftest.err >&5
18128   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18129   (exit $ac_status); } &&
18130          { ac_try='test -z "$ac_c_werror_flag"
18131                          || test ! -s conftest.err'
18132   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18133   (eval $ac_try) 2>&5
18134   ac_status=$?
18135   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18136   (exit $ac_status); }; } &&
18137          { ac_try='test -s conftest$ac_exeext'
18138   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18139   (eval $ac_try) 2>&5
18140   ac_status=$?
18141   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18142   (exit $ac_status); }; }; then
18143   ac_cv_lib_m_roundl=yes
18144 else
18145   echo "$as_me: failed program was:" >&5
18146 sed 's/^/| /' conftest.$ac_ext >&5
18147
18148 ac_cv_lib_m_roundl=no
18149 fi
18150 rm -f conftest.err conftest.$ac_objext \
18151       conftest$ac_exeext conftest.$ac_ext
18152 LIBS=$ac_check_lib_save_LIBS
18153 fi
18154 echo "$as_me:$LINENO: result: $ac_cv_lib_m_roundl" >&5
18155 echo "${ECHO_T}$ac_cv_lib_m_roundl" >&6
18156 if test $ac_cv_lib_m_roundl = yes; then
18157
18158 cat >>confdefs.h <<\_ACEOF
18159 #define HAVE_ROUNDL 1
18160 _ACEOF
18161
18162 fi
18163
18164 echo "$as_me:$LINENO: checking for scalbnf in -lm" >&5
18165 echo $ECHO_N "checking for scalbnf in -lm... $ECHO_C" >&6
18166 if test "${ac_cv_lib_m_scalbnf+set}" = set; then
18167   echo $ECHO_N "(cached) $ECHO_C" >&6
18168 else
18169   ac_check_lib_save_LIBS=$LIBS
18170 LIBS="-lm  $LIBS"
18171 if test x$gcc_no_link = xyes; then
18172   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18173 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18174    { (exit 1); exit 1; }; }
18175 fi
18176 cat >conftest.$ac_ext <<_ACEOF
18177 /* confdefs.h.  */
18178 _ACEOF
18179 cat confdefs.h >>conftest.$ac_ext
18180 cat >>conftest.$ac_ext <<_ACEOF
18181 /* end confdefs.h.  */
18182
18183 /* Override any gcc2 internal prototype to avoid an error.  */
18184 #ifdef __cplusplus
18185 extern "C"
18186 #endif
18187 /* We use char because int might match the return type of a gcc2
18188    builtin and then its argument prototype would still apply.  */
18189 char scalbnf ();
18190 int
18191 main ()
18192 {
18193 scalbnf ();
18194   ;
18195   return 0;
18196 }
18197 _ACEOF
18198 rm -f conftest.$ac_objext conftest$ac_exeext
18199 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18200   (eval $ac_link) 2>conftest.er1
18201   ac_status=$?
18202   grep -v '^ *+' conftest.er1 >conftest.err
18203   rm -f conftest.er1
18204   cat conftest.err >&5
18205   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18206   (exit $ac_status); } &&
18207          { ac_try='test -z "$ac_c_werror_flag"
18208                          || test ! -s conftest.err'
18209   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18210   (eval $ac_try) 2>&5
18211   ac_status=$?
18212   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18213   (exit $ac_status); }; } &&
18214          { ac_try='test -s conftest$ac_exeext'
18215   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18216   (eval $ac_try) 2>&5
18217   ac_status=$?
18218   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18219   (exit $ac_status); }; }; then
18220   ac_cv_lib_m_scalbnf=yes
18221 else
18222   echo "$as_me: failed program was:" >&5
18223 sed 's/^/| /' conftest.$ac_ext >&5
18224
18225 ac_cv_lib_m_scalbnf=no
18226 fi
18227 rm -f conftest.err conftest.$ac_objext \
18228       conftest$ac_exeext conftest.$ac_ext
18229 LIBS=$ac_check_lib_save_LIBS
18230 fi
18231 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbnf" >&5
18232 echo "${ECHO_T}$ac_cv_lib_m_scalbnf" >&6
18233 if test $ac_cv_lib_m_scalbnf = yes; then
18234
18235 cat >>confdefs.h <<\_ACEOF
18236 #define HAVE_SCALBNF 1
18237 _ACEOF
18238
18239 fi
18240
18241 echo "$as_me:$LINENO: checking for scalbn in -lm" >&5
18242 echo $ECHO_N "checking for scalbn in -lm... $ECHO_C" >&6
18243 if test "${ac_cv_lib_m_scalbn+set}" = set; then
18244   echo $ECHO_N "(cached) $ECHO_C" >&6
18245 else
18246   ac_check_lib_save_LIBS=$LIBS
18247 LIBS="-lm  $LIBS"
18248 if test x$gcc_no_link = xyes; then
18249   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18250 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18251    { (exit 1); exit 1; }; }
18252 fi
18253 cat >conftest.$ac_ext <<_ACEOF
18254 /* confdefs.h.  */
18255 _ACEOF
18256 cat confdefs.h >>conftest.$ac_ext
18257 cat >>conftest.$ac_ext <<_ACEOF
18258 /* end confdefs.h.  */
18259
18260 /* Override any gcc2 internal prototype to avoid an error.  */
18261 #ifdef __cplusplus
18262 extern "C"
18263 #endif
18264 /* We use char because int might match the return type of a gcc2
18265    builtin and then its argument prototype would still apply.  */
18266 char scalbn ();
18267 int
18268 main ()
18269 {
18270 scalbn ();
18271   ;
18272   return 0;
18273 }
18274 _ACEOF
18275 rm -f conftest.$ac_objext conftest$ac_exeext
18276 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18277   (eval $ac_link) 2>conftest.er1
18278   ac_status=$?
18279   grep -v '^ *+' conftest.er1 >conftest.err
18280   rm -f conftest.er1
18281   cat conftest.err >&5
18282   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18283   (exit $ac_status); } &&
18284          { ac_try='test -z "$ac_c_werror_flag"
18285                          || test ! -s conftest.err'
18286   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18287   (eval $ac_try) 2>&5
18288   ac_status=$?
18289   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18290   (exit $ac_status); }; } &&
18291          { ac_try='test -s conftest$ac_exeext'
18292   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18293   (eval $ac_try) 2>&5
18294   ac_status=$?
18295   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18296   (exit $ac_status); }; }; then
18297   ac_cv_lib_m_scalbn=yes
18298 else
18299   echo "$as_me: failed program was:" >&5
18300 sed 's/^/| /' conftest.$ac_ext >&5
18301
18302 ac_cv_lib_m_scalbn=no
18303 fi
18304 rm -f conftest.err conftest.$ac_objext \
18305       conftest$ac_exeext conftest.$ac_ext
18306 LIBS=$ac_check_lib_save_LIBS
18307 fi
18308 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbn" >&5
18309 echo "${ECHO_T}$ac_cv_lib_m_scalbn" >&6
18310 if test $ac_cv_lib_m_scalbn = yes; then
18311
18312 cat >>confdefs.h <<\_ACEOF
18313 #define HAVE_SCALBN 1
18314 _ACEOF
18315
18316 fi
18317
18318 echo "$as_me:$LINENO: checking for scalbnl in -lm" >&5
18319 echo $ECHO_N "checking for scalbnl in -lm... $ECHO_C" >&6
18320 if test "${ac_cv_lib_m_scalbnl+set}" = set; then
18321   echo $ECHO_N "(cached) $ECHO_C" >&6
18322 else
18323   ac_check_lib_save_LIBS=$LIBS
18324 LIBS="-lm  $LIBS"
18325 if test x$gcc_no_link = xyes; then
18326   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18327 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18328    { (exit 1); exit 1; }; }
18329 fi
18330 cat >conftest.$ac_ext <<_ACEOF
18331 /* confdefs.h.  */
18332 _ACEOF
18333 cat confdefs.h >>conftest.$ac_ext
18334 cat >>conftest.$ac_ext <<_ACEOF
18335 /* end confdefs.h.  */
18336
18337 /* Override any gcc2 internal prototype to avoid an error.  */
18338 #ifdef __cplusplus
18339 extern "C"
18340 #endif
18341 /* We use char because int might match the return type of a gcc2
18342    builtin and then its argument prototype would still apply.  */
18343 char scalbnl ();
18344 int
18345 main ()
18346 {
18347 scalbnl ();
18348   ;
18349   return 0;
18350 }
18351 _ACEOF
18352 rm -f conftest.$ac_objext conftest$ac_exeext
18353 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18354   (eval $ac_link) 2>conftest.er1
18355   ac_status=$?
18356   grep -v '^ *+' conftest.er1 >conftest.err
18357   rm -f conftest.er1
18358   cat conftest.err >&5
18359   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18360   (exit $ac_status); } &&
18361          { ac_try='test -z "$ac_c_werror_flag"
18362                          || test ! -s conftest.err'
18363   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18364   (eval $ac_try) 2>&5
18365   ac_status=$?
18366   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18367   (exit $ac_status); }; } &&
18368          { ac_try='test -s conftest$ac_exeext'
18369   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18370   (eval $ac_try) 2>&5
18371   ac_status=$?
18372   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18373   (exit $ac_status); }; }; then
18374   ac_cv_lib_m_scalbnl=yes
18375 else
18376   echo "$as_me: failed program was:" >&5
18377 sed 's/^/| /' conftest.$ac_ext >&5
18378
18379 ac_cv_lib_m_scalbnl=no
18380 fi
18381 rm -f conftest.err conftest.$ac_objext \
18382       conftest$ac_exeext conftest.$ac_ext
18383 LIBS=$ac_check_lib_save_LIBS
18384 fi
18385 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbnl" >&5
18386 echo "${ECHO_T}$ac_cv_lib_m_scalbnl" >&6
18387 if test $ac_cv_lib_m_scalbnl = yes; then
18388
18389 cat >>confdefs.h <<\_ACEOF
18390 #define HAVE_SCALBNL 1
18391 _ACEOF
18392
18393 fi
18394
18395 echo "$as_me:$LINENO: checking for sinf in -lm" >&5
18396 echo $ECHO_N "checking for sinf in -lm... $ECHO_C" >&6
18397 if test "${ac_cv_lib_m_sinf+set}" = set; then
18398   echo $ECHO_N "(cached) $ECHO_C" >&6
18399 else
18400   ac_check_lib_save_LIBS=$LIBS
18401 LIBS="-lm  $LIBS"
18402 if test x$gcc_no_link = xyes; then
18403   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18404 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18405    { (exit 1); exit 1; }; }
18406 fi
18407 cat >conftest.$ac_ext <<_ACEOF
18408 /* confdefs.h.  */
18409 _ACEOF
18410 cat confdefs.h >>conftest.$ac_ext
18411 cat >>conftest.$ac_ext <<_ACEOF
18412 /* end confdefs.h.  */
18413
18414 /* Override any gcc2 internal prototype to avoid an error.  */
18415 #ifdef __cplusplus
18416 extern "C"
18417 #endif
18418 /* We use char because int might match the return type of a gcc2
18419    builtin and then its argument prototype would still apply.  */
18420 char sinf ();
18421 int
18422 main ()
18423 {
18424 sinf ();
18425   ;
18426   return 0;
18427 }
18428 _ACEOF
18429 rm -f conftest.$ac_objext conftest$ac_exeext
18430 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18431   (eval $ac_link) 2>conftest.er1
18432   ac_status=$?
18433   grep -v '^ *+' conftest.er1 >conftest.err
18434   rm -f conftest.er1
18435   cat conftest.err >&5
18436   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18437   (exit $ac_status); } &&
18438          { ac_try='test -z "$ac_c_werror_flag"
18439                          || test ! -s conftest.err'
18440   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18441   (eval $ac_try) 2>&5
18442   ac_status=$?
18443   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18444   (exit $ac_status); }; } &&
18445          { ac_try='test -s conftest$ac_exeext'
18446   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18447   (eval $ac_try) 2>&5
18448   ac_status=$?
18449   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18450   (exit $ac_status); }; }; then
18451   ac_cv_lib_m_sinf=yes
18452 else
18453   echo "$as_me: failed program was:" >&5
18454 sed 's/^/| /' conftest.$ac_ext >&5
18455
18456 ac_cv_lib_m_sinf=no
18457 fi
18458 rm -f conftest.err conftest.$ac_objext \
18459       conftest$ac_exeext conftest.$ac_ext
18460 LIBS=$ac_check_lib_save_LIBS
18461 fi
18462 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinf" >&5
18463 echo "${ECHO_T}$ac_cv_lib_m_sinf" >&6
18464 if test $ac_cv_lib_m_sinf = yes; then
18465
18466 cat >>confdefs.h <<\_ACEOF
18467 #define HAVE_SINF 1
18468 _ACEOF
18469
18470 fi
18471
18472 echo "$as_me:$LINENO: checking for sin in -lm" >&5
18473 echo $ECHO_N "checking for sin in -lm... $ECHO_C" >&6
18474 if test "${ac_cv_lib_m_sin+set}" = set; then
18475   echo $ECHO_N "(cached) $ECHO_C" >&6
18476 else
18477   ac_check_lib_save_LIBS=$LIBS
18478 LIBS="-lm  $LIBS"
18479 if test x$gcc_no_link = xyes; then
18480   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18481 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18482    { (exit 1); exit 1; }; }
18483 fi
18484 cat >conftest.$ac_ext <<_ACEOF
18485 /* confdefs.h.  */
18486 _ACEOF
18487 cat confdefs.h >>conftest.$ac_ext
18488 cat >>conftest.$ac_ext <<_ACEOF
18489 /* end confdefs.h.  */
18490
18491 /* Override any gcc2 internal prototype to avoid an error.  */
18492 #ifdef __cplusplus
18493 extern "C"
18494 #endif
18495 /* We use char because int might match the return type of a gcc2
18496    builtin and then its argument prototype would still apply.  */
18497 char sin ();
18498 int
18499 main ()
18500 {
18501 sin ();
18502   ;
18503   return 0;
18504 }
18505 _ACEOF
18506 rm -f conftest.$ac_objext conftest$ac_exeext
18507 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18508   (eval $ac_link) 2>conftest.er1
18509   ac_status=$?
18510   grep -v '^ *+' conftest.er1 >conftest.err
18511   rm -f conftest.er1
18512   cat conftest.err >&5
18513   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18514   (exit $ac_status); } &&
18515          { ac_try='test -z "$ac_c_werror_flag"
18516                          || test ! -s conftest.err'
18517   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18518   (eval $ac_try) 2>&5
18519   ac_status=$?
18520   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18521   (exit $ac_status); }; } &&
18522          { ac_try='test -s conftest$ac_exeext'
18523   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18524   (eval $ac_try) 2>&5
18525   ac_status=$?
18526   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18527   (exit $ac_status); }; }; then
18528   ac_cv_lib_m_sin=yes
18529 else
18530   echo "$as_me: failed program was:" >&5
18531 sed 's/^/| /' conftest.$ac_ext >&5
18532
18533 ac_cv_lib_m_sin=no
18534 fi
18535 rm -f conftest.err conftest.$ac_objext \
18536       conftest$ac_exeext conftest.$ac_ext
18537 LIBS=$ac_check_lib_save_LIBS
18538 fi
18539 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sin" >&5
18540 echo "${ECHO_T}$ac_cv_lib_m_sin" >&6
18541 if test $ac_cv_lib_m_sin = yes; then
18542
18543 cat >>confdefs.h <<\_ACEOF
18544 #define HAVE_SIN 1
18545 _ACEOF
18546
18547 fi
18548
18549 echo "$as_me:$LINENO: checking for sinl in -lm" >&5
18550 echo $ECHO_N "checking for sinl in -lm... $ECHO_C" >&6
18551 if test "${ac_cv_lib_m_sinl+set}" = set; then
18552   echo $ECHO_N "(cached) $ECHO_C" >&6
18553 else
18554   ac_check_lib_save_LIBS=$LIBS
18555 LIBS="-lm  $LIBS"
18556 if test x$gcc_no_link = xyes; then
18557   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18558 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18559    { (exit 1); exit 1; }; }
18560 fi
18561 cat >conftest.$ac_ext <<_ACEOF
18562 /* confdefs.h.  */
18563 _ACEOF
18564 cat confdefs.h >>conftest.$ac_ext
18565 cat >>conftest.$ac_ext <<_ACEOF
18566 /* end confdefs.h.  */
18567
18568 /* Override any gcc2 internal prototype to avoid an error.  */
18569 #ifdef __cplusplus
18570 extern "C"
18571 #endif
18572 /* We use char because int might match the return type of a gcc2
18573    builtin and then its argument prototype would still apply.  */
18574 char sinl ();
18575 int
18576 main ()
18577 {
18578 sinl ();
18579   ;
18580   return 0;
18581 }
18582 _ACEOF
18583 rm -f conftest.$ac_objext conftest$ac_exeext
18584 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18585   (eval $ac_link) 2>conftest.er1
18586   ac_status=$?
18587   grep -v '^ *+' conftest.er1 >conftest.err
18588   rm -f conftest.er1
18589   cat conftest.err >&5
18590   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18591   (exit $ac_status); } &&
18592          { ac_try='test -z "$ac_c_werror_flag"
18593                          || test ! -s conftest.err'
18594   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18595   (eval $ac_try) 2>&5
18596   ac_status=$?
18597   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18598   (exit $ac_status); }; } &&
18599          { ac_try='test -s conftest$ac_exeext'
18600   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18601   (eval $ac_try) 2>&5
18602   ac_status=$?
18603   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18604   (exit $ac_status); }; }; then
18605   ac_cv_lib_m_sinl=yes
18606 else
18607   echo "$as_me: failed program was:" >&5
18608 sed 's/^/| /' conftest.$ac_ext >&5
18609
18610 ac_cv_lib_m_sinl=no
18611 fi
18612 rm -f conftest.err conftest.$ac_objext \
18613       conftest$ac_exeext conftest.$ac_ext
18614 LIBS=$ac_check_lib_save_LIBS
18615 fi
18616 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinl" >&5
18617 echo "${ECHO_T}$ac_cv_lib_m_sinl" >&6
18618 if test $ac_cv_lib_m_sinl = yes; then
18619
18620 cat >>confdefs.h <<\_ACEOF
18621 #define HAVE_SINL 1
18622 _ACEOF
18623
18624 fi
18625
18626 echo "$as_me:$LINENO: checking for csinf in -lm" >&5
18627 echo $ECHO_N "checking for csinf in -lm... $ECHO_C" >&6
18628 if test "${ac_cv_lib_m_csinf+set}" = set; then
18629   echo $ECHO_N "(cached) $ECHO_C" >&6
18630 else
18631   ac_check_lib_save_LIBS=$LIBS
18632 LIBS="-lm  $LIBS"
18633 if test x$gcc_no_link = xyes; then
18634   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18635 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18636    { (exit 1); exit 1; }; }
18637 fi
18638 cat >conftest.$ac_ext <<_ACEOF
18639 /* confdefs.h.  */
18640 _ACEOF
18641 cat confdefs.h >>conftest.$ac_ext
18642 cat >>conftest.$ac_ext <<_ACEOF
18643 /* end confdefs.h.  */
18644
18645 /* Override any gcc2 internal prototype to avoid an error.  */
18646 #ifdef __cplusplus
18647 extern "C"
18648 #endif
18649 /* We use char because int might match the return type of a gcc2
18650    builtin and then its argument prototype would still apply.  */
18651 char csinf ();
18652 int
18653 main ()
18654 {
18655 csinf ();
18656   ;
18657   return 0;
18658 }
18659 _ACEOF
18660 rm -f conftest.$ac_objext conftest$ac_exeext
18661 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18662   (eval $ac_link) 2>conftest.er1
18663   ac_status=$?
18664   grep -v '^ *+' conftest.er1 >conftest.err
18665   rm -f conftest.er1
18666   cat conftest.err >&5
18667   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18668   (exit $ac_status); } &&
18669          { ac_try='test -z "$ac_c_werror_flag"
18670                          || test ! -s conftest.err'
18671   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18672   (eval $ac_try) 2>&5
18673   ac_status=$?
18674   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18675   (exit $ac_status); }; } &&
18676          { ac_try='test -s conftest$ac_exeext'
18677   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18678   (eval $ac_try) 2>&5
18679   ac_status=$?
18680   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18681   (exit $ac_status); }; }; then
18682   ac_cv_lib_m_csinf=yes
18683 else
18684   echo "$as_me: failed program was:" >&5
18685 sed 's/^/| /' conftest.$ac_ext >&5
18686
18687 ac_cv_lib_m_csinf=no
18688 fi
18689 rm -f conftest.err conftest.$ac_objext \
18690       conftest$ac_exeext conftest.$ac_ext
18691 LIBS=$ac_check_lib_save_LIBS
18692 fi
18693 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinf" >&5
18694 echo "${ECHO_T}$ac_cv_lib_m_csinf" >&6
18695 if test $ac_cv_lib_m_csinf = yes; then
18696
18697 cat >>confdefs.h <<\_ACEOF
18698 #define HAVE_CSINF 1
18699 _ACEOF
18700
18701 fi
18702
18703 echo "$as_me:$LINENO: checking for csin in -lm" >&5
18704 echo $ECHO_N "checking for csin in -lm... $ECHO_C" >&6
18705 if test "${ac_cv_lib_m_csin+set}" = set; then
18706   echo $ECHO_N "(cached) $ECHO_C" >&6
18707 else
18708   ac_check_lib_save_LIBS=$LIBS
18709 LIBS="-lm  $LIBS"
18710 if test x$gcc_no_link = xyes; then
18711   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18712 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18713    { (exit 1); exit 1; }; }
18714 fi
18715 cat >conftest.$ac_ext <<_ACEOF
18716 /* confdefs.h.  */
18717 _ACEOF
18718 cat confdefs.h >>conftest.$ac_ext
18719 cat >>conftest.$ac_ext <<_ACEOF
18720 /* end confdefs.h.  */
18721
18722 /* Override any gcc2 internal prototype to avoid an error.  */
18723 #ifdef __cplusplus
18724 extern "C"
18725 #endif
18726 /* We use char because int might match the return type of a gcc2
18727    builtin and then its argument prototype would still apply.  */
18728 char csin ();
18729 int
18730 main ()
18731 {
18732 csin ();
18733   ;
18734   return 0;
18735 }
18736 _ACEOF
18737 rm -f conftest.$ac_objext conftest$ac_exeext
18738 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18739   (eval $ac_link) 2>conftest.er1
18740   ac_status=$?
18741   grep -v '^ *+' conftest.er1 >conftest.err
18742   rm -f conftest.er1
18743   cat conftest.err >&5
18744   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18745   (exit $ac_status); } &&
18746          { ac_try='test -z "$ac_c_werror_flag"
18747                          || test ! -s conftest.err'
18748   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18749   (eval $ac_try) 2>&5
18750   ac_status=$?
18751   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18752   (exit $ac_status); }; } &&
18753          { ac_try='test -s conftest$ac_exeext'
18754   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18755   (eval $ac_try) 2>&5
18756   ac_status=$?
18757   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18758   (exit $ac_status); }; }; then
18759   ac_cv_lib_m_csin=yes
18760 else
18761   echo "$as_me: failed program was:" >&5
18762 sed 's/^/| /' conftest.$ac_ext >&5
18763
18764 ac_cv_lib_m_csin=no
18765 fi
18766 rm -f conftest.err conftest.$ac_objext \
18767       conftest$ac_exeext conftest.$ac_ext
18768 LIBS=$ac_check_lib_save_LIBS
18769 fi
18770 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csin" >&5
18771 echo "${ECHO_T}$ac_cv_lib_m_csin" >&6
18772 if test $ac_cv_lib_m_csin = yes; then
18773
18774 cat >>confdefs.h <<\_ACEOF
18775 #define HAVE_CSIN 1
18776 _ACEOF
18777
18778 fi
18779
18780 echo "$as_me:$LINENO: checking for csinl in -lm" >&5
18781 echo $ECHO_N "checking for csinl in -lm... $ECHO_C" >&6
18782 if test "${ac_cv_lib_m_csinl+set}" = set; then
18783   echo $ECHO_N "(cached) $ECHO_C" >&6
18784 else
18785   ac_check_lib_save_LIBS=$LIBS
18786 LIBS="-lm  $LIBS"
18787 if test x$gcc_no_link = xyes; then
18788   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18789 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18790    { (exit 1); exit 1; }; }
18791 fi
18792 cat >conftest.$ac_ext <<_ACEOF
18793 /* confdefs.h.  */
18794 _ACEOF
18795 cat confdefs.h >>conftest.$ac_ext
18796 cat >>conftest.$ac_ext <<_ACEOF
18797 /* end confdefs.h.  */
18798
18799 /* Override any gcc2 internal prototype to avoid an error.  */
18800 #ifdef __cplusplus
18801 extern "C"
18802 #endif
18803 /* We use char because int might match the return type of a gcc2
18804    builtin and then its argument prototype would still apply.  */
18805 char csinl ();
18806 int
18807 main ()
18808 {
18809 csinl ();
18810   ;
18811   return 0;
18812 }
18813 _ACEOF
18814 rm -f conftest.$ac_objext conftest$ac_exeext
18815 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18816   (eval $ac_link) 2>conftest.er1
18817   ac_status=$?
18818   grep -v '^ *+' conftest.er1 >conftest.err
18819   rm -f conftest.er1
18820   cat conftest.err >&5
18821   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18822   (exit $ac_status); } &&
18823          { ac_try='test -z "$ac_c_werror_flag"
18824                          || test ! -s conftest.err'
18825   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18826   (eval $ac_try) 2>&5
18827   ac_status=$?
18828   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18829   (exit $ac_status); }; } &&
18830          { ac_try='test -s conftest$ac_exeext'
18831   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18832   (eval $ac_try) 2>&5
18833   ac_status=$?
18834   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18835   (exit $ac_status); }; }; then
18836   ac_cv_lib_m_csinl=yes
18837 else
18838   echo "$as_me: failed program was:" >&5
18839 sed 's/^/| /' conftest.$ac_ext >&5
18840
18841 ac_cv_lib_m_csinl=no
18842 fi
18843 rm -f conftest.err conftest.$ac_objext \
18844       conftest$ac_exeext conftest.$ac_ext
18845 LIBS=$ac_check_lib_save_LIBS
18846 fi
18847 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinl" >&5
18848 echo "${ECHO_T}$ac_cv_lib_m_csinl" >&6
18849 if test $ac_cv_lib_m_csinl = yes; then
18850
18851 cat >>confdefs.h <<\_ACEOF
18852 #define HAVE_CSINL 1
18853 _ACEOF
18854
18855 fi
18856
18857 echo "$as_me:$LINENO: checking for sinhf in -lm" >&5
18858 echo $ECHO_N "checking for sinhf in -lm... $ECHO_C" >&6
18859 if test "${ac_cv_lib_m_sinhf+set}" = set; then
18860   echo $ECHO_N "(cached) $ECHO_C" >&6
18861 else
18862   ac_check_lib_save_LIBS=$LIBS
18863 LIBS="-lm  $LIBS"
18864 if test x$gcc_no_link = xyes; then
18865   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18866 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18867    { (exit 1); exit 1; }; }
18868 fi
18869 cat >conftest.$ac_ext <<_ACEOF
18870 /* confdefs.h.  */
18871 _ACEOF
18872 cat confdefs.h >>conftest.$ac_ext
18873 cat >>conftest.$ac_ext <<_ACEOF
18874 /* end confdefs.h.  */
18875
18876 /* Override any gcc2 internal prototype to avoid an error.  */
18877 #ifdef __cplusplus
18878 extern "C"
18879 #endif
18880 /* We use char because int might match the return type of a gcc2
18881    builtin and then its argument prototype would still apply.  */
18882 char sinhf ();
18883 int
18884 main ()
18885 {
18886 sinhf ();
18887   ;
18888   return 0;
18889 }
18890 _ACEOF
18891 rm -f conftest.$ac_objext conftest$ac_exeext
18892 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18893   (eval $ac_link) 2>conftest.er1
18894   ac_status=$?
18895   grep -v '^ *+' conftest.er1 >conftest.err
18896   rm -f conftest.er1
18897   cat conftest.err >&5
18898   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18899   (exit $ac_status); } &&
18900          { ac_try='test -z "$ac_c_werror_flag"
18901                          || test ! -s conftest.err'
18902   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18903   (eval $ac_try) 2>&5
18904   ac_status=$?
18905   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18906   (exit $ac_status); }; } &&
18907          { ac_try='test -s conftest$ac_exeext'
18908   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18909   (eval $ac_try) 2>&5
18910   ac_status=$?
18911   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18912   (exit $ac_status); }; }; then
18913   ac_cv_lib_m_sinhf=yes
18914 else
18915   echo "$as_me: failed program was:" >&5
18916 sed 's/^/| /' conftest.$ac_ext >&5
18917
18918 ac_cv_lib_m_sinhf=no
18919 fi
18920 rm -f conftest.err conftest.$ac_objext \
18921       conftest$ac_exeext conftest.$ac_ext
18922 LIBS=$ac_check_lib_save_LIBS
18923 fi
18924 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinhf" >&5
18925 echo "${ECHO_T}$ac_cv_lib_m_sinhf" >&6
18926 if test $ac_cv_lib_m_sinhf = yes; then
18927
18928 cat >>confdefs.h <<\_ACEOF
18929 #define HAVE_SINHF 1
18930 _ACEOF
18931
18932 fi
18933
18934 echo "$as_me:$LINENO: checking for sinh in -lm" >&5
18935 echo $ECHO_N "checking for sinh in -lm... $ECHO_C" >&6
18936 if test "${ac_cv_lib_m_sinh+set}" = set; then
18937   echo $ECHO_N "(cached) $ECHO_C" >&6
18938 else
18939   ac_check_lib_save_LIBS=$LIBS
18940 LIBS="-lm  $LIBS"
18941 if test x$gcc_no_link = xyes; then
18942   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18943 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18944    { (exit 1); exit 1; }; }
18945 fi
18946 cat >conftest.$ac_ext <<_ACEOF
18947 /* confdefs.h.  */
18948 _ACEOF
18949 cat confdefs.h >>conftest.$ac_ext
18950 cat >>conftest.$ac_ext <<_ACEOF
18951 /* end confdefs.h.  */
18952
18953 /* Override any gcc2 internal prototype to avoid an error.  */
18954 #ifdef __cplusplus
18955 extern "C"
18956 #endif
18957 /* We use char because int might match the return type of a gcc2
18958    builtin and then its argument prototype would still apply.  */
18959 char sinh ();
18960 int
18961 main ()
18962 {
18963 sinh ();
18964   ;
18965   return 0;
18966 }
18967 _ACEOF
18968 rm -f conftest.$ac_objext conftest$ac_exeext
18969 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18970   (eval $ac_link) 2>conftest.er1
18971   ac_status=$?
18972   grep -v '^ *+' conftest.er1 >conftest.err
18973   rm -f conftest.er1
18974   cat conftest.err >&5
18975   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18976   (exit $ac_status); } &&
18977          { ac_try='test -z "$ac_c_werror_flag"
18978                          || test ! -s conftest.err'
18979   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18980   (eval $ac_try) 2>&5
18981   ac_status=$?
18982   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18983   (exit $ac_status); }; } &&
18984          { ac_try='test -s conftest$ac_exeext'
18985   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18986   (eval $ac_try) 2>&5
18987   ac_status=$?
18988   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18989   (exit $ac_status); }; }; then
18990   ac_cv_lib_m_sinh=yes
18991 else
18992   echo "$as_me: failed program was:" >&5
18993 sed 's/^/| /' conftest.$ac_ext >&5
18994
18995 ac_cv_lib_m_sinh=no
18996 fi
18997 rm -f conftest.err conftest.$ac_objext \
18998       conftest$ac_exeext conftest.$ac_ext
18999 LIBS=$ac_check_lib_save_LIBS
19000 fi
19001 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinh" >&5
19002 echo "${ECHO_T}$ac_cv_lib_m_sinh" >&6
19003 if test $ac_cv_lib_m_sinh = yes; then
19004
19005 cat >>confdefs.h <<\_ACEOF
19006 #define HAVE_SINH 1
19007 _ACEOF
19008
19009 fi
19010
19011 echo "$as_me:$LINENO: checking for sinhl in -lm" >&5
19012 echo $ECHO_N "checking for sinhl in -lm... $ECHO_C" >&6
19013 if test "${ac_cv_lib_m_sinhl+set}" = set; then
19014   echo $ECHO_N "(cached) $ECHO_C" >&6
19015 else
19016   ac_check_lib_save_LIBS=$LIBS
19017 LIBS="-lm  $LIBS"
19018 if test x$gcc_no_link = xyes; then
19019   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19020 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19021    { (exit 1); exit 1; }; }
19022 fi
19023 cat >conftest.$ac_ext <<_ACEOF
19024 /* confdefs.h.  */
19025 _ACEOF
19026 cat confdefs.h >>conftest.$ac_ext
19027 cat >>conftest.$ac_ext <<_ACEOF
19028 /* end confdefs.h.  */
19029
19030 /* Override any gcc2 internal prototype to avoid an error.  */
19031 #ifdef __cplusplus
19032 extern "C"
19033 #endif
19034 /* We use char because int might match the return type of a gcc2
19035    builtin and then its argument prototype would still apply.  */
19036 char sinhl ();
19037 int
19038 main ()
19039 {
19040 sinhl ();
19041   ;
19042   return 0;
19043 }
19044 _ACEOF
19045 rm -f conftest.$ac_objext conftest$ac_exeext
19046 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19047   (eval $ac_link) 2>conftest.er1
19048   ac_status=$?
19049   grep -v '^ *+' conftest.er1 >conftest.err
19050   rm -f conftest.er1
19051   cat conftest.err >&5
19052   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19053   (exit $ac_status); } &&
19054          { ac_try='test -z "$ac_c_werror_flag"
19055                          || test ! -s conftest.err'
19056   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19057   (eval $ac_try) 2>&5
19058   ac_status=$?
19059   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19060   (exit $ac_status); }; } &&
19061          { ac_try='test -s conftest$ac_exeext'
19062   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19063   (eval $ac_try) 2>&5
19064   ac_status=$?
19065   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19066   (exit $ac_status); }; }; then
19067   ac_cv_lib_m_sinhl=yes
19068 else
19069   echo "$as_me: failed program was:" >&5
19070 sed 's/^/| /' conftest.$ac_ext >&5
19071
19072 ac_cv_lib_m_sinhl=no
19073 fi
19074 rm -f conftest.err conftest.$ac_objext \
19075       conftest$ac_exeext conftest.$ac_ext
19076 LIBS=$ac_check_lib_save_LIBS
19077 fi
19078 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinhl" >&5
19079 echo "${ECHO_T}$ac_cv_lib_m_sinhl" >&6
19080 if test $ac_cv_lib_m_sinhl = yes; then
19081
19082 cat >>confdefs.h <<\_ACEOF
19083 #define HAVE_SINHL 1
19084 _ACEOF
19085
19086 fi
19087
19088 echo "$as_me:$LINENO: checking for csinhf in -lm" >&5
19089 echo $ECHO_N "checking for csinhf in -lm... $ECHO_C" >&6
19090 if test "${ac_cv_lib_m_csinhf+set}" = set; then
19091   echo $ECHO_N "(cached) $ECHO_C" >&6
19092 else
19093   ac_check_lib_save_LIBS=$LIBS
19094 LIBS="-lm  $LIBS"
19095 if test x$gcc_no_link = xyes; then
19096   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19097 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19098    { (exit 1); exit 1; }; }
19099 fi
19100 cat >conftest.$ac_ext <<_ACEOF
19101 /* confdefs.h.  */
19102 _ACEOF
19103 cat confdefs.h >>conftest.$ac_ext
19104 cat >>conftest.$ac_ext <<_ACEOF
19105 /* end confdefs.h.  */
19106
19107 /* Override any gcc2 internal prototype to avoid an error.  */
19108 #ifdef __cplusplus
19109 extern "C"
19110 #endif
19111 /* We use char because int might match the return type of a gcc2
19112    builtin and then its argument prototype would still apply.  */
19113 char csinhf ();
19114 int
19115 main ()
19116 {
19117 csinhf ();
19118   ;
19119   return 0;
19120 }
19121 _ACEOF
19122 rm -f conftest.$ac_objext conftest$ac_exeext
19123 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19124   (eval $ac_link) 2>conftest.er1
19125   ac_status=$?
19126   grep -v '^ *+' conftest.er1 >conftest.err
19127   rm -f conftest.er1
19128   cat conftest.err >&5
19129   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19130   (exit $ac_status); } &&
19131          { ac_try='test -z "$ac_c_werror_flag"
19132                          || test ! -s conftest.err'
19133   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19134   (eval $ac_try) 2>&5
19135   ac_status=$?
19136   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19137   (exit $ac_status); }; } &&
19138          { ac_try='test -s conftest$ac_exeext'
19139   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19140   (eval $ac_try) 2>&5
19141   ac_status=$?
19142   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19143   (exit $ac_status); }; }; then
19144   ac_cv_lib_m_csinhf=yes
19145 else
19146   echo "$as_me: failed program was:" >&5
19147 sed 's/^/| /' conftest.$ac_ext >&5
19148
19149 ac_cv_lib_m_csinhf=no
19150 fi
19151 rm -f conftest.err conftest.$ac_objext \
19152       conftest$ac_exeext conftest.$ac_ext
19153 LIBS=$ac_check_lib_save_LIBS
19154 fi
19155 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinhf" >&5
19156 echo "${ECHO_T}$ac_cv_lib_m_csinhf" >&6
19157 if test $ac_cv_lib_m_csinhf = yes; then
19158
19159 cat >>confdefs.h <<\_ACEOF
19160 #define HAVE_CSINHF 1
19161 _ACEOF
19162
19163 fi
19164
19165 echo "$as_me:$LINENO: checking for csinh in -lm" >&5
19166 echo $ECHO_N "checking for csinh in -lm... $ECHO_C" >&6
19167 if test "${ac_cv_lib_m_csinh+set}" = set; then
19168   echo $ECHO_N "(cached) $ECHO_C" >&6
19169 else
19170   ac_check_lib_save_LIBS=$LIBS
19171 LIBS="-lm  $LIBS"
19172 if test x$gcc_no_link = xyes; then
19173   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19174 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19175    { (exit 1); exit 1; }; }
19176 fi
19177 cat >conftest.$ac_ext <<_ACEOF
19178 /* confdefs.h.  */
19179 _ACEOF
19180 cat confdefs.h >>conftest.$ac_ext
19181 cat >>conftest.$ac_ext <<_ACEOF
19182 /* end confdefs.h.  */
19183
19184 /* Override any gcc2 internal prototype to avoid an error.  */
19185 #ifdef __cplusplus
19186 extern "C"
19187 #endif
19188 /* We use char because int might match the return type of a gcc2
19189    builtin and then its argument prototype would still apply.  */
19190 char csinh ();
19191 int
19192 main ()
19193 {
19194 csinh ();
19195   ;
19196   return 0;
19197 }
19198 _ACEOF
19199 rm -f conftest.$ac_objext conftest$ac_exeext
19200 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19201   (eval $ac_link) 2>conftest.er1
19202   ac_status=$?
19203   grep -v '^ *+' conftest.er1 >conftest.err
19204   rm -f conftest.er1
19205   cat conftest.err >&5
19206   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19207   (exit $ac_status); } &&
19208          { ac_try='test -z "$ac_c_werror_flag"
19209                          || test ! -s conftest.err'
19210   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19211   (eval $ac_try) 2>&5
19212   ac_status=$?
19213   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19214   (exit $ac_status); }; } &&
19215          { ac_try='test -s conftest$ac_exeext'
19216   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19217   (eval $ac_try) 2>&5
19218   ac_status=$?
19219   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19220   (exit $ac_status); }; }; then
19221   ac_cv_lib_m_csinh=yes
19222 else
19223   echo "$as_me: failed program was:" >&5
19224 sed 's/^/| /' conftest.$ac_ext >&5
19225
19226 ac_cv_lib_m_csinh=no
19227 fi
19228 rm -f conftest.err conftest.$ac_objext \
19229       conftest$ac_exeext conftest.$ac_ext
19230 LIBS=$ac_check_lib_save_LIBS
19231 fi
19232 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinh" >&5
19233 echo "${ECHO_T}$ac_cv_lib_m_csinh" >&6
19234 if test $ac_cv_lib_m_csinh = yes; then
19235
19236 cat >>confdefs.h <<\_ACEOF
19237 #define HAVE_CSINH 1
19238 _ACEOF
19239
19240 fi
19241
19242 echo "$as_me:$LINENO: checking for csinhl in -lm" >&5
19243 echo $ECHO_N "checking for csinhl in -lm... $ECHO_C" >&6
19244 if test "${ac_cv_lib_m_csinhl+set}" = set; then
19245   echo $ECHO_N "(cached) $ECHO_C" >&6
19246 else
19247   ac_check_lib_save_LIBS=$LIBS
19248 LIBS="-lm  $LIBS"
19249 if test x$gcc_no_link = xyes; then
19250   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19251 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19252    { (exit 1); exit 1; }; }
19253 fi
19254 cat >conftest.$ac_ext <<_ACEOF
19255 /* confdefs.h.  */
19256 _ACEOF
19257 cat confdefs.h >>conftest.$ac_ext
19258 cat >>conftest.$ac_ext <<_ACEOF
19259 /* end confdefs.h.  */
19260
19261 /* Override any gcc2 internal prototype to avoid an error.  */
19262 #ifdef __cplusplus
19263 extern "C"
19264 #endif
19265 /* We use char because int might match the return type of a gcc2
19266    builtin and then its argument prototype would still apply.  */
19267 char csinhl ();
19268 int
19269 main ()
19270 {
19271 csinhl ();
19272   ;
19273   return 0;
19274 }
19275 _ACEOF
19276 rm -f conftest.$ac_objext conftest$ac_exeext
19277 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19278   (eval $ac_link) 2>conftest.er1
19279   ac_status=$?
19280   grep -v '^ *+' conftest.er1 >conftest.err
19281   rm -f conftest.er1
19282   cat conftest.err >&5
19283   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19284   (exit $ac_status); } &&
19285          { ac_try='test -z "$ac_c_werror_flag"
19286                          || test ! -s conftest.err'
19287   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19288   (eval $ac_try) 2>&5
19289   ac_status=$?
19290   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19291   (exit $ac_status); }; } &&
19292          { ac_try='test -s conftest$ac_exeext'
19293   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19294   (eval $ac_try) 2>&5
19295   ac_status=$?
19296   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19297   (exit $ac_status); }; }; then
19298   ac_cv_lib_m_csinhl=yes
19299 else
19300   echo "$as_me: failed program was:" >&5
19301 sed 's/^/| /' conftest.$ac_ext >&5
19302
19303 ac_cv_lib_m_csinhl=no
19304 fi
19305 rm -f conftest.err conftest.$ac_objext \
19306       conftest$ac_exeext conftest.$ac_ext
19307 LIBS=$ac_check_lib_save_LIBS
19308 fi
19309 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinhl" >&5
19310 echo "${ECHO_T}$ac_cv_lib_m_csinhl" >&6
19311 if test $ac_cv_lib_m_csinhl = yes; then
19312
19313 cat >>confdefs.h <<\_ACEOF
19314 #define HAVE_CSINHL 1
19315 _ACEOF
19316
19317 fi
19318
19319 echo "$as_me:$LINENO: checking for sqrtf in -lm" >&5
19320 echo $ECHO_N "checking for sqrtf in -lm... $ECHO_C" >&6
19321 if test "${ac_cv_lib_m_sqrtf+set}" = set; then
19322   echo $ECHO_N "(cached) $ECHO_C" >&6
19323 else
19324   ac_check_lib_save_LIBS=$LIBS
19325 LIBS="-lm  $LIBS"
19326 if test x$gcc_no_link = xyes; then
19327   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19328 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19329    { (exit 1); exit 1; }; }
19330 fi
19331 cat >conftest.$ac_ext <<_ACEOF
19332 /* confdefs.h.  */
19333 _ACEOF
19334 cat confdefs.h >>conftest.$ac_ext
19335 cat >>conftest.$ac_ext <<_ACEOF
19336 /* end confdefs.h.  */
19337
19338 /* Override any gcc2 internal prototype to avoid an error.  */
19339 #ifdef __cplusplus
19340 extern "C"
19341 #endif
19342 /* We use char because int might match the return type of a gcc2
19343    builtin and then its argument prototype would still apply.  */
19344 char sqrtf ();
19345 int
19346 main ()
19347 {
19348 sqrtf ();
19349   ;
19350   return 0;
19351 }
19352 _ACEOF
19353 rm -f conftest.$ac_objext conftest$ac_exeext
19354 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19355   (eval $ac_link) 2>conftest.er1
19356   ac_status=$?
19357   grep -v '^ *+' conftest.er1 >conftest.err
19358   rm -f conftest.er1
19359   cat conftest.err >&5
19360   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19361   (exit $ac_status); } &&
19362          { ac_try='test -z "$ac_c_werror_flag"
19363                          || test ! -s conftest.err'
19364   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19365   (eval $ac_try) 2>&5
19366   ac_status=$?
19367   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19368   (exit $ac_status); }; } &&
19369          { ac_try='test -s conftest$ac_exeext'
19370   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19371   (eval $ac_try) 2>&5
19372   ac_status=$?
19373   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19374   (exit $ac_status); }; }; then
19375   ac_cv_lib_m_sqrtf=yes
19376 else
19377   echo "$as_me: failed program was:" >&5
19378 sed 's/^/| /' conftest.$ac_ext >&5
19379
19380 ac_cv_lib_m_sqrtf=no
19381 fi
19382 rm -f conftest.err conftest.$ac_objext \
19383       conftest$ac_exeext conftest.$ac_ext
19384 LIBS=$ac_check_lib_save_LIBS
19385 fi
19386 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrtf" >&5
19387 echo "${ECHO_T}$ac_cv_lib_m_sqrtf" >&6
19388 if test $ac_cv_lib_m_sqrtf = yes; then
19389
19390 cat >>confdefs.h <<\_ACEOF
19391 #define HAVE_SQRTF 1
19392 _ACEOF
19393
19394 fi
19395
19396 echo "$as_me:$LINENO: checking for sqrt in -lm" >&5
19397 echo $ECHO_N "checking for sqrt in -lm... $ECHO_C" >&6
19398 if test "${ac_cv_lib_m_sqrt+set}" = set; then
19399   echo $ECHO_N "(cached) $ECHO_C" >&6
19400 else
19401   ac_check_lib_save_LIBS=$LIBS
19402 LIBS="-lm  $LIBS"
19403 if test x$gcc_no_link = xyes; then
19404   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19405 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19406    { (exit 1); exit 1; }; }
19407 fi
19408 cat >conftest.$ac_ext <<_ACEOF
19409 /* confdefs.h.  */
19410 _ACEOF
19411 cat confdefs.h >>conftest.$ac_ext
19412 cat >>conftest.$ac_ext <<_ACEOF
19413 /* end confdefs.h.  */
19414
19415 /* Override any gcc2 internal prototype to avoid an error.  */
19416 #ifdef __cplusplus
19417 extern "C"
19418 #endif
19419 /* We use char because int might match the return type of a gcc2
19420    builtin and then its argument prototype would still apply.  */
19421 char sqrt ();
19422 int
19423 main ()
19424 {
19425 sqrt ();
19426   ;
19427   return 0;
19428 }
19429 _ACEOF
19430 rm -f conftest.$ac_objext conftest$ac_exeext
19431 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19432   (eval $ac_link) 2>conftest.er1
19433   ac_status=$?
19434   grep -v '^ *+' conftest.er1 >conftest.err
19435   rm -f conftest.er1
19436   cat conftest.err >&5
19437   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19438   (exit $ac_status); } &&
19439          { ac_try='test -z "$ac_c_werror_flag"
19440                          || test ! -s conftest.err'
19441   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19442   (eval $ac_try) 2>&5
19443   ac_status=$?
19444   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19445   (exit $ac_status); }; } &&
19446          { ac_try='test -s conftest$ac_exeext'
19447   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19448   (eval $ac_try) 2>&5
19449   ac_status=$?
19450   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19451   (exit $ac_status); }; }; then
19452   ac_cv_lib_m_sqrt=yes
19453 else
19454   echo "$as_me: failed program was:" >&5
19455 sed 's/^/| /' conftest.$ac_ext >&5
19456
19457 ac_cv_lib_m_sqrt=no
19458 fi
19459 rm -f conftest.err conftest.$ac_objext \
19460       conftest$ac_exeext conftest.$ac_ext
19461 LIBS=$ac_check_lib_save_LIBS
19462 fi
19463 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrt" >&5
19464 echo "${ECHO_T}$ac_cv_lib_m_sqrt" >&6
19465 if test $ac_cv_lib_m_sqrt = yes; then
19466
19467 cat >>confdefs.h <<\_ACEOF
19468 #define HAVE_SQRT 1
19469 _ACEOF
19470
19471 fi
19472
19473 echo "$as_me:$LINENO: checking for sqrtl in -lm" >&5
19474 echo $ECHO_N "checking for sqrtl in -lm... $ECHO_C" >&6
19475 if test "${ac_cv_lib_m_sqrtl+set}" = set; then
19476   echo $ECHO_N "(cached) $ECHO_C" >&6
19477 else
19478   ac_check_lib_save_LIBS=$LIBS
19479 LIBS="-lm  $LIBS"
19480 if test x$gcc_no_link = xyes; then
19481   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19482 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19483    { (exit 1); exit 1; }; }
19484 fi
19485 cat >conftest.$ac_ext <<_ACEOF
19486 /* confdefs.h.  */
19487 _ACEOF
19488 cat confdefs.h >>conftest.$ac_ext
19489 cat >>conftest.$ac_ext <<_ACEOF
19490 /* end confdefs.h.  */
19491
19492 /* Override any gcc2 internal prototype to avoid an error.  */
19493 #ifdef __cplusplus
19494 extern "C"
19495 #endif
19496 /* We use char because int might match the return type of a gcc2
19497    builtin and then its argument prototype would still apply.  */
19498 char sqrtl ();
19499 int
19500 main ()
19501 {
19502 sqrtl ();
19503   ;
19504   return 0;
19505 }
19506 _ACEOF
19507 rm -f conftest.$ac_objext conftest$ac_exeext
19508 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19509   (eval $ac_link) 2>conftest.er1
19510   ac_status=$?
19511   grep -v '^ *+' conftest.er1 >conftest.err
19512   rm -f conftest.er1
19513   cat conftest.err >&5
19514   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19515   (exit $ac_status); } &&
19516          { ac_try='test -z "$ac_c_werror_flag"
19517                          || test ! -s conftest.err'
19518   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19519   (eval $ac_try) 2>&5
19520   ac_status=$?
19521   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19522   (exit $ac_status); }; } &&
19523          { ac_try='test -s conftest$ac_exeext'
19524   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19525   (eval $ac_try) 2>&5
19526   ac_status=$?
19527   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19528   (exit $ac_status); }; }; then
19529   ac_cv_lib_m_sqrtl=yes
19530 else
19531   echo "$as_me: failed program was:" >&5
19532 sed 's/^/| /' conftest.$ac_ext >&5
19533
19534 ac_cv_lib_m_sqrtl=no
19535 fi
19536 rm -f conftest.err conftest.$ac_objext \
19537       conftest$ac_exeext conftest.$ac_ext
19538 LIBS=$ac_check_lib_save_LIBS
19539 fi
19540 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrtl" >&5
19541 echo "${ECHO_T}$ac_cv_lib_m_sqrtl" >&6
19542 if test $ac_cv_lib_m_sqrtl = yes; then
19543
19544 cat >>confdefs.h <<\_ACEOF
19545 #define HAVE_SQRTL 1
19546 _ACEOF
19547
19548 fi
19549
19550 echo "$as_me:$LINENO: checking for csqrtf in -lm" >&5
19551 echo $ECHO_N "checking for csqrtf in -lm... $ECHO_C" >&6
19552 if test "${ac_cv_lib_m_csqrtf+set}" = set; then
19553   echo $ECHO_N "(cached) $ECHO_C" >&6
19554 else
19555   ac_check_lib_save_LIBS=$LIBS
19556 LIBS="-lm  $LIBS"
19557 if test x$gcc_no_link = xyes; then
19558   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19559 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19560    { (exit 1); exit 1; }; }
19561 fi
19562 cat >conftest.$ac_ext <<_ACEOF
19563 /* confdefs.h.  */
19564 _ACEOF
19565 cat confdefs.h >>conftest.$ac_ext
19566 cat >>conftest.$ac_ext <<_ACEOF
19567 /* end confdefs.h.  */
19568
19569 /* Override any gcc2 internal prototype to avoid an error.  */
19570 #ifdef __cplusplus
19571 extern "C"
19572 #endif
19573 /* We use char because int might match the return type of a gcc2
19574    builtin and then its argument prototype would still apply.  */
19575 char csqrtf ();
19576 int
19577 main ()
19578 {
19579 csqrtf ();
19580   ;
19581   return 0;
19582 }
19583 _ACEOF
19584 rm -f conftest.$ac_objext conftest$ac_exeext
19585 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19586   (eval $ac_link) 2>conftest.er1
19587   ac_status=$?
19588   grep -v '^ *+' conftest.er1 >conftest.err
19589   rm -f conftest.er1
19590   cat conftest.err >&5
19591   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19592   (exit $ac_status); } &&
19593          { ac_try='test -z "$ac_c_werror_flag"
19594                          || test ! -s conftest.err'
19595   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19596   (eval $ac_try) 2>&5
19597   ac_status=$?
19598   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19599   (exit $ac_status); }; } &&
19600          { ac_try='test -s conftest$ac_exeext'
19601   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19602   (eval $ac_try) 2>&5
19603   ac_status=$?
19604   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19605   (exit $ac_status); }; }; then
19606   ac_cv_lib_m_csqrtf=yes
19607 else
19608   echo "$as_me: failed program was:" >&5
19609 sed 's/^/| /' conftest.$ac_ext >&5
19610
19611 ac_cv_lib_m_csqrtf=no
19612 fi
19613 rm -f conftest.err conftest.$ac_objext \
19614       conftest$ac_exeext conftest.$ac_ext
19615 LIBS=$ac_check_lib_save_LIBS
19616 fi
19617 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrtf" >&5
19618 echo "${ECHO_T}$ac_cv_lib_m_csqrtf" >&6
19619 if test $ac_cv_lib_m_csqrtf = yes; then
19620
19621 cat >>confdefs.h <<\_ACEOF
19622 #define HAVE_CSQRTF 1
19623 _ACEOF
19624
19625 fi
19626
19627 echo "$as_me:$LINENO: checking for csqrt in -lm" >&5
19628 echo $ECHO_N "checking for csqrt in -lm... $ECHO_C" >&6
19629 if test "${ac_cv_lib_m_csqrt+set}" = set; then
19630   echo $ECHO_N "(cached) $ECHO_C" >&6
19631 else
19632   ac_check_lib_save_LIBS=$LIBS
19633 LIBS="-lm  $LIBS"
19634 if test x$gcc_no_link = xyes; then
19635   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19636 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19637    { (exit 1); exit 1; }; }
19638 fi
19639 cat >conftest.$ac_ext <<_ACEOF
19640 /* confdefs.h.  */
19641 _ACEOF
19642 cat confdefs.h >>conftest.$ac_ext
19643 cat >>conftest.$ac_ext <<_ACEOF
19644 /* end confdefs.h.  */
19645
19646 /* Override any gcc2 internal prototype to avoid an error.  */
19647 #ifdef __cplusplus
19648 extern "C"
19649 #endif
19650 /* We use char because int might match the return type of a gcc2
19651    builtin and then its argument prototype would still apply.  */
19652 char csqrt ();
19653 int
19654 main ()
19655 {
19656 csqrt ();
19657   ;
19658   return 0;
19659 }
19660 _ACEOF
19661 rm -f conftest.$ac_objext conftest$ac_exeext
19662 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19663   (eval $ac_link) 2>conftest.er1
19664   ac_status=$?
19665   grep -v '^ *+' conftest.er1 >conftest.err
19666   rm -f conftest.er1
19667   cat conftest.err >&5
19668   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19669   (exit $ac_status); } &&
19670          { ac_try='test -z "$ac_c_werror_flag"
19671                          || test ! -s conftest.err'
19672   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19673   (eval $ac_try) 2>&5
19674   ac_status=$?
19675   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19676   (exit $ac_status); }; } &&
19677          { ac_try='test -s conftest$ac_exeext'
19678   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19679   (eval $ac_try) 2>&5
19680   ac_status=$?
19681   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19682   (exit $ac_status); }; }; then
19683   ac_cv_lib_m_csqrt=yes
19684 else
19685   echo "$as_me: failed program was:" >&5
19686 sed 's/^/| /' conftest.$ac_ext >&5
19687
19688 ac_cv_lib_m_csqrt=no
19689 fi
19690 rm -f conftest.err conftest.$ac_objext \
19691       conftest$ac_exeext conftest.$ac_ext
19692 LIBS=$ac_check_lib_save_LIBS
19693 fi
19694 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrt" >&5
19695 echo "${ECHO_T}$ac_cv_lib_m_csqrt" >&6
19696 if test $ac_cv_lib_m_csqrt = yes; then
19697
19698 cat >>confdefs.h <<\_ACEOF
19699 #define HAVE_CSQRT 1
19700 _ACEOF
19701
19702 fi
19703
19704 echo "$as_me:$LINENO: checking for csqrtl in -lm" >&5
19705 echo $ECHO_N "checking for csqrtl in -lm... $ECHO_C" >&6
19706 if test "${ac_cv_lib_m_csqrtl+set}" = set; then
19707   echo $ECHO_N "(cached) $ECHO_C" >&6
19708 else
19709   ac_check_lib_save_LIBS=$LIBS
19710 LIBS="-lm  $LIBS"
19711 if test x$gcc_no_link = xyes; then
19712   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19713 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19714    { (exit 1); exit 1; }; }
19715 fi
19716 cat >conftest.$ac_ext <<_ACEOF
19717 /* confdefs.h.  */
19718 _ACEOF
19719 cat confdefs.h >>conftest.$ac_ext
19720 cat >>conftest.$ac_ext <<_ACEOF
19721 /* end confdefs.h.  */
19722
19723 /* Override any gcc2 internal prototype to avoid an error.  */
19724 #ifdef __cplusplus
19725 extern "C"
19726 #endif
19727 /* We use char because int might match the return type of a gcc2
19728    builtin and then its argument prototype would still apply.  */
19729 char csqrtl ();
19730 int
19731 main ()
19732 {
19733 csqrtl ();
19734   ;
19735   return 0;
19736 }
19737 _ACEOF
19738 rm -f conftest.$ac_objext conftest$ac_exeext
19739 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19740   (eval $ac_link) 2>conftest.er1
19741   ac_status=$?
19742   grep -v '^ *+' conftest.er1 >conftest.err
19743   rm -f conftest.er1
19744   cat conftest.err >&5
19745   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19746   (exit $ac_status); } &&
19747          { ac_try='test -z "$ac_c_werror_flag"
19748                          || test ! -s conftest.err'
19749   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19750   (eval $ac_try) 2>&5
19751   ac_status=$?
19752   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19753   (exit $ac_status); }; } &&
19754          { ac_try='test -s conftest$ac_exeext'
19755   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19756   (eval $ac_try) 2>&5
19757   ac_status=$?
19758   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19759   (exit $ac_status); }; }; then
19760   ac_cv_lib_m_csqrtl=yes
19761 else
19762   echo "$as_me: failed program was:" >&5
19763 sed 's/^/| /' conftest.$ac_ext >&5
19764
19765 ac_cv_lib_m_csqrtl=no
19766 fi
19767 rm -f conftest.err conftest.$ac_objext \
19768       conftest$ac_exeext conftest.$ac_ext
19769 LIBS=$ac_check_lib_save_LIBS
19770 fi
19771 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrtl" >&5
19772 echo "${ECHO_T}$ac_cv_lib_m_csqrtl" >&6
19773 if test $ac_cv_lib_m_csqrtl = yes; then
19774
19775 cat >>confdefs.h <<\_ACEOF
19776 #define HAVE_CSQRTL 1
19777 _ACEOF
19778
19779 fi
19780
19781 echo "$as_me:$LINENO: checking for tanf in -lm" >&5
19782 echo $ECHO_N "checking for tanf in -lm... $ECHO_C" >&6
19783 if test "${ac_cv_lib_m_tanf+set}" = set; then
19784   echo $ECHO_N "(cached) $ECHO_C" >&6
19785 else
19786   ac_check_lib_save_LIBS=$LIBS
19787 LIBS="-lm  $LIBS"
19788 if test x$gcc_no_link = xyes; then
19789   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19790 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19791    { (exit 1); exit 1; }; }
19792 fi
19793 cat >conftest.$ac_ext <<_ACEOF
19794 /* confdefs.h.  */
19795 _ACEOF
19796 cat confdefs.h >>conftest.$ac_ext
19797 cat >>conftest.$ac_ext <<_ACEOF
19798 /* end confdefs.h.  */
19799
19800 /* Override any gcc2 internal prototype to avoid an error.  */
19801 #ifdef __cplusplus
19802 extern "C"
19803 #endif
19804 /* We use char because int might match the return type of a gcc2
19805    builtin and then its argument prototype would still apply.  */
19806 char tanf ();
19807 int
19808 main ()
19809 {
19810 tanf ();
19811   ;
19812   return 0;
19813 }
19814 _ACEOF
19815 rm -f conftest.$ac_objext conftest$ac_exeext
19816 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19817   (eval $ac_link) 2>conftest.er1
19818   ac_status=$?
19819   grep -v '^ *+' conftest.er1 >conftest.err
19820   rm -f conftest.er1
19821   cat conftest.err >&5
19822   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19823   (exit $ac_status); } &&
19824          { ac_try='test -z "$ac_c_werror_flag"
19825                          || test ! -s conftest.err'
19826   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19827   (eval $ac_try) 2>&5
19828   ac_status=$?
19829   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19830   (exit $ac_status); }; } &&
19831          { ac_try='test -s conftest$ac_exeext'
19832   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19833   (eval $ac_try) 2>&5
19834   ac_status=$?
19835   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19836   (exit $ac_status); }; }; then
19837   ac_cv_lib_m_tanf=yes
19838 else
19839   echo "$as_me: failed program was:" >&5
19840 sed 's/^/| /' conftest.$ac_ext >&5
19841
19842 ac_cv_lib_m_tanf=no
19843 fi
19844 rm -f conftest.err conftest.$ac_objext \
19845       conftest$ac_exeext conftest.$ac_ext
19846 LIBS=$ac_check_lib_save_LIBS
19847 fi
19848 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanf" >&5
19849 echo "${ECHO_T}$ac_cv_lib_m_tanf" >&6
19850 if test $ac_cv_lib_m_tanf = yes; then
19851
19852 cat >>confdefs.h <<\_ACEOF
19853 #define HAVE_TANF 1
19854 _ACEOF
19855
19856 fi
19857
19858 echo "$as_me:$LINENO: checking for tan in -lm" >&5
19859 echo $ECHO_N "checking for tan in -lm... $ECHO_C" >&6
19860 if test "${ac_cv_lib_m_tan+set}" = set; then
19861   echo $ECHO_N "(cached) $ECHO_C" >&6
19862 else
19863   ac_check_lib_save_LIBS=$LIBS
19864 LIBS="-lm  $LIBS"
19865 if test x$gcc_no_link = xyes; then
19866   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19867 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19868    { (exit 1); exit 1; }; }
19869 fi
19870 cat >conftest.$ac_ext <<_ACEOF
19871 /* confdefs.h.  */
19872 _ACEOF
19873 cat confdefs.h >>conftest.$ac_ext
19874 cat >>conftest.$ac_ext <<_ACEOF
19875 /* end confdefs.h.  */
19876
19877 /* Override any gcc2 internal prototype to avoid an error.  */
19878 #ifdef __cplusplus
19879 extern "C"
19880 #endif
19881 /* We use char because int might match the return type of a gcc2
19882    builtin and then its argument prototype would still apply.  */
19883 char tan ();
19884 int
19885 main ()
19886 {
19887 tan ();
19888   ;
19889   return 0;
19890 }
19891 _ACEOF
19892 rm -f conftest.$ac_objext conftest$ac_exeext
19893 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19894   (eval $ac_link) 2>conftest.er1
19895   ac_status=$?
19896   grep -v '^ *+' conftest.er1 >conftest.err
19897   rm -f conftest.er1
19898   cat conftest.err >&5
19899   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19900   (exit $ac_status); } &&
19901          { ac_try='test -z "$ac_c_werror_flag"
19902                          || test ! -s conftest.err'
19903   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19904   (eval $ac_try) 2>&5
19905   ac_status=$?
19906   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19907   (exit $ac_status); }; } &&
19908          { ac_try='test -s conftest$ac_exeext'
19909   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19910   (eval $ac_try) 2>&5
19911   ac_status=$?
19912   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19913   (exit $ac_status); }; }; then
19914   ac_cv_lib_m_tan=yes
19915 else
19916   echo "$as_me: failed program was:" >&5
19917 sed 's/^/| /' conftest.$ac_ext >&5
19918
19919 ac_cv_lib_m_tan=no
19920 fi
19921 rm -f conftest.err conftest.$ac_objext \
19922       conftest$ac_exeext conftest.$ac_ext
19923 LIBS=$ac_check_lib_save_LIBS
19924 fi
19925 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tan" >&5
19926 echo "${ECHO_T}$ac_cv_lib_m_tan" >&6
19927 if test $ac_cv_lib_m_tan = yes; then
19928
19929 cat >>confdefs.h <<\_ACEOF
19930 #define HAVE_TAN 1
19931 _ACEOF
19932
19933 fi
19934
19935 echo "$as_me:$LINENO: checking for tanl in -lm" >&5
19936 echo $ECHO_N "checking for tanl in -lm... $ECHO_C" >&6
19937 if test "${ac_cv_lib_m_tanl+set}" = set; then
19938   echo $ECHO_N "(cached) $ECHO_C" >&6
19939 else
19940   ac_check_lib_save_LIBS=$LIBS
19941 LIBS="-lm  $LIBS"
19942 if test x$gcc_no_link = xyes; then
19943   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19944 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19945    { (exit 1); exit 1; }; }
19946 fi
19947 cat >conftest.$ac_ext <<_ACEOF
19948 /* confdefs.h.  */
19949 _ACEOF
19950 cat confdefs.h >>conftest.$ac_ext
19951 cat >>conftest.$ac_ext <<_ACEOF
19952 /* end confdefs.h.  */
19953
19954 /* Override any gcc2 internal prototype to avoid an error.  */
19955 #ifdef __cplusplus
19956 extern "C"
19957 #endif
19958 /* We use char because int might match the return type of a gcc2
19959    builtin and then its argument prototype would still apply.  */
19960 char tanl ();
19961 int
19962 main ()
19963 {
19964 tanl ();
19965   ;
19966   return 0;
19967 }
19968 _ACEOF
19969 rm -f conftest.$ac_objext conftest$ac_exeext
19970 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19971   (eval $ac_link) 2>conftest.er1
19972   ac_status=$?
19973   grep -v '^ *+' conftest.er1 >conftest.err
19974   rm -f conftest.er1
19975   cat conftest.err >&5
19976   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19977   (exit $ac_status); } &&
19978          { ac_try='test -z "$ac_c_werror_flag"
19979                          || test ! -s conftest.err'
19980   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19981   (eval $ac_try) 2>&5
19982   ac_status=$?
19983   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19984   (exit $ac_status); }; } &&
19985          { ac_try='test -s conftest$ac_exeext'
19986   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19987   (eval $ac_try) 2>&5
19988   ac_status=$?
19989   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19990   (exit $ac_status); }; }; then
19991   ac_cv_lib_m_tanl=yes
19992 else
19993   echo "$as_me: failed program was:" >&5
19994 sed 's/^/| /' conftest.$ac_ext >&5
19995
19996 ac_cv_lib_m_tanl=no
19997 fi
19998 rm -f conftest.err conftest.$ac_objext \
19999       conftest$ac_exeext conftest.$ac_ext
20000 LIBS=$ac_check_lib_save_LIBS
20001 fi
20002 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanl" >&5
20003 echo "${ECHO_T}$ac_cv_lib_m_tanl" >&6
20004 if test $ac_cv_lib_m_tanl = yes; then
20005
20006 cat >>confdefs.h <<\_ACEOF
20007 #define HAVE_TANL 1
20008 _ACEOF
20009
20010 fi
20011
20012 echo "$as_me:$LINENO: checking for ctanf in -lm" >&5
20013 echo $ECHO_N "checking for ctanf in -lm... $ECHO_C" >&6
20014 if test "${ac_cv_lib_m_ctanf+set}" = set; then
20015   echo $ECHO_N "(cached) $ECHO_C" >&6
20016 else
20017   ac_check_lib_save_LIBS=$LIBS
20018 LIBS="-lm  $LIBS"
20019 if test x$gcc_no_link = xyes; then
20020   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20021 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20022    { (exit 1); exit 1; }; }
20023 fi
20024 cat >conftest.$ac_ext <<_ACEOF
20025 /* confdefs.h.  */
20026 _ACEOF
20027 cat confdefs.h >>conftest.$ac_ext
20028 cat >>conftest.$ac_ext <<_ACEOF
20029 /* end confdefs.h.  */
20030
20031 /* Override any gcc2 internal prototype to avoid an error.  */
20032 #ifdef __cplusplus
20033 extern "C"
20034 #endif
20035 /* We use char because int might match the return type of a gcc2
20036    builtin and then its argument prototype would still apply.  */
20037 char ctanf ();
20038 int
20039 main ()
20040 {
20041 ctanf ();
20042   ;
20043   return 0;
20044 }
20045 _ACEOF
20046 rm -f conftest.$ac_objext conftest$ac_exeext
20047 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20048   (eval $ac_link) 2>conftest.er1
20049   ac_status=$?
20050   grep -v '^ *+' conftest.er1 >conftest.err
20051   rm -f conftest.er1
20052   cat conftest.err >&5
20053   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20054   (exit $ac_status); } &&
20055          { ac_try='test -z "$ac_c_werror_flag"
20056                          || test ! -s conftest.err'
20057   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20058   (eval $ac_try) 2>&5
20059   ac_status=$?
20060   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20061   (exit $ac_status); }; } &&
20062          { ac_try='test -s conftest$ac_exeext'
20063   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20064   (eval $ac_try) 2>&5
20065   ac_status=$?
20066   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20067   (exit $ac_status); }; }; then
20068   ac_cv_lib_m_ctanf=yes
20069 else
20070   echo "$as_me: failed program was:" >&5
20071 sed 's/^/| /' conftest.$ac_ext >&5
20072
20073 ac_cv_lib_m_ctanf=no
20074 fi
20075 rm -f conftest.err conftest.$ac_objext \
20076       conftest$ac_exeext conftest.$ac_ext
20077 LIBS=$ac_check_lib_save_LIBS
20078 fi
20079 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanf" >&5
20080 echo "${ECHO_T}$ac_cv_lib_m_ctanf" >&6
20081 if test $ac_cv_lib_m_ctanf = yes; then
20082
20083 cat >>confdefs.h <<\_ACEOF
20084 #define HAVE_CTANF 1
20085 _ACEOF
20086
20087 fi
20088
20089 echo "$as_me:$LINENO: checking for ctan in -lm" >&5
20090 echo $ECHO_N "checking for ctan in -lm... $ECHO_C" >&6
20091 if test "${ac_cv_lib_m_ctan+set}" = set; then
20092   echo $ECHO_N "(cached) $ECHO_C" >&6
20093 else
20094   ac_check_lib_save_LIBS=$LIBS
20095 LIBS="-lm  $LIBS"
20096 if test x$gcc_no_link = xyes; then
20097   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20098 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20099    { (exit 1); exit 1; }; }
20100 fi
20101 cat >conftest.$ac_ext <<_ACEOF
20102 /* confdefs.h.  */
20103 _ACEOF
20104 cat confdefs.h >>conftest.$ac_ext
20105 cat >>conftest.$ac_ext <<_ACEOF
20106 /* end confdefs.h.  */
20107
20108 /* Override any gcc2 internal prototype to avoid an error.  */
20109 #ifdef __cplusplus
20110 extern "C"
20111 #endif
20112 /* We use char because int might match the return type of a gcc2
20113    builtin and then its argument prototype would still apply.  */
20114 char ctan ();
20115 int
20116 main ()
20117 {
20118 ctan ();
20119   ;
20120   return 0;
20121 }
20122 _ACEOF
20123 rm -f conftest.$ac_objext conftest$ac_exeext
20124 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20125   (eval $ac_link) 2>conftest.er1
20126   ac_status=$?
20127   grep -v '^ *+' conftest.er1 >conftest.err
20128   rm -f conftest.er1
20129   cat conftest.err >&5
20130   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20131   (exit $ac_status); } &&
20132          { ac_try='test -z "$ac_c_werror_flag"
20133                          || test ! -s conftest.err'
20134   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20135   (eval $ac_try) 2>&5
20136   ac_status=$?
20137   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20138   (exit $ac_status); }; } &&
20139          { ac_try='test -s conftest$ac_exeext'
20140   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20141   (eval $ac_try) 2>&5
20142   ac_status=$?
20143   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20144   (exit $ac_status); }; }; then
20145   ac_cv_lib_m_ctan=yes
20146 else
20147   echo "$as_me: failed program was:" >&5
20148 sed 's/^/| /' conftest.$ac_ext >&5
20149
20150 ac_cv_lib_m_ctan=no
20151 fi
20152 rm -f conftest.err conftest.$ac_objext \
20153       conftest$ac_exeext conftest.$ac_ext
20154 LIBS=$ac_check_lib_save_LIBS
20155 fi
20156 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctan" >&5
20157 echo "${ECHO_T}$ac_cv_lib_m_ctan" >&6
20158 if test $ac_cv_lib_m_ctan = yes; then
20159
20160 cat >>confdefs.h <<\_ACEOF
20161 #define HAVE_CTAN 1
20162 _ACEOF
20163
20164 fi
20165
20166 echo "$as_me:$LINENO: checking for ctanl in -lm" >&5
20167 echo $ECHO_N "checking for ctanl in -lm... $ECHO_C" >&6
20168 if test "${ac_cv_lib_m_ctanl+set}" = set; then
20169   echo $ECHO_N "(cached) $ECHO_C" >&6
20170 else
20171   ac_check_lib_save_LIBS=$LIBS
20172 LIBS="-lm  $LIBS"
20173 if test x$gcc_no_link = xyes; then
20174   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20175 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20176    { (exit 1); exit 1; }; }
20177 fi
20178 cat >conftest.$ac_ext <<_ACEOF
20179 /* confdefs.h.  */
20180 _ACEOF
20181 cat confdefs.h >>conftest.$ac_ext
20182 cat >>conftest.$ac_ext <<_ACEOF
20183 /* end confdefs.h.  */
20184
20185 /* Override any gcc2 internal prototype to avoid an error.  */
20186 #ifdef __cplusplus
20187 extern "C"
20188 #endif
20189 /* We use char because int might match the return type of a gcc2
20190    builtin and then its argument prototype would still apply.  */
20191 char ctanl ();
20192 int
20193 main ()
20194 {
20195 ctanl ();
20196   ;
20197   return 0;
20198 }
20199 _ACEOF
20200 rm -f conftest.$ac_objext conftest$ac_exeext
20201 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20202   (eval $ac_link) 2>conftest.er1
20203   ac_status=$?
20204   grep -v '^ *+' conftest.er1 >conftest.err
20205   rm -f conftest.er1
20206   cat conftest.err >&5
20207   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20208   (exit $ac_status); } &&
20209          { ac_try='test -z "$ac_c_werror_flag"
20210                          || test ! -s conftest.err'
20211   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20212   (eval $ac_try) 2>&5
20213   ac_status=$?
20214   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20215   (exit $ac_status); }; } &&
20216          { ac_try='test -s conftest$ac_exeext'
20217   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20218   (eval $ac_try) 2>&5
20219   ac_status=$?
20220   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20221   (exit $ac_status); }; }; then
20222   ac_cv_lib_m_ctanl=yes
20223 else
20224   echo "$as_me: failed program was:" >&5
20225 sed 's/^/| /' conftest.$ac_ext >&5
20226
20227 ac_cv_lib_m_ctanl=no
20228 fi
20229 rm -f conftest.err conftest.$ac_objext \
20230       conftest$ac_exeext conftest.$ac_ext
20231 LIBS=$ac_check_lib_save_LIBS
20232 fi
20233 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanl" >&5
20234 echo "${ECHO_T}$ac_cv_lib_m_ctanl" >&6
20235 if test $ac_cv_lib_m_ctanl = yes; then
20236
20237 cat >>confdefs.h <<\_ACEOF
20238 #define HAVE_CTANL 1
20239 _ACEOF
20240
20241 fi
20242
20243 echo "$as_me:$LINENO: checking for tanhf in -lm" >&5
20244 echo $ECHO_N "checking for tanhf in -lm... $ECHO_C" >&6
20245 if test "${ac_cv_lib_m_tanhf+set}" = set; then
20246   echo $ECHO_N "(cached) $ECHO_C" >&6
20247 else
20248   ac_check_lib_save_LIBS=$LIBS
20249 LIBS="-lm  $LIBS"
20250 if test x$gcc_no_link = xyes; then
20251   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20252 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20253    { (exit 1); exit 1; }; }
20254 fi
20255 cat >conftest.$ac_ext <<_ACEOF
20256 /* confdefs.h.  */
20257 _ACEOF
20258 cat confdefs.h >>conftest.$ac_ext
20259 cat >>conftest.$ac_ext <<_ACEOF
20260 /* end confdefs.h.  */
20261
20262 /* Override any gcc2 internal prototype to avoid an error.  */
20263 #ifdef __cplusplus
20264 extern "C"
20265 #endif
20266 /* We use char because int might match the return type of a gcc2
20267    builtin and then its argument prototype would still apply.  */
20268 char tanhf ();
20269 int
20270 main ()
20271 {
20272 tanhf ();
20273   ;
20274   return 0;
20275 }
20276 _ACEOF
20277 rm -f conftest.$ac_objext conftest$ac_exeext
20278 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20279   (eval $ac_link) 2>conftest.er1
20280   ac_status=$?
20281   grep -v '^ *+' conftest.er1 >conftest.err
20282   rm -f conftest.er1
20283   cat conftest.err >&5
20284   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20285   (exit $ac_status); } &&
20286          { ac_try='test -z "$ac_c_werror_flag"
20287                          || test ! -s conftest.err'
20288   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20289   (eval $ac_try) 2>&5
20290   ac_status=$?
20291   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20292   (exit $ac_status); }; } &&
20293          { ac_try='test -s conftest$ac_exeext'
20294   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20295   (eval $ac_try) 2>&5
20296   ac_status=$?
20297   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20298   (exit $ac_status); }; }; then
20299   ac_cv_lib_m_tanhf=yes
20300 else
20301   echo "$as_me: failed program was:" >&5
20302 sed 's/^/| /' conftest.$ac_ext >&5
20303
20304 ac_cv_lib_m_tanhf=no
20305 fi
20306 rm -f conftest.err conftest.$ac_objext \
20307       conftest$ac_exeext conftest.$ac_ext
20308 LIBS=$ac_check_lib_save_LIBS
20309 fi
20310 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanhf" >&5
20311 echo "${ECHO_T}$ac_cv_lib_m_tanhf" >&6
20312 if test $ac_cv_lib_m_tanhf = yes; then
20313
20314 cat >>confdefs.h <<\_ACEOF
20315 #define HAVE_TANHF 1
20316 _ACEOF
20317
20318 fi
20319
20320 echo "$as_me:$LINENO: checking for tanh in -lm" >&5
20321 echo $ECHO_N "checking for tanh in -lm... $ECHO_C" >&6
20322 if test "${ac_cv_lib_m_tanh+set}" = set; then
20323   echo $ECHO_N "(cached) $ECHO_C" >&6
20324 else
20325   ac_check_lib_save_LIBS=$LIBS
20326 LIBS="-lm  $LIBS"
20327 if test x$gcc_no_link = xyes; then
20328   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20329 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20330    { (exit 1); exit 1; }; }
20331 fi
20332 cat >conftest.$ac_ext <<_ACEOF
20333 /* confdefs.h.  */
20334 _ACEOF
20335 cat confdefs.h >>conftest.$ac_ext
20336 cat >>conftest.$ac_ext <<_ACEOF
20337 /* end confdefs.h.  */
20338
20339 /* Override any gcc2 internal prototype to avoid an error.  */
20340 #ifdef __cplusplus
20341 extern "C"
20342 #endif
20343 /* We use char because int might match the return type of a gcc2
20344    builtin and then its argument prototype would still apply.  */
20345 char tanh ();
20346 int
20347 main ()
20348 {
20349 tanh ();
20350   ;
20351   return 0;
20352 }
20353 _ACEOF
20354 rm -f conftest.$ac_objext conftest$ac_exeext
20355 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20356   (eval $ac_link) 2>conftest.er1
20357   ac_status=$?
20358   grep -v '^ *+' conftest.er1 >conftest.err
20359   rm -f conftest.er1
20360   cat conftest.err >&5
20361   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20362   (exit $ac_status); } &&
20363          { ac_try='test -z "$ac_c_werror_flag"
20364                          || test ! -s conftest.err'
20365   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20366   (eval $ac_try) 2>&5
20367   ac_status=$?
20368   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20369   (exit $ac_status); }; } &&
20370          { ac_try='test -s conftest$ac_exeext'
20371   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20372   (eval $ac_try) 2>&5
20373   ac_status=$?
20374   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20375   (exit $ac_status); }; }; then
20376   ac_cv_lib_m_tanh=yes
20377 else
20378   echo "$as_me: failed program was:" >&5
20379 sed 's/^/| /' conftest.$ac_ext >&5
20380
20381 ac_cv_lib_m_tanh=no
20382 fi
20383 rm -f conftest.err conftest.$ac_objext \
20384       conftest$ac_exeext conftest.$ac_ext
20385 LIBS=$ac_check_lib_save_LIBS
20386 fi
20387 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanh" >&5
20388 echo "${ECHO_T}$ac_cv_lib_m_tanh" >&6
20389 if test $ac_cv_lib_m_tanh = yes; then
20390
20391 cat >>confdefs.h <<\_ACEOF
20392 #define HAVE_TANH 1
20393 _ACEOF
20394
20395 fi
20396
20397 echo "$as_me:$LINENO: checking for tanhl in -lm" >&5
20398 echo $ECHO_N "checking for tanhl in -lm... $ECHO_C" >&6
20399 if test "${ac_cv_lib_m_tanhl+set}" = set; then
20400   echo $ECHO_N "(cached) $ECHO_C" >&6
20401 else
20402   ac_check_lib_save_LIBS=$LIBS
20403 LIBS="-lm  $LIBS"
20404 if test x$gcc_no_link = xyes; then
20405   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20406 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20407    { (exit 1); exit 1; }; }
20408 fi
20409 cat >conftest.$ac_ext <<_ACEOF
20410 /* confdefs.h.  */
20411 _ACEOF
20412 cat confdefs.h >>conftest.$ac_ext
20413 cat >>conftest.$ac_ext <<_ACEOF
20414 /* end confdefs.h.  */
20415
20416 /* Override any gcc2 internal prototype to avoid an error.  */
20417 #ifdef __cplusplus
20418 extern "C"
20419 #endif
20420 /* We use char because int might match the return type of a gcc2
20421    builtin and then its argument prototype would still apply.  */
20422 char tanhl ();
20423 int
20424 main ()
20425 {
20426 tanhl ();
20427   ;
20428   return 0;
20429 }
20430 _ACEOF
20431 rm -f conftest.$ac_objext conftest$ac_exeext
20432 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20433   (eval $ac_link) 2>conftest.er1
20434   ac_status=$?
20435   grep -v '^ *+' conftest.er1 >conftest.err
20436   rm -f conftest.er1
20437   cat conftest.err >&5
20438   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20439   (exit $ac_status); } &&
20440          { ac_try='test -z "$ac_c_werror_flag"
20441                          || test ! -s conftest.err'
20442   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20443   (eval $ac_try) 2>&5
20444   ac_status=$?
20445   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20446   (exit $ac_status); }; } &&
20447          { ac_try='test -s conftest$ac_exeext'
20448   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20449   (eval $ac_try) 2>&5
20450   ac_status=$?
20451   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20452   (exit $ac_status); }; }; then
20453   ac_cv_lib_m_tanhl=yes
20454 else
20455   echo "$as_me: failed program was:" >&5
20456 sed 's/^/| /' conftest.$ac_ext >&5
20457
20458 ac_cv_lib_m_tanhl=no
20459 fi
20460 rm -f conftest.err conftest.$ac_objext \
20461       conftest$ac_exeext conftest.$ac_ext
20462 LIBS=$ac_check_lib_save_LIBS
20463 fi
20464 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanhl" >&5
20465 echo "${ECHO_T}$ac_cv_lib_m_tanhl" >&6
20466 if test $ac_cv_lib_m_tanhl = yes; then
20467
20468 cat >>confdefs.h <<\_ACEOF
20469 #define HAVE_TANHL 1
20470 _ACEOF
20471
20472 fi
20473
20474 echo "$as_me:$LINENO: checking for ctanhf in -lm" >&5
20475 echo $ECHO_N "checking for ctanhf in -lm... $ECHO_C" >&6
20476 if test "${ac_cv_lib_m_ctanhf+set}" = set; then
20477   echo $ECHO_N "(cached) $ECHO_C" >&6
20478 else
20479   ac_check_lib_save_LIBS=$LIBS
20480 LIBS="-lm  $LIBS"
20481 if test x$gcc_no_link = xyes; then
20482   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20483 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20484    { (exit 1); exit 1; }; }
20485 fi
20486 cat >conftest.$ac_ext <<_ACEOF
20487 /* confdefs.h.  */
20488 _ACEOF
20489 cat confdefs.h >>conftest.$ac_ext
20490 cat >>conftest.$ac_ext <<_ACEOF
20491 /* end confdefs.h.  */
20492
20493 /* Override any gcc2 internal prototype to avoid an error.  */
20494 #ifdef __cplusplus
20495 extern "C"
20496 #endif
20497 /* We use char because int might match the return type of a gcc2
20498    builtin and then its argument prototype would still apply.  */
20499 char ctanhf ();
20500 int
20501 main ()
20502 {
20503 ctanhf ();
20504   ;
20505   return 0;
20506 }
20507 _ACEOF
20508 rm -f conftest.$ac_objext conftest$ac_exeext
20509 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20510   (eval $ac_link) 2>conftest.er1
20511   ac_status=$?
20512   grep -v '^ *+' conftest.er1 >conftest.err
20513   rm -f conftest.er1
20514   cat conftest.err >&5
20515   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20516   (exit $ac_status); } &&
20517          { ac_try='test -z "$ac_c_werror_flag"
20518                          || test ! -s conftest.err'
20519   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20520   (eval $ac_try) 2>&5
20521   ac_status=$?
20522   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20523   (exit $ac_status); }; } &&
20524          { ac_try='test -s conftest$ac_exeext'
20525   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20526   (eval $ac_try) 2>&5
20527   ac_status=$?
20528   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20529   (exit $ac_status); }; }; then
20530   ac_cv_lib_m_ctanhf=yes
20531 else
20532   echo "$as_me: failed program was:" >&5
20533 sed 's/^/| /' conftest.$ac_ext >&5
20534
20535 ac_cv_lib_m_ctanhf=no
20536 fi
20537 rm -f conftest.err conftest.$ac_objext \
20538       conftest$ac_exeext conftest.$ac_ext
20539 LIBS=$ac_check_lib_save_LIBS
20540 fi
20541 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanhf" >&5
20542 echo "${ECHO_T}$ac_cv_lib_m_ctanhf" >&6
20543 if test $ac_cv_lib_m_ctanhf = yes; then
20544
20545 cat >>confdefs.h <<\_ACEOF
20546 #define HAVE_CTANHF 1
20547 _ACEOF
20548
20549 fi
20550
20551 echo "$as_me:$LINENO: checking for ctanh in -lm" >&5
20552 echo $ECHO_N "checking for ctanh in -lm... $ECHO_C" >&6
20553 if test "${ac_cv_lib_m_ctanh+set}" = set; then
20554   echo $ECHO_N "(cached) $ECHO_C" >&6
20555 else
20556   ac_check_lib_save_LIBS=$LIBS
20557 LIBS="-lm  $LIBS"
20558 if test x$gcc_no_link = xyes; then
20559   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20560 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20561    { (exit 1); exit 1; }; }
20562 fi
20563 cat >conftest.$ac_ext <<_ACEOF
20564 /* confdefs.h.  */
20565 _ACEOF
20566 cat confdefs.h >>conftest.$ac_ext
20567 cat >>conftest.$ac_ext <<_ACEOF
20568 /* end confdefs.h.  */
20569
20570 /* Override any gcc2 internal prototype to avoid an error.  */
20571 #ifdef __cplusplus
20572 extern "C"
20573 #endif
20574 /* We use char because int might match the return type of a gcc2
20575    builtin and then its argument prototype would still apply.  */
20576 char ctanh ();
20577 int
20578 main ()
20579 {
20580 ctanh ();
20581   ;
20582   return 0;
20583 }
20584 _ACEOF
20585 rm -f conftest.$ac_objext conftest$ac_exeext
20586 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20587   (eval $ac_link) 2>conftest.er1
20588   ac_status=$?
20589   grep -v '^ *+' conftest.er1 >conftest.err
20590   rm -f conftest.er1
20591   cat conftest.err >&5
20592   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20593   (exit $ac_status); } &&
20594          { ac_try='test -z "$ac_c_werror_flag"
20595                          || test ! -s conftest.err'
20596   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20597   (eval $ac_try) 2>&5
20598   ac_status=$?
20599   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20600   (exit $ac_status); }; } &&
20601          { ac_try='test -s conftest$ac_exeext'
20602   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20603   (eval $ac_try) 2>&5
20604   ac_status=$?
20605   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20606   (exit $ac_status); }; }; then
20607   ac_cv_lib_m_ctanh=yes
20608 else
20609   echo "$as_me: failed program was:" >&5
20610 sed 's/^/| /' conftest.$ac_ext >&5
20611
20612 ac_cv_lib_m_ctanh=no
20613 fi
20614 rm -f conftest.err conftest.$ac_objext \
20615       conftest$ac_exeext conftest.$ac_ext
20616 LIBS=$ac_check_lib_save_LIBS
20617 fi
20618 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanh" >&5
20619 echo "${ECHO_T}$ac_cv_lib_m_ctanh" >&6
20620 if test $ac_cv_lib_m_ctanh = yes; then
20621
20622 cat >>confdefs.h <<\_ACEOF
20623 #define HAVE_CTANH 1
20624 _ACEOF
20625
20626 fi
20627
20628 echo "$as_me:$LINENO: checking for ctanhl in -lm" >&5
20629 echo $ECHO_N "checking for ctanhl in -lm... $ECHO_C" >&6
20630 if test "${ac_cv_lib_m_ctanhl+set}" = set; then
20631   echo $ECHO_N "(cached) $ECHO_C" >&6
20632 else
20633   ac_check_lib_save_LIBS=$LIBS
20634 LIBS="-lm  $LIBS"
20635 if test x$gcc_no_link = xyes; then
20636   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20637 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20638    { (exit 1); exit 1; }; }
20639 fi
20640 cat >conftest.$ac_ext <<_ACEOF
20641 /* confdefs.h.  */
20642 _ACEOF
20643 cat confdefs.h >>conftest.$ac_ext
20644 cat >>conftest.$ac_ext <<_ACEOF
20645 /* end confdefs.h.  */
20646
20647 /* Override any gcc2 internal prototype to avoid an error.  */
20648 #ifdef __cplusplus
20649 extern "C"
20650 #endif
20651 /* We use char because int might match the return type of a gcc2
20652    builtin and then its argument prototype would still apply.  */
20653 char ctanhl ();
20654 int
20655 main ()
20656 {
20657 ctanhl ();
20658   ;
20659   return 0;
20660 }
20661 _ACEOF
20662 rm -f conftest.$ac_objext conftest$ac_exeext
20663 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20664   (eval $ac_link) 2>conftest.er1
20665   ac_status=$?
20666   grep -v '^ *+' conftest.er1 >conftest.err
20667   rm -f conftest.er1
20668   cat conftest.err >&5
20669   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20670   (exit $ac_status); } &&
20671          { ac_try='test -z "$ac_c_werror_flag"
20672                          || test ! -s conftest.err'
20673   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20674   (eval $ac_try) 2>&5
20675   ac_status=$?
20676   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20677   (exit $ac_status); }; } &&
20678          { ac_try='test -s conftest$ac_exeext'
20679   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20680   (eval $ac_try) 2>&5
20681   ac_status=$?
20682   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20683   (exit $ac_status); }; }; then
20684   ac_cv_lib_m_ctanhl=yes
20685 else
20686   echo "$as_me: failed program was:" >&5
20687 sed 's/^/| /' conftest.$ac_ext >&5
20688
20689 ac_cv_lib_m_ctanhl=no
20690 fi
20691 rm -f conftest.err conftest.$ac_objext \
20692       conftest$ac_exeext conftest.$ac_ext
20693 LIBS=$ac_check_lib_save_LIBS
20694 fi
20695 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanhl" >&5
20696 echo "${ECHO_T}$ac_cv_lib_m_ctanhl" >&6
20697 if test $ac_cv_lib_m_ctanhl = yes; then
20698
20699 cat >>confdefs.h <<\_ACEOF
20700 #define HAVE_CTANHL 1
20701 _ACEOF
20702
20703 fi
20704
20705 echo "$as_me:$LINENO: checking for truncf in -lm" >&5
20706 echo $ECHO_N "checking for truncf in -lm... $ECHO_C" >&6
20707 if test "${ac_cv_lib_m_truncf+set}" = set; then
20708   echo $ECHO_N "(cached) $ECHO_C" >&6
20709 else
20710   ac_check_lib_save_LIBS=$LIBS
20711 LIBS="-lm  $LIBS"
20712 if test x$gcc_no_link = xyes; then
20713   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20714 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20715    { (exit 1); exit 1; }; }
20716 fi
20717 cat >conftest.$ac_ext <<_ACEOF
20718 /* confdefs.h.  */
20719 _ACEOF
20720 cat confdefs.h >>conftest.$ac_ext
20721 cat >>conftest.$ac_ext <<_ACEOF
20722 /* end confdefs.h.  */
20723
20724 /* Override any gcc2 internal prototype to avoid an error.  */
20725 #ifdef __cplusplus
20726 extern "C"
20727 #endif
20728 /* We use char because int might match the return type of a gcc2
20729    builtin and then its argument prototype would still apply.  */
20730 char truncf ();
20731 int
20732 main ()
20733 {
20734 truncf ();
20735   ;
20736   return 0;
20737 }
20738 _ACEOF
20739 rm -f conftest.$ac_objext conftest$ac_exeext
20740 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20741   (eval $ac_link) 2>conftest.er1
20742   ac_status=$?
20743   grep -v '^ *+' conftest.er1 >conftest.err
20744   rm -f conftest.er1
20745   cat conftest.err >&5
20746   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20747   (exit $ac_status); } &&
20748          { ac_try='test -z "$ac_c_werror_flag"
20749                          || test ! -s conftest.err'
20750   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20751   (eval $ac_try) 2>&5
20752   ac_status=$?
20753   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20754   (exit $ac_status); }; } &&
20755          { ac_try='test -s conftest$ac_exeext'
20756   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20757   (eval $ac_try) 2>&5
20758   ac_status=$?
20759   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20760   (exit $ac_status); }; }; then
20761   ac_cv_lib_m_truncf=yes
20762 else
20763   echo "$as_me: failed program was:" >&5
20764 sed 's/^/| /' conftest.$ac_ext >&5
20765
20766 ac_cv_lib_m_truncf=no
20767 fi
20768 rm -f conftest.err conftest.$ac_objext \
20769       conftest$ac_exeext conftest.$ac_ext
20770 LIBS=$ac_check_lib_save_LIBS
20771 fi
20772 echo "$as_me:$LINENO: result: $ac_cv_lib_m_truncf" >&5
20773 echo "${ECHO_T}$ac_cv_lib_m_truncf" >&6
20774 if test $ac_cv_lib_m_truncf = yes; then
20775
20776 cat >>confdefs.h <<\_ACEOF
20777 #define HAVE_TRUNCF 1
20778 _ACEOF
20779
20780 fi
20781
20782 echo "$as_me:$LINENO: checking for trunc in -lm" >&5
20783 echo $ECHO_N "checking for trunc in -lm... $ECHO_C" >&6
20784 if test "${ac_cv_lib_m_trunc+set}" = set; then
20785   echo $ECHO_N "(cached) $ECHO_C" >&6
20786 else
20787   ac_check_lib_save_LIBS=$LIBS
20788 LIBS="-lm  $LIBS"
20789 if test x$gcc_no_link = xyes; then
20790   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20791 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20792    { (exit 1); exit 1; }; }
20793 fi
20794 cat >conftest.$ac_ext <<_ACEOF
20795 /* confdefs.h.  */
20796 _ACEOF
20797 cat confdefs.h >>conftest.$ac_ext
20798 cat >>conftest.$ac_ext <<_ACEOF
20799 /* end confdefs.h.  */
20800
20801 /* Override any gcc2 internal prototype to avoid an error.  */
20802 #ifdef __cplusplus
20803 extern "C"
20804 #endif
20805 /* We use char because int might match the return type of a gcc2
20806    builtin and then its argument prototype would still apply.  */
20807 char trunc ();
20808 int
20809 main ()
20810 {
20811 trunc ();
20812   ;
20813   return 0;
20814 }
20815 _ACEOF
20816 rm -f conftest.$ac_objext conftest$ac_exeext
20817 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20818   (eval $ac_link) 2>conftest.er1
20819   ac_status=$?
20820   grep -v '^ *+' conftest.er1 >conftest.err
20821   rm -f conftest.er1
20822   cat conftest.err >&5
20823   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20824   (exit $ac_status); } &&
20825          { ac_try='test -z "$ac_c_werror_flag"
20826                          || test ! -s conftest.err'
20827   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20828   (eval $ac_try) 2>&5
20829   ac_status=$?
20830   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20831   (exit $ac_status); }; } &&
20832          { ac_try='test -s conftest$ac_exeext'
20833   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20834   (eval $ac_try) 2>&5
20835   ac_status=$?
20836   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20837   (exit $ac_status); }; }; then
20838   ac_cv_lib_m_trunc=yes
20839 else
20840   echo "$as_me: failed program was:" >&5
20841 sed 's/^/| /' conftest.$ac_ext >&5
20842
20843 ac_cv_lib_m_trunc=no
20844 fi
20845 rm -f conftest.err conftest.$ac_objext \
20846       conftest$ac_exeext conftest.$ac_ext
20847 LIBS=$ac_check_lib_save_LIBS
20848 fi
20849 echo "$as_me:$LINENO: result: $ac_cv_lib_m_trunc" >&5
20850 echo "${ECHO_T}$ac_cv_lib_m_trunc" >&6
20851 if test $ac_cv_lib_m_trunc = yes; then
20852
20853 cat >>confdefs.h <<\_ACEOF
20854 #define HAVE_TRUNC 1
20855 _ACEOF
20856
20857 fi
20858
20859 echo "$as_me:$LINENO: checking for truncl in -lm" >&5
20860 echo $ECHO_N "checking for truncl in -lm... $ECHO_C" >&6
20861 if test "${ac_cv_lib_m_truncl+set}" = set; then
20862   echo $ECHO_N "(cached) $ECHO_C" >&6
20863 else
20864   ac_check_lib_save_LIBS=$LIBS
20865 LIBS="-lm  $LIBS"
20866 if test x$gcc_no_link = xyes; then
20867   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20868 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20869    { (exit 1); exit 1; }; }
20870 fi
20871 cat >conftest.$ac_ext <<_ACEOF
20872 /* confdefs.h.  */
20873 _ACEOF
20874 cat confdefs.h >>conftest.$ac_ext
20875 cat >>conftest.$ac_ext <<_ACEOF
20876 /* end confdefs.h.  */
20877
20878 /* Override any gcc2 internal prototype to avoid an error.  */
20879 #ifdef __cplusplus
20880 extern "C"
20881 #endif
20882 /* We use char because int might match the return type of a gcc2
20883    builtin and then its argument prototype would still apply.  */
20884 char truncl ();
20885 int
20886 main ()
20887 {
20888 truncl ();
20889   ;
20890   return 0;
20891 }
20892 _ACEOF
20893 rm -f conftest.$ac_objext conftest$ac_exeext
20894 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20895   (eval $ac_link) 2>conftest.er1
20896   ac_status=$?
20897   grep -v '^ *+' conftest.er1 >conftest.err
20898   rm -f conftest.er1
20899   cat conftest.err >&5
20900   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20901   (exit $ac_status); } &&
20902          { ac_try='test -z "$ac_c_werror_flag"
20903                          || test ! -s conftest.err'
20904   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20905   (eval $ac_try) 2>&5
20906   ac_status=$?
20907   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20908   (exit $ac_status); }; } &&
20909          { ac_try='test -s conftest$ac_exeext'
20910   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20911   (eval $ac_try) 2>&5
20912   ac_status=$?
20913   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20914   (exit $ac_status); }; }; then
20915   ac_cv_lib_m_truncl=yes
20916 else
20917   echo "$as_me: failed program was:" >&5
20918 sed 's/^/| /' conftest.$ac_ext >&5
20919
20920 ac_cv_lib_m_truncl=no
20921 fi
20922 rm -f conftest.err conftest.$ac_objext \
20923       conftest$ac_exeext conftest.$ac_ext
20924 LIBS=$ac_check_lib_save_LIBS
20925 fi
20926 echo "$as_me:$LINENO: result: $ac_cv_lib_m_truncl" >&5
20927 echo "${ECHO_T}$ac_cv_lib_m_truncl" >&6
20928 if test $ac_cv_lib_m_truncl = yes; then
20929
20930 cat >>confdefs.h <<\_ACEOF
20931 #define HAVE_TRUNCL 1
20932 _ACEOF
20933
20934 fi
20935
20936 echo "$as_me:$LINENO: checking for erff in -lm" >&5
20937 echo $ECHO_N "checking for erff in -lm... $ECHO_C" >&6
20938 if test "${ac_cv_lib_m_erff+set}" = set; then
20939   echo $ECHO_N "(cached) $ECHO_C" >&6
20940 else
20941   ac_check_lib_save_LIBS=$LIBS
20942 LIBS="-lm  $LIBS"
20943 if test x$gcc_no_link = xyes; then
20944   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20945 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20946    { (exit 1); exit 1; }; }
20947 fi
20948 cat >conftest.$ac_ext <<_ACEOF
20949 /* confdefs.h.  */
20950 _ACEOF
20951 cat confdefs.h >>conftest.$ac_ext
20952 cat >>conftest.$ac_ext <<_ACEOF
20953 /* end confdefs.h.  */
20954
20955 /* Override any gcc2 internal prototype to avoid an error.  */
20956 #ifdef __cplusplus
20957 extern "C"
20958 #endif
20959 /* We use char because int might match the return type of a gcc2
20960    builtin and then its argument prototype would still apply.  */
20961 char erff ();
20962 int
20963 main ()
20964 {
20965 erff ();
20966   ;
20967   return 0;
20968 }
20969 _ACEOF
20970 rm -f conftest.$ac_objext conftest$ac_exeext
20971 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20972   (eval $ac_link) 2>conftest.er1
20973   ac_status=$?
20974   grep -v '^ *+' conftest.er1 >conftest.err
20975   rm -f conftest.er1
20976   cat conftest.err >&5
20977   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20978   (exit $ac_status); } &&
20979          { ac_try='test -z "$ac_c_werror_flag"
20980                          || test ! -s conftest.err'
20981   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20982   (eval $ac_try) 2>&5
20983   ac_status=$?
20984   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20985   (exit $ac_status); }; } &&
20986          { ac_try='test -s conftest$ac_exeext'
20987   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20988   (eval $ac_try) 2>&5
20989   ac_status=$?
20990   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20991   (exit $ac_status); }; }; then
20992   ac_cv_lib_m_erff=yes
20993 else
20994   echo "$as_me: failed program was:" >&5
20995 sed 's/^/| /' conftest.$ac_ext >&5
20996
20997 ac_cv_lib_m_erff=no
20998 fi
20999 rm -f conftest.err conftest.$ac_objext \
21000       conftest$ac_exeext conftest.$ac_ext
21001 LIBS=$ac_check_lib_save_LIBS
21002 fi
21003 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erff" >&5
21004 echo "${ECHO_T}$ac_cv_lib_m_erff" >&6
21005 if test $ac_cv_lib_m_erff = yes; then
21006
21007 cat >>confdefs.h <<\_ACEOF
21008 #define HAVE_ERFF 1
21009 _ACEOF
21010
21011 fi
21012
21013 echo "$as_me:$LINENO: checking for erf in -lm" >&5
21014 echo $ECHO_N "checking for erf in -lm... $ECHO_C" >&6
21015 if test "${ac_cv_lib_m_erf+set}" = set; then
21016   echo $ECHO_N "(cached) $ECHO_C" >&6
21017 else
21018   ac_check_lib_save_LIBS=$LIBS
21019 LIBS="-lm  $LIBS"
21020 if test x$gcc_no_link = xyes; then
21021   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21022 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21023    { (exit 1); exit 1; }; }
21024 fi
21025 cat >conftest.$ac_ext <<_ACEOF
21026 /* confdefs.h.  */
21027 _ACEOF
21028 cat confdefs.h >>conftest.$ac_ext
21029 cat >>conftest.$ac_ext <<_ACEOF
21030 /* end confdefs.h.  */
21031
21032 /* Override any gcc2 internal prototype to avoid an error.  */
21033 #ifdef __cplusplus
21034 extern "C"
21035 #endif
21036 /* We use char because int might match the return type of a gcc2
21037    builtin and then its argument prototype would still apply.  */
21038 char erf ();
21039 int
21040 main ()
21041 {
21042 erf ();
21043   ;
21044   return 0;
21045 }
21046 _ACEOF
21047 rm -f conftest.$ac_objext conftest$ac_exeext
21048 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21049   (eval $ac_link) 2>conftest.er1
21050   ac_status=$?
21051   grep -v '^ *+' conftest.er1 >conftest.err
21052   rm -f conftest.er1
21053   cat conftest.err >&5
21054   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21055   (exit $ac_status); } &&
21056          { ac_try='test -z "$ac_c_werror_flag"
21057                          || test ! -s conftest.err'
21058   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21059   (eval $ac_try) 2>&5
21060   ac_status=$?
21061   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21062   (exit $ac_status); }; } &&
21063          { ac_try='test -s conftest$ac_exeext'
21064   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21065   (eval $ac_try) 2>&5
21066   ac_status=$?
21067   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21068   (exit $ac_status); }; }; then
21069   ac_cv_lib_m_erf=yes
21070 else
21071   echo "$as_me: failed program was:" >&5
21072 sed 's/^/| /' conftest.$ac_ext >&5
21073
21074 ac_cv_lib_m_erf=no
21075 fi
21076 rm -f conftest.err conftest.$ac_objext \
21077       conftest$ac_exeext conftest.$ac_ext
21078 LIBS=$ac_check_lib_save_LIBS
21079 fi
21080 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erf" >&5
21081 echo "${ECHO_T}$ac_cv_lib_m_erf" >&6
21082 if test $ac_cv_lib_m_erf = yes; then
21083
21084 cat >>confdefs.h <<\_ACEOF
21085 #define HAVE_ERF 1
21086 _ACEOF
21087
21088 fi
21089
21090 echo "$as_me:$LINENO: checking for erfl in -lm" >&5
21091 echo $ECHO_N "checking for erfl in -lm... $ECHO_C" >&6
21092 if test "${ac_cv_lib_m_erfl+set}" = set; then
21093   echo $ECHO_N "(cached) $ECHO_C" >&6
21094 else
21095   ac_check_lib_save_LIBS=$LIBS
21096 LIBS="-lm  $LIBS"
21097 if test x$gcc_no_link = xyes; then
21098   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21099 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21100    { (exit 1); exit 1; }; }
21101 fi
21102 cat >conftest.$ac_ext <<_ACEOF
21103 /* confdefs.h.  */
21104 _ACEOF
21105 cat confdefs.h >>conftest.$ac_ext
21106 cat >>conftest.$ac_ext <<_ACEOF
21107 /* end confdefs.h.  */
21108
21109 /* Override any gcc2 internal prototype to avoid an error.  */
21110 #ifdef __cplusplus
21111 extern "C"
21112 #endif
21113 /* We use char because int might match the return type of a gcc2
21114    builtin and then its argument prototype would still apply.  */
21115 char erfl ();
21116 int
21117 main ()
21118 {
21119 erfl ();
21120   ;
21121   return 0;
21122 }
21123 _ACEOF
21124 rm -f conftest.$ac_objext conftest$ac_exeext
21125 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21126   (eval $ac_link) 2>conftest.er1
21127   ac_status=$?
21128   grep -v '^ *+' conftest.er1 >conftest.err
21129   rm -f conftest.er1
21130   cat conftest.err >&5
21131   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21132   (exit $ac_status); } &&
21133          { ac_try='test -z "$ac_c_werror_flag"
21134                          || test ! -s conftest.err'
21135   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21136   (eval $ac_try) 2>&5
21137   ac_status=$?
21138   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21139   (exit $ac_status); }; } &&
21140          { ac_try='test -s conftest$ac_exeext'
21141   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21142   (eval $ac_try) 2>&5
21143   ac_status=$?
21144   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21145   (exit $ac_status); }; }; then
21146   ac_cv_lib_m_erfl=yes
21147 else
21148   echo "$as_me: failed program was:" >&5
21149 sed 's/^/| /' conftest.$ac_ext >&5
21150
21151 ac_cv_lib_m_erfl=no
21152 fi
21153 rm -f conftest.err conftest.$ac_objext \
21154       conftest$ac_exeext conftest.$ac_ext
21155 LIBS=$ac_check_lib_save_LIBS
21156 fi
21157 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfl" >&5
21158 echo "${ECHO_T}$ac_cv_lib_m_erfl" >&6
21159 if test $ac_cv_lib_m_erfl = yes; then
21160
21161 cat >>confdefs.h <<\_ACEOF
21162 #define HAVE_ERFL 1
21163 _ACEOF
21164
21165 fi
21166
21167 echo "$as_me:$LINENO: checking for erfcf in -lm" >&5
21168 echo $ECHO_N "checking for erfcf in -lm... $ECHO_C" >&6
21169 if test "${ac_cv_lib_m_erfcf+set}" = set; then
21170   echo $ECHO_N "(cached) $ECHO_C" >&6
21171 else
21172   ac_check_lib_save_LIBS=$LIBS
21173 LIBS="-lm  $LIBS"
21174 if test x$gcc_no_link = xyes; then
21175   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21176 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21177    { (exit 1); exit 1; }; }
21178 fi
21179 cat >conftest.$ac_ext <<_ACEOF
21180 /* confdefs.h.  */
21181 _ACEOF
21182 cat confdefs.h >>conftest.$ac_ext
21183 cat >>conftest.$ac_ext <<_ACEOF
21184 /* end confdefs.h.  */
21185
21186 /* Override any gcc2 internal prototype to avoid an error.  */
21187 #ifdef __cplusplus
21188 extern "C"
21189 #endif
21190 /* We use char because int might match the return type of a gcc2
21191    builtin and then its argument prototype would still apply.  */
21192 char erfcf ();
21193 int
21194 main ()
21195 {
21196 erfcf ();
21197   ;
21198   return 0;
21199 }
21200 _ACEOF
21201 rm -f conftest.$ac_objext conftest$ac_exeext
21202 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21203   (eval $ac_link) 2>conftest.er1
21204   ac_status=$?
21205   grep -v '^ *+' conftest.er1 >conftest.err
21206   rm -f conftest.er1
21207   cat conftest.err >&5
21208   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21209   (exit $ac_status); } &&
21210          { ac_try='test -z "$ac_c_werror_flag"
21211                          || test ! -s conftest.err'
21212   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21213   (eval $ac_try) 2>&5
21214   ac_status=$?
21215   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21216   (exit $ac_status); }; } &&
21217          { ac_try='test -s conftest$ac_exeext'
21218   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21219   (eval $ac_try) 2>&5
21220   ac_status=$?
21221   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21222   (exit $ac_status); }; }; then
21223   ac_cv_lib_m_erfcf=yes
21224 else
21225   echo "$as_me: failed program was:" >&5
21226 sed 's/^/| /' conftest.$ac_ext >&5
21227
21228 ac_cv_lib_m_erfcf=no
21229 fi
21230 rm -f conftest.err conftest.$ac_objext \
21231       conftest$ac_exeext conftest.$ac_ext
21232 LIBS=$ac_check_lib_save_LIBS
21233 fi
21234 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfcf" >&5
21235 echo "${ECHO_T}$ac_cv_lib_m_erfcf" >&6
21236 if test $ac_cv_lib_m_erfcf = yes; then
21237
21238 cat >>confdefs.h <<\_ACEOF
21239 #define HAVE_ERFCF 1
21240 _ACEOF
21241
21242 fi
21243
21244 echo "$as_me:$LINENO: checking for erfc in -lm" >&5
21245 echo $ECHO_N "checking for erfc in -lm... $ECHO_C" >&6
21246 if test "${ac_cv_lib_m_erfc+set}" = set; then
21247   echo $ECHO_N "(cached) $ECHO_C" >&6
21248 else
21249   ac_check_lib_save_LIBS=$LIBS
21250 LIBS="-lm  $LIBS"
21251 if test x$gcc_no_link = xyes; then
21252   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21253 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21254    { (exit 1); exit 1; }; }
21255 fi
21256 cat >conftest.$ac_ext <<_ACEOF
21257 /* confdefs.h.  */
21258 _ACEOF
21259 cat confdefs.h >>conftest.$ac_ext
21260 cat >>conftest.$ac_ext <<_ACEOF
21261 /* end confdefs.h.  */
21262
21263 /* Override any gcc2 internal prototype to avoid an error.  */
21264 #ifdef __cplusplus
21265 extern "C"
21266 #endif
21267 /* We use char because int might match the return type of a gcc2
21268    builtin and then its argument prototype would still apply.  */
21269 char erfc ();
21270 int
21271 main ()
21272 {
21273 erfc ();
21274   ;
21275   return 0;
21276 }
21277 _ACEOF
21278 rm -f conftest.$ac_objext conftest$ac_exeext
21279 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21280   (eval $ac_link) 2>conftest.er1
21281   ac_status=$?
21282   grep -v '^ *+' conftest.er1 >conftest.err
21283   rm -f conftest.er1
21284   cat conftest.err >&5
21285   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21286   (exit $ac_status); } &&
21287          { ac_try='test -z "$ac_c_werror_flag"
21288                          || test ! -s conftest.err'
21289   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21290   (eval $ac_try) 2>&5
21291   ac_status=$?
21292   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21293   (exit $ac_status); }; } &&
21294          { ac_try='test -s conftest$ac_exeext'
21295   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21296   (eval $ac_try) 2>&5
21297   ac_status=$?
21298   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21299   (exit $ac_status); }; }; then
21300   ac_cv_lib_m_erfc=yes
21301 else
21302   echo "$as_me: failed program was:" >&5
21303 sed 's/^/| /' conftest.$ac_ext >&5
21304
21305 ac_cv_lib_m_erfc=no
21306 fi
21307 rm -f conftest.err conftest.$ac_objext \
21308       conftest$ac_exeext conftest.$ac_ext
21309 LIBS=$ac_check_lib_save_LIBS
21310 fi
21311 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfc" >&5
21312 echo "${ECHO_T}$ac_cv_lib_m_erfc" >&6
21313 if test $ac_cv_lib_m_erfc = yes; then
21314
21315 cat >>confdefs.h <<\_ACEOF
21316 #define HAVE_ERFC 1
21317 _ACEOF
21318
21319 fi
21320
21321 echo "$as_me:$LINENO: checking for erfcl in -lm" >&5
21322 echo $ECHO_N "checking for erfcl in -lm... $ECHO_C" >&6
21323 if test "${ac_cv_lib_m_erfcl+set}" = set; then
21324   echo $ECHO_N "(cached) $ECHO_C" >&6
21325 else
21326   ac_check_lib_save_LIBS=$LIBS
21327 LIBS="-lm  $LIBS"
21328 if test x$gcc_no_link = xyes; then
21329   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21330 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21331    { (exit 1); exit 1; }; }
21332 fi
21333 cat >conftest.$ac_ext <<_ACEOF
21334 /* confdefs.h.  */
21335 _ACEOF
21336 cat confdefs.h >>conftest.$ac_ext
21337 cat >>conftest.$ac_ext <<_ACEOF
21338 /* end confdefs.h.  */
21339
21340 /* Override any gcc2 internal prototype to avoid an error.  */
21341 #ifdef __cplusplus
21342 extern "C"
21343 #endif
21344 /* We use char because int might match the return type of a gcc2
21345    builtin and then its argument prototype would still apply.  */
21346 char erfcl ();
21347 int
21348 main ()
21349 {
21350 erfcl ();
21351   ;
21352   return 0;
21353 }
21354 _ACEOF
21355 rm -f conftest.$ac_objext conftest$ac_exeext
21356 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21357   (eval $ac_link) 2>conftest.er1
21358   ac_status=$?
21359   grep -v '^ *+' conftest.er1 >conftest.err
21360   rm -f conftest.er1
21361   cat conftest.err >&5
21362   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21363   (exit $ac_status); } &&
21364          { ac_try='test -z "$ac_c_werror_flag"
21365                          || test ! -s conftest.err'
21366   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21367   (eval $ac_try) 2>&5
21368   ac_status=$?
21369   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21370   (exit $ac_status); }; } &&
21371          { ac_try='test -s conftest$ac_exeext'
21372   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21373   (eval $ac_try) 2>&5
21374   ac_status=$?
21375   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21376   (exit $ac_status); }; }; then
21377   ac_cv_lib_m_erfcl=yes
21378 else
21379   echo "$as_me: failed program was:" >&5
21380 sed 's/^/| /' conftest.$ac_ext >&5
21381
21382 ac_cv_lib_m_erfcl=no
21383 fi
21384 rm -f conftest.err conftest.$ac_objext \
21385       conftest$ac_exeext conftest.$ac_ext
21386 LIBS=$ac_check_lib_save_LIBS
21387 fi
21388 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfcl" >&5
21389 echo "${ECHO_T}$ac_cv_lib_m_erfcl" >&6
21390 if test $ac_cv_lib_m_erfcl = yes; then
21391
21392 cat >>confdefs.h <<\_ACEOF
21393 #define HAVE_ERFCL 1
21394 _ACEOF
21395
21396 fi
21397
21398 echo "$as_me:$LINENO: checking for j0f in -lm" >&5
21399 echo $ECHO_N "checking for j0f in -lm... $ECHO_C" >&6
21400 if test "${ac_cv_lib_m_j0f+set}" = set; then
21401   echo $ECHO_N "(cached) $ECHO_C" >&6
21402 else
21403   ac_check_lib_save_LIBS=$LIBS
21404 LIBS="-lm  $LIBS"
21405 if test x$gcc_no_link = xyes; then
21406   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21407 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21408    { (exit 1); exit 1; }; }
21409 fi
21410 cat >conftest.$ac_ext <<_ACEOF
21411 /* confdefs.h.  */
21412 _ACEOF
21413 cat confdefs.h >>conftest.$ac_ext
21414 cat >>conftest.$ac_ext <<_ACEOF
21415 /* end confdefs.h.  */
21416
21417 /* Override any gcc2 internal prototype to avoid an error.  */
21418 #ifdef __cplusplus
21419 extern "C"
21420 #endif
21421 /* We use char because int might match the return type of a gcc2
21422    builtin and then its argument prototype would still apply.  */
21423 char j0f ();
21424 int
21425 main ()
21426 {
21427 j0f ();
21428   ;
21429   return 0;
21430 }
21431 _ACEOF
21432 rm -f conftest.$ac_objext conftest$ac_exeext
21433 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21434   (eval $ac_link) 2>conftest.er1
21435   ac_status=$?
21436   grep -v '^ *+' conftest.er1 >conftest.err
21437   rm -f conftest.er1
21438   cat conftest.err >&5
21439   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21440   (exit $ac_status); } &&
21441          { ac_try='test -z "$ac_c_werror_flag"
21442                          || test ! -s conftest.err'
21443   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21444   (eval $ac_try) 2>&5
21445   ac_status=$?
21446   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21447   (exit $ac_status); }; } &&
21448          { ac_try='test -s conftest$ac_exeext'
21449   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21450   (eval $ac_try) 2>&5
21451   ac_status=$?
21452   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21453   (exit $ac_status); }; }; then
21454   ac_cv_lib_m_j0f=yes
21455 else
21456   echo "$as_me: failed program was:" >&5
21457 sed 's/^/| /' conftest.$ac_ext >&5
21458
21459 ac_cv_lib_m_j0f=no
21460 fi
21461 rm -f conftest.err conftest.$ac_objext \
21462       conftest$ac_exeext conftest.$ac_ext
21463 LIBS=$ac_check_lib_save_LIBS
21464 fi
21465 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0f" >&5
21466 echo "${ECHO_T}$ac_cv_lib_m_j0f" >&6
21467 if test $ac_cv_lib_m_j0f = yes; then
21468
21469 cat >>confdefs.h <<\_ACEOF
21470 #define HAVE_J0F 1
21471 _ACEOF
21472
21473 fi
21474
21475 echo "$as_me:$LINENO: checking for j0 in -lm" >&5
21476 echo $ECHO_N "checking for j0 in -lm... $ECHO_C" >&6
21477 if test "${ac_cv_lib_m_j0+set}" = set; then
21478   echo $ECHO_N "(cached) $ECHO_C" >&6
21479 else
21480   ac_check_lib_save_LIBS=$LIBS
21481 LIBS="-lm  $LIBS"
21482 if test x$gcc_no_link = xyes; then
21483   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21484 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21485    { (exit 1); exit 1; }; }
21486 fi
21487 cat >conftest.$ac_ext <<_ACEOF
21488 /* confdefs.h.  */
21489 _ACEOF
21490 cat confdefs.h >>conftest.$ac_ext
21491 cat >>conftest.$ac_ext <<_ACEOF
21492 /* end confdefs.h.  */
21493
21494 /* Override any gcc2 internal prototype to avoid an error.  */
21495 #ifdef __cplusplus
21496 extern "C"
21497 #endif
21498 /* We use char because int might match the return type of a gcc2
21499    builtin and then its argument prototype would still apply.  */
21500 char j0 ();
21501 int
21502 main ()
21503 {
21504 j0 ();
21505   ;
21506   return 0;
21507 }
21508 _ACEOF
21509 rm -f conftest.$ac_objext conftest$ac_exeext
21510 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21511   (eval $ac_link) 2>conftest.er1
21512   ac_status=$?
21513   grep -v '^ *+' conftest.er1 >conftest.err
21514   rm -f conftest.er1
21515   cat conftest.err >&5
21516   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21517   (exit $ac_status); } &&
21518          { ac_try='test -z "$ac_c_werror_flag"
21519                          || test ! -s conftest.err'
21520   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21521   (eval $ac_try) 2>&5
21522   ac_status=$?
21523   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21524   (exit $ac_status); }; } &&
21525          { ac_try='test -s conftest$ac_exeext'
21526   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21527   (eval $ac_try) 2>&5
21528   ac_status=$?
21529   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21530   (exit $ac_status); }; }; then
21531   ac_cv_lib_m_j0=yes
21532 else
21533   echo "$as_me: failed program was:" >&5
21534 sed 's/^/| /' conftest.$ac_ext >&5
21535
21536 ac_cv_lib_m_j0=no
21537 fi
21538 rm -f conftest.err conftest.$ac_objext \
21539       conftest$ac_exeext conftest.$ac_ext
21540 LIBS=$ac_check_lib_save_LIBS
21541 fi
21542 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0" >&5
21543 echo "${ECHO_T}$ac_cv_lib_m_j0" >&6
21544 if test $ac_cv_lib_m_j0 = yes; then
21545
21546 cat >>confdefs.h <<\_ACEOF
21547 #define HAVE_J0 1
21548 _ACEOF
21549
21550 fi
21551
21552 echo "$as_me:$LINENO: checking for j0l in -lm" >&5
21553 echo $ECHO_N "checking for j0l in -lm... $ECHO_C" >&6
21554 if test "${ac_cv_lib_m_j0l+set}" = set; then
21555   echo $ECHO_N "(cached) $ECHO_C" >&6
21556 else
21557   ac_check_lib_save_LIBS=$LIBS
21558 LIBS="-lm  $LIBS"
21559 if test x$gcc_no_link = xyes; then
21560   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21561 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21562    { (exit 1); exit 1; }; }
21563 fi
21564 cat >conftest.$ac_ext <<_ACEOF
21565 /* confdefs.h.  */
21566 _ACEOF
21567 cat confdefs.h >>conftest.$ac_ext
21568 cat >>conftest.$ac_ext <<_ACEOF
21569 /* end confdefs.h.  */
21570
21571 /* Override any gcc2 internal prototype to avoid an error.  */
21572 #ifdef __cplusplus
21573 extern "C"
21574 #endif
21575 /* We use char because int might match the return type of a gcc2
21576    builtin and then its argument prototype would still apply.  */
21577 char j0l ();
21578 int
21579 main ()
21580 {
21581 j0l ();
21582   ;
21583   return 0;
21584 }
21585 _ACEOF
21586 rm -f conftest.$ac_objext conftest$ac_exeext
21587 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21588   (eval $ac_link) 2>conftest.er1
21589   ac_status=$?
21590   grep -v '^ *+' conftest.er1 >conftest.err
21591   rm -f conftest.er1
21592   cat conftest.err >&5
21593   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21594   (exit $ac_status); } &&
21595          { ac_try='test -z "$ac_c_werror_flag"
21596                          || test ! -s conftest.err'
21597   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21598   (eval $ac_try) 2>&5
21599   ac_status=$?
21600   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21601   (exit $ac_status); }; } &&
21602          { ac_try='test -s conftest$ac_exeext'
21603   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21604   (eval $ac_try) 2>&5
21605   ac_status=$?
21606   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21607   (exit $ac_status); }; }; then
21608   ac_cv_lib_m_j0l=yes
21609 else
21610   echo "$as_me: failed program was:" >&5
21611 sed 's/^/| /' conftest.$ac_ext >&5
21612
21613 ac_cv_lib_m_j0l=no
21614 fi
21615 rm -f conftest.err conftest.$ac_objext \
21616       conftest$ac_exeext conftest.$ac_ext
21617 LIBS=$ac_check_lib_save_LIBS
21618 fi
21619 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0l" >&5
21620 echo "${ECHO_T}$ac_cv_lib_m_j0l" >&6
21621 if test $ac_cv_lib_m_j0l = yes; then
21622
21623 cat >>confdefs.h <<\_ACEOF
21624 #define HAVE_J0L 1
21625 _ACEOF
21626
21627 fi
21628
21629 echo "$as_me:$LINENO: checking for j1f in -lm" >&5
21630 echo $ECHO_N "checking for j1f in -lm... $ECHO_C" >&6
21631 if test "${ac_cv_lib_m_j1f+set}" = set; then
21632   echo $ECHO_N "(cached) $ECHO_C" >&6
21633 else
21634   ac_check_lib_save_LIBS=$LIBS
21635 LIBS="-lm  $LIBS"
21636 if test x$gcc_no_link = xyes; then
21637   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21638 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21639    { (exit 1); exit 1; }; }
21640 fi
21641 cat >conftest.$ac_ext <<_ACEOF
21642 /* confdefs.h.  */
21643 _ACEOF
21644 cat confdefs.h >>conftest.$ac_ext
21645 cat >>conftest.$ac_ext <<_ACEOF
21646 /* end confdefs.h.  */
21647
21648 /* Override any gcc2 internal prototype to avoid an error.  */
21649 #ifdef __cplusplus
21650 extern "C"
21651 #endif
21652 /* We use char because int might match the return type of a gcc2
21653    builtin and then its argument prototype would still apply.  */
21654 char j1f ();
21655 int
21656 main ()
21657 {
21658 j1f ();
21659   ;
21660   return 0;
21661 }
21662 _ACEOF
21663 rm -f conftest.$ac_objext conftest$ac_exeext
21664 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21665   (eval $ac_link) 2>conftest.er1
21666   ac_status=$?
21667   grep -v '^ *+' conftest.er1 >conftest.err
21668   rm -f conftest.er1
21669   cat conftest.err >&5
21670   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21671   (exit $ac_status); } &&
21672          { ac_try='test -z "$ac_c_werror_flag"
21673                          || test ! -s conftest.err'
21674   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21675   (eval $ac_try) 2>&5
21676   ac_status=$?
21677   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21678   (exit $ac_status); }; } &&
21679          { ac_try='test -s conftest$ac_exeext'
21680   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21681   (eval $ac_try) 2>&5
21682   ac_status=$?
21683   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21684   (exit $ac_status); }; }; then
21685   ac_cv_lib_m_j1f=yes
21686 else
21687   echo "$as_me: failed program was:" >&5
21688 sed 's/^/| /' conftest.$ac_ext >&5
21689
21690 ac_cv_lib_m_j1f=no
21691 fi
21692 rm -f conftest.err conftest.$ac_objext \
21693       conftest$ac_exeext conftest.$ac_ext
21694 LIBS=$ac_check_lib_save_LIBS
21695 fi
21696 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1f" >&5
21697 echo "${ECHO_T}$ac_cv_lib_m_j1f" >&6
21698 if test $ac_cv_lib_m_j1f = yes; then
21699
21700 cat >>confdefs.h <<\_ACEOF
21701 #define HAVE_J1F 1
21702 _ACEOF
21703
21704 fi
21705
21706 echo "$as_me:$LINENO: checking for j1 in -lm" >&5
21707 echo $ECHO_N "checking for j1 in -lm... $ECHO_C" >&6
21708 if test "${ac_cv_lib_m_j1+set}" = set; then
21709   echo $ECHO_N "(cached) $ECHO_C" >&6
21710 else
21711   ac_check_lib_save_LIBS=$LIBS
21712 LIBS="-lm  $LIBS"
21713 if test x$gcc_no_link = xyes; then
21714   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21715 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21716    { (exit 1); exit 1; }; }
21717 fi
21718 cat >conftest.$ac_ext <<_ACEOF
21719 /* confdefs.h.  */
21720 _ACEOF
21721 cat confdefs.h >>conftest.$ac_ext
21722 cat >>conftest.$ac_ext <<_ACEOF
21723 /* end confdefs.h.  */
21724
21725 /* Override any gcc2 internal prototype to avoid an error.  */
21726 #ifdef __cplusplus
21727 extern "C"
21728 #endif
21729 /* We use char because int might match the return type of a gcc2
21730    builtin and then its argument prototype would still apply.  */
21731 char j1 ();
21732 int
21733 main ()
21734 {
21735 j1 ();
21736   ;
21737   return 0;
21738 }
21739 _ACEOF
21740 rm -f conftest.$ac_objext conftest$ac_exeext
21741 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21742   (eval $ac_link) 2>conftest.er1
21743   ac_status=$?
21744   grep -v '^ *+' conftest.er1 >conftest.err
21745   rm -f conftest.er1
21746   cat conftest.err >&5
21747   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21748   (exit $ac_status); } &&
21749          { ac_try='test -z "$ac_c_werror_flag"
21750                          || test ! -s conftest.err'
21751   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21752   (eval $ac_try) 2>&5
21753   ac_status=$?
21754   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21755   (exit $ac_status); }; } &&
21756          { ac_try='test -s conftest$ac_exeext'
21757   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21758   (eval $ac_try) 2>&5
21759   ac_status=$?
21760   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21761   (exit $ac_status); }; }; then
21762   ac_cv_lib_m_j1=yes
21763 else
21764   echo "$as_me: failed program was:" >&5
21765 sed 's/^/| /' conftest.$ac_ext >&5
21766
21767 ac_cv_lib_m_j1=no
21768 fi
21769 rm -f conftest.err conftest.$ac_objext \
21770       conftest$ac_exeext conftest.$ac_ext
21771 LIBS=$ac_check_lib_save_LIBS
21772 fi
21773 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1" >&5
21774 echo "${ECHO_T}$ac_cv_lib_m_j1" >&6
21775 if test $ac_cv_lib_m_j1 = yes; then
21776
21777 cat >>confdefs.h <<\_ACEOF
21778 #define HAVE_J1 1
21779 _ACEOF
21780
21781 fi
21782
21783 echo "$as_me:$LINENO: checking for j1l in -lm" >&5
21784 echo $ECHO_N "checking for j1l in -lm... $ECHO_C" >&6
21785 if test "${ac_cv_lib_m_j1l+set}" = set; then
21786   echo $ECHO_N "(cached) $ECHO_C" >&6
21787 else
21788   ac_check_lib_save_LIBS=$LIBS
21789 LIBS="-lm  $LIBS"
21790 if test x$gcc_no_link = xyes; then
21791   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21792 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21793    { (exit 1); exit 1; }; }
21794 fi
21795 cat >conftest.$ac_ext <<_ACEOF
21796 /* confdefs.h.  */
21797 _ACEOF
21798 cat confdefs.h >>conftest.$ac_ext
21799 cat >>conftest.$ac_ext <<_ACEOF
21800 /* end confdefs.h.  */
21801
21802 /* Override any gcc2 internal prototype to avoid an error.  */
21803 #ifdef __cplusplus
21804 extern "C"
21805 #endif
21806 /* We use char because int might match the return type of a gcc2
21807    builtin and then its argument prototype would still apply.  */
21808 char j1l ();
21809 int
21810 main ()
21811 {
21812 j1l ();
21813   ;
21814   return 0;
21815 }
21816 _ACEOF
21817 rm -f conftest.$ac_objext conftest$ac_exeext
21818 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21819   (eval $ac_link) 2>conftest.er1
21820   ac_status=$?
21821   grep -v '^ *+' conftest.er1 >conftest.err
21822   rm -f conftest.er1
21823   cat conftest.err >&5
21824   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21825   (exit $ac_status); } &&
21826          { ac_try='test -z "$ac_c_werror_flag"
21827                          || test ! -s conftest.err'
21828   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21829   (eval $ac_try) 2>&5
21830   ac_status=$?
21831   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21832   (exit $ac_status); }; } &&
21833          { ac_try='test -s conftest$ac_exeext'
21834   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21835   (eval $ac_try) 2>&5
21836   ac_status=$?
21837   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21838   (exit $ac_status); }; }; then
21839   ac_cv_lib_m_j1l=yes
21840 else
21841   echo "$as_me: failed program was:" >&5
21842 sed 's/^/| /' conftest.$ac_ext >&5
21843
21844 ac_cv_lib_m_j1l=no
21845 fi
21846 rm -f conftest.err conftest.$ac_objext \
21847       conftest$ac_exeext conftest.$ac_ext
21848 LIBS=$ac_check_lib_save_LIBS
21849 fi
21850 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1l" >&5
21851 echo "${ECHO_T}$ac_cv_lib_m_j1l" >&6
21852 if test $ac_cv_lib_m_j1l = yes; then
21853
21854 cat >>confdefs.h <<\_ACEOF
21855 #define HAVE_J1L 1
21856 _ACEOF
21857
21858 fi
21859
21860 echo "$as_me:$LINENO: checking for jnf in -lm" >&5
21861 echo $ECHO_N "checking for jnf in -lm... $ECHO_C" >&6
21862 if test "${ac_cv_lib_m_jnf+set}" = set; then
21863   echo $ECHO_N "(cached) $ECHO_C" >&6
21864 else
21865   ac_check_lib_save_LIBS=$LIBS
21866 LIBS="-lm  $LIBS"
21867 if test x$gcc_no_link = xyes; then
21868   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21869 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21870    { (exit 1); exit 1; }; }
21871 fi
21872 cat >conftest.$ac_ext <<_ACEOF
21873 /* confdefs.h.  */
21874 _ACEOF
21875 cat confdefs.h >>conftest.$ac_ext
21876 cat >>conftest.$ac_ext <<_ACEOF
21877 /* end confdefs.h.  */
21878
21879 /* Override any gcc2 internal prototype to avoid an error.  */
21880 #ifdef __cplusplus
21881 extern "C"
21882 #endif
21883 /* We use char because int might match the return type of a gcc2
21884    builtin and then its argument prototype would still apply.  */
21885 char jnf ();
21886 int
21887 main ()
21888 {
21889 jnf ();
21890   ;
21891   return 0;
21892 }
21893 _ACEOF
21894 rm -f conftest.$ac_objext conftest$ac_exeext
21895 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21896   (eval $ac_link) 2>conftest.er1
21897   ac_status=$?
21898   grep -v '^ *+' conftest.er1 >conftest.err
21899   rm -f conftest.er1
21900   cat conftest.err >&5
21901   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21902   (exit $ac_status); } &&
21903          { ac_try='test -z "$ac_c_werror_flag"
21904                          || test ! -s conftest.err'
21905   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21906   (eval $ac_try) 2>&5
21907   ac_status=$?
21908   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21909   (exit $ac_status); }; } &&
21910          { ac_try='test -s conftest$ac_exeext'
21911   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21912   (eval $ac_try) 2>&5
21913   ac_status=$?
21914   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21915   (exit $ac_status); }; }; then
21916   ac_cv_lib_m_jnf=yes
21917 else
21918   echo "$as_me: failed program was:" >&5
21919 sed 's/^/| /' conftest.$ac_ext >&5
21920
21921 ac_cv_lib_m_jnf=no
21922 fi
21923 rm -f conftest.err conftest.$ac_objext \
21924       conftest$ac_exeext conftest.$ac_ext
21925 LIBS=$ac_check_lib_save_LIBS
21926 fi
21927 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jnf" >&5
21928 echo "${ECHO_T}$ac_cv_lib_m_jnf" >&6
21929 if test $ac_cv_lib_m_jnf = yes; then
21930
21931 cat >>confdefs.h <<\_ACEOF
21932 #define HAVE_JNF 1
21933 _ACEOF
21934
21935 fi
21936
21937 echo "$as_me:$LINENO: checking for jn in -lm" >&5
21938 echo $ECHO_N "checking for jn in -lm... $ECHO_C" >&6
21939 if test "${ac_cv_lib_m_jn+set}" = set; then
21940   echo $ECHO_N "(cached) $ECHO_C" >&6
21941 else
21942   ac_check_lib_save_LIBS=$LIBS
21943 LIBS="-lm  $LIBS"
21944 if test x$gcc_no_link = xyes; then
21945   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21946 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21947    { (exit 1); exit 1; }; }
21948 fi
21949 cat >conftest.$ac_ext <<_ACEOF
21950 /* confdefs.h.  */
21951 _ACEOF
21952 cat confdefs.h >>conftest.$ac_ext
21953 cat >>conftest.$ac_ext <<_ACEOF
21954 /* end confdefs.h.  */
21955
21956 /* Override any gcc2 internal prototype to avoid an error.  */
21957 #ifdef __cplusplus
21958 extern "C"
21959 #endif
21960 /* We use char because int might match the return type of a gcc2
21961    builtin and then its argument prototype would still apply.  */
21962 char jn ();
21963 int
21964 main ()
21965 {
21966 jn ();
21967   ;
21968   return 0;
21969 }
21970 _ACEOF
21971 rm -f conftest.$ac_objext conftest$ac_exeext
21972 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21973   (eval $ac_link) 2>conftest.er1
21974   ac_status=$?
21975   grep -v '^ *+' conftest.er1 >conftest.err
21976   rm -f conftest.er1
21977   cat conftest.err >&5
21978   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21979   (exit $ac_status); } &&
21980          { ac_try='test -z "$ac_c_werror_flag"
21981                          || test ! -s conftest.err'
21982   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21983   (eval $ac_try) 2>&5
21984   ac_status=$?
21985   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21986   (exit $ac_status); }; } &&
21987          { ac_try='test -s conftest$ac_exeext'
21988   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21989   (eval $ac_try) 2>&5
21990   ac_status=$?
21991   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21992   (exit $ac_status); }; }; then
21993   ac_cv_lib_m_jn=yes
21994 else
21995   echo "$as_me: failed program was:" >&5
21996 sed 's/^/| /' conftest.$ac_ext >&5
21997
21998 ac_cv_lib_m_jn=no
21999 fi
22000 rm -f conftest.err conftest.$ac_objext \
22001       conftest$ac_exeext conftest.$ac_ext
22002 LIBS=$ac_check_lib_save_LIBS
22003 fi
22004 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jn" >&5
22005 echo "${ECHO_T}$ac_cv_lib_m_jn" >&6
22006 if test $ac_cv_lib_m_jn = yes; then
22007
22008 cat >>confdefs.h <<\_ACEOF
22009 #define HAVE_JN 1
22010 _ACEOF
22011
22012 fi
22013
22014 echo "$as_me:$LINENO: checking for jnl in -lm" >&5
22015 echo $ECHO_N "checking for jnl in -lm... $ECHO_C" >&6
22016 if test "${ac_cv_lib_m_jnl+set}" = set; then
22017   echo $ECHO_N "(cached) $ECHO_C" >&6
22018 else
22019   ac_check_lib_save_LIBS=$LIBS
22020 LIBS="-lm  $LIBS"
22021 if test x$gcc_no_link = xyes; then
22022   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22023 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22024    { (exit 1); exit 1; }; }
22025 fi
22026 cat >conftest.$ac_ext <<_ACEOF
22027 /* confdefs.h.  */
22028 _ACEOF
22029 cat confdefs.h >>conftest.$ac_ext
22030 cat >>conftest.$ac_ext <<_ACEOF
22031 /* end confdefs.h.  */
22032
22033 /* Override any gcc2 internal prototype to avoid an error.  */
22034 #ifdef __cplusplus
22035 extern "C"
22036 #endif
22037 /* We use char because int might match the return type of a gcc2
22038    builtin and then its argument prototype would still apply.  */
22039 char jnl ();
22040 int
22041 main ()
22042 {
22043 jnl ();
22044   ;
22045   return 0;
22046 }
22047 _ACEOF
22048 rm -f conftest.$ac_objext conftest$ac_exeext
22049 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22050   (eval $ac_link) 2>conftest.er1
22051   ac_status=$?
22052   grep -v '^ *+' conftest.er1 >conftest.err
22053   rm -f conftest.er1
22054   cat conftest.err >&5
22055   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22056   (exit $ac_status); } &&
22057          { ac_try='test -z "$ac_c_werror_flag"
22058                          || test ! -s conftest.err'
22059   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22060   (eval $ac_try) 2>&5
22061   ac_status=$?
22062   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22063   (exit $ac_status); }; } &&
22064          { ac_try='test -s conftest$ac_exeext'
22065   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22066   (eval $ac_try) 2>&5
22067   ac_status=$?
22068   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22069   (exit $ac_status); }; }; then
22070   ac_cv_lib_m_jnl=yes
22071 else
22072   echo "$as_me: failed program was:" >&5
22073 sed 's/^/| /' conftest.$ac_ext >&5
22074
22075 ac_cv_lib_m_jnl=no
22076 fi
22077 rm -f conftest.err conftest.$ac_objext \
22078       conftest$ac_exeext conftest.$ac_ext
22079 LIBS=$ac_check_lib_save_LIBS
22080 fi
22081 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jnl" >&5
22082 echo "${ECHO_T}$ac_cv_lib_m_jnl" >&6
22083 if test $ac_cv_lib_m_jnl = yes; then
22084
22085 cat >>confdefs.h <<\_ACEOF
22086 #define HAVE_JNL 1
22087 _ACEOF
22088
22089 fi
22090
22091 echo "$as_me:$LINENO: checking for y0f in -lm" >&5
22092 echo $ECHO_N "checking for y0f in -lm... $ECHO_C" >&6
22093 if test "${ac_cv_lib_m_y0f+set}" = set; then
22094   echo $ECHO_N "(cached) $ECHO_C" >&6
22095 else
22096   ac_check_lib_save_LIBS=$LIBS
22097 LIBS="-lm  $LIBS"
22098 if test x$gcc_no_link = xyes; then
22099   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22100 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22101    { (exit 1); exit 1; }; }
22102 fi
22103 cat >conftest.$ac_ext <<_ACEOF
22104 /* confdefs.h.  */
22105 _ACEOF
22106 cat confdefs.h >>conftest.$ac_ext
22107 cat >>conftest.$ac_ext <<_ACEOF
22108 /* end confdefs.h.  */
22109
22110 /* Override any gcc2 internal prototype to avoid an error.  */
22111 #ifdef __cplusplus
22112 extern "C"
22113 #endif
22114 /* We use char because int might match the return type of a gcc2
22115    builtin and then its argument prototype would still apply.  */
22116 char y0f ();
22117 int
22118 main ()
22119 {
22120 y0f ();
22121   ;
22122   return 0;
22123 }
22124 _ACEOF
22125 rm -f conftest.$ac_objext conftest$ac_exeext
22126 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22127   (eval $ac_link) 2>conftest.er1
22128   ac_status=$?
22129   grep -v '^ *+' conftest.er1 >conftest.err
22130   rm -f conftest.er1
22131   cat conftest.err >&5
22132   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22133   (exit $ac_status); } &&
22134          { ac_try='test -z "$ac_c_werror_flag"
22135                          || test ! -s conftest.err'
22136   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22137   (eval $ac_try) 2>&5
22138   ac_status=$?
22139   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22140   (exit $ac_status); }; } &&
22141          { ac_try='test -s conftest$ac_exeext'
22142   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22143   (eval $ac_try) 2>&5
22144   ac_status=$?
22145   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22146   (exit $ac_status); }; }; then
22147   ac_cv_lib_m_y0f=yes
22148 else
22149   echo "$as_me: failed program was:" >&5
22150 sed 's/^/| /' conftest.$ac_ext >&5
22151
22152 ac_cv_lib_m_y0f=no
22153 fi
22154 rm -f conftest.err conftest.$ac_objext \
22155       conftest$ac_exeext conftest.$ac_ext
22156 LIBS=$ac_check_lib_save_LIBS
22157 fi
22158 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0f" >&5
22159 echo "${ECHO_T}$ac_cv_lib_m_y0f" >&6
22160 if test $ac_cv_lib_m_y0f = yes; then
22161
22162 cat >>confdefs.h <<\_ACEOF
22163 #define HAVE_Y0F 1
22164 _ACEOF
22165
22166 fi
22167
22168 echo "$as_me:$LINENO: checking for y0 in -lm" >&5
22169 echo $ECHO_N "checking for y0 in -lm... $ECHO_C" >&6
22170 if test "${ac_cv_lib_m_y0+set}" = set; then
22171   echo $ECHO_N "(cached) $ECHO_C" >&6
22172 else
22173   ac_check_lib_save_LIBS=$LIBS
22174 LIBS="-lm  $LIBS"
22175 if test x$gcc_no_link = xyes; then
22176   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22177 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22178    { (exit 1); exit 1; }; }
22179 fi
22180 cat >conftest.$ac_ext <<_ACEOF
22181 /* confdefs.h.  */
22182 _ACEOF
22183 cat confdefs.h >>conftest.$ac_ext
22184 cat >>conftest.$ac_ext <<_ACEOF
22185 /* end confdefs.h.  */
22186
22187 /* Override any gcc2 internal prototype to avoid an error.  */
22188 #ifdef __cplusplus
22189 extern "C"
22190 #endif
22191 /* We use char because int might match the return type of a gcc2
22192    builtin and then its argument prototype would still apply.  */
22193 char y0 ();
22194 int
22195 main ()
22196 {
22197 y0 ();
22198   ;
22199   return 0;
22200 }
22201 _ACEOF
22202 rm -f conftest.$ac_objext conftest$ac_exeext
22203 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22204   (eval $ac_link) 2>conftest.er1
22205   ac_status=$?
22206   grep -v '^ *+' conftest.er1 >conftest.err
22207   rm -f conftest.er1
22208   cat conftest.err >&5
22209   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22210   (exit $ac_status); } &&
22211          { ac_try='test -z "$ac_c_werror_flag"
22212                          || test ! -s conftest.err'
22213   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22214   (eval $ac_try) 2>&5
22215   ac_status=$?
22216   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22217   (exit $ac_status); }; } &&
22218          { ac_try='test -s conftest$ac_exeext'
22219   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22220   (eval $ac_try) 2>&5
22221   ac_status=$?
22222   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22223   (exit $ac_status); }; }; then
22224   ac_cv_lib_m_y0=yes
22225 else
22226   echo "$as_me: failed program was:" >&5
22227 sed 's/^/| /' conftest.$ac_ext >&5
22228
22229 ac_cv_lib_m_y0=no
22230 fi
22231 rm -f conftest.err conftest.$ac_objext \
22232       conftest$ac_exeext conftest.$ac_ext
22233 LIBS=$ac_check_lib_save_LIBS
22234 fi
22235 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0" >&5
22236 echo "${ECHO_T}$ac_cv_lib_m_y0" >&6
22237 if test $ac_cv_lib_m_y0 = yes; then
22238
22239 cat >>confdefs.h <<\_ACEOF
22240 #define HAVE_Y0 1
22241 _ACEOF
22242
22243 fi
22244
22245 echo "$as_me:$LINENO: checking for y0l in -lm" >&5
22246 echo $ECHO_N "checking for y0l in -lm... $ECHO_C" >&6
22247 if test "${ac_cv_lib_m_y0l+set}" = set; then
22248   echo $ECHO_N "(cached) $ECHO_C" >&6
22249 else
22250   ac_check_lib_save_LIBS=$LIBS
22251 LIBS="-lm  $LIBS"
22252 if test x$gcc_no_link = xyes; then
22253   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22254 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22255    { (exit 1); exit 1; }; }
22256 fi
22257 cat >conftest.$ac_ext <<_ACEOF
22258 /* confdefs.h.  */
22259 _ACEOF
22260 cat confdefs.h >>conftest.$ac_ext
22261 cat >>conftest.$ac_ext <<_ACEOF
22262 /* end confdefs.h.  */
22263
22264 /* Override any gcc2 internal prototype to avoid an error.  */
22265 #ifdef __cplusplus
22266 extern "C"
22267 #endif
22268 /* We use char because int might match the return type of a gcc2
22269    builtin and then its argument prototype would still apply.  */
22270 char y0l ();
22271 int
22272 main ()
22273 {
22274 y0l ();
22275   ;
22276   return 0;
22277 }
22278 _ACEOF
22279 rm -f conftest.$ac_objext conftest$ac_exeext
22280 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22281   (eval $ac_link) 2>conftest.er1
22282   ac_status=$?
22283   grep -v '^ *+' conftest.er1 >conftest.err
22284   rm -f conftest.er1
22285   cat conftest.err >&5
22286   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22287   (exit $ac_status); } &&
22288          { ac_try='test -z "$ac_c_werror_flag"
22289                          || test ! -s conftest.err'
22290   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22291   (eval $ac_try) 2>&5
22292   ac_status=$?
22293   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22294   (exit $ac_status); }; } &&
22295          { ac_try='test -s conftest$ac_exeext'
22296   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22297   (eval $ac_try) 2>&5
22298   ac_status=$?
22299   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22300   (exit $ac_status); }; }; then
22301   ac_cv_lib_m_y0l=yes
22302 else
22303   echo "$as_me: failed program was:" >&5
22304 sed 's/^/| /' conftest.$ac_ext >&5
22305
22306 ac_cv_lib_m_y0l=no
22307 fi
22308 rm -f conftest.err conftest.$ac_objext \
22309       conftest$ac_exeext conftest.$ac_ext
22310 LIBS=$ac_check_lib_save_LIBS
22311 fi
22312 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0l" >&5
22313 echo "${ECHO_T}$ac_cv_lib_m_y0l" >&6
22314 if test $ac_cv_lib_m_y0l = yes; then
22315
22316 cat >>confdefs.h <<\_ACEOF
22317 #define HAVE_Y0L 1
22318 _ACEOF
22319
22320 fi
22321
22322 echo "$as_me:$LINENO: checking for y1f in -lm" >&5
22323 echo $ECHO_N "checking for y1f in -lm... $ECHO_C" >&6
22324 if test "${ac_cv_lib_m_y1f+set}" = set; then
22325   echo $ECHO_N "(cached) $ECHO_C" >&6
22326 else
22327   ac_check_lib_save_LIBS=$LIBS
22328 LIBS="-lm  $LIBS"
22329 if test x$gcc_no_link = xyes; then
22330   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22331 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22332    { (exit 1); exit 1; }; }
22333 fi
22334 cat >conftest.$ac_ext <<_ACEOF
22335 /* confdefs.h.  */
22336 _ACEOF
22337 cat confdefs.h >>conftest.$ac_ext
22338 cat >>conftest.$ac_ext <<_ACEOF
22339 /* end confdefs.h.  */
22340
22341 /* Override any gcc2 internal prototype to avoid an error.  */
22342 #ifdef __cplusplus
22343 extern "C"
22344 #endif
22345 /* We use char because int might match the return type of a gcc2
22346    builtin and then its argument prototype would still apply.  */
22347 char y1f ();
22348 int
22349 main ()
22350 {
22351 y1f ();
22352   ;
22353   return 0;
22354 }
22355 _ACEOF
22356 rm -f conftest.$ac_objext conftest$ac_exeext
22357 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22358   (eval $ac_link) 2>conftest.er1
22359   ac_status=$?
22360   grep -v '^ *+' conftest.er1 >conftest.err
22361   rm -f conftest.er1
22362   cat conftest.err >&5
22363   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22364   (exit $ac_status); } &&
22365          { ac_try='test -z "$ac_c_werror_flag"
22366                          || test ! -s conftest.err'
22367   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22368   (eval $ac_try) 2>&5
22369   ac_status=$?
22370   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22371   (exit $ac_status); }; } &&
22372          { ac_try='test -s conftest$ac_exeext'
22373   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22374   (eval $ac_try) 2>&5
22375   ac_status=$?
22376   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22377   (exit $ac_status); }; }; then
22378   ac_cv_lib_m_y1f=yes
22379 else
22380   echo "$as_me: failed program was:" >&5
22381 sed 's/^/| /' conftest.$ac_ext >&5
22382
22383 ac_cv_lib_m_y1f=no
22384 fi
22385 rm -f conftest.err conftest.$ac_objext \
22386       conftest$ac_exeext conftest.$ac_ext
22387 LIBS=$ac_check_lib_save_LIBS
22388 fi
22389 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1f" >&5
22390 echo "${ECHO_T}$ac_cv_lib_m_y1f" >&6
22391 if test $ac_cv_lib_m_y1f = yes; then
22392
22393 cat >>confdefs.h <<\_ACEOF
22394 #define HAVE_Y1F 1
22395 _ACEOF
22396
22397 fi
22398
22399 echo "$as_me:$LINENO: checking for y1 in -lm" >&5
22400 echo $ECHO_N "checking for y1 in -lm... $ECHO_C" >&6
22401 if test "${ac_cv_lib_m_y1+set}" = set; then
22402   echo $ECHO_N "(cached) $ECHO_C" >&6
22403 else
22404   ac_check_lib_save_LIBS=$LIBS
22405 LIBS="-lm  $LIBS"
22406 if test x$gcc_no_link = xyes; then
22407   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22408 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22409    { (exit 1); exit 1; }; }
22410 fi
22411 cat >conftest.$ac_ext <<_ACEOF
22412 /* confdefs.h.  */
22413 _ACEOF
22414 cat confdefs.h >>conftest.$ac_ext
22415 cat >>conftest.$ac_ext <<_ACEOF
22416 /* end confdefs.h.  */
22417
22418 /* Override any gcc2 internal prototype to avoid an error.  */
22419 #ifdef __cplusplus
22420 extern "C"
22421 #endif
22422 /* We use char because int might match the return type of a gcc2
22423    builtin and then its argument prototype would still apply.  */
22424 char y1 ();
22425 int
22426 main ()
22427 {
22428 y1 ();
22429   ;
22430   return 0;
22431 }
22432 _ACEOF
22433 rm -f conftest.$ac_objext conftest$ac_exeext
22434 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22435   (eval $ac_link) 2>conftest.er1
22436   ac_status=$?
22437   grep -v '^ *+' conftest.er1 >conftest.err
22438   rm -f conftest.er1
22439   cat conftest.err >&5
22440   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22441   (exit $ac_status); } &&
22442          { ac_try='test -z "$ac_c_werror_flag"
22443                          || test ! -s conftest.err'
22444   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22445   (eval $ac_try) 2>&5
22446   ac_status=$?
22447   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22448   (exit $ac_status); }; } &&
22449          { ac_try='test -s conftest$ac_exeext'
22450   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22451   (eval $ac_try) 2>&5
22452   ac_status=$?
22453   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22454   (exit $ac_status); }; }; then
22455   ac_cv_lib_m_y1=yes
22456 else
22457   echo "$as_me: failed program was:" >&5
22458 sed 's/^/| /' conftest.$ac_ext >&5
22459
22460 ac_cv_lib_m_y1=no
22461 fi
22462 rm -f conftest.err conftest.$ac_objext \
22463       conftest$ac_exeext conftest.$ac_ext
22464 LIBS=$ac_check_lib_save_LIBS
22465 fi
22466 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1" >&5
22467 echo "${ECHO_T}$ac_cv_lib_m_y1" >&6
22468 if test $ac_cv_lib_m_y1 = yes; then
22469
22470 cat >>confdefs.h <<\_ACEOF
22471 #define HAVE_Y1 1
22472 _ACEOF
22473
22474 fi
22475
22476 echo "$as_me:$LINENO: checking for y1l in -lm" >&5
22477 echo $ECHO_N "checking for y1l in -lm... $ECHO_C" >&6
22478 if test "${ac_cv_lib_m_y1l+set}" = set; then
22479   echo $ECHO_N "(cached) $ECHO_C" >&6
22480 else
22481   ac_check_lib_save_LIBS=$LIBS
22482 LIBS="-lm  $LIBS"
22483 if test x$gcc_no_link = xyes; then
22484   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22485 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22486    { (exit 1); exit 1; }; }
22487 fi
22488 cat >conftest.$ac_ext <<_ACEOF
22489 /* confdefs.h.  */
22490 _ACEOF
22491 cat confdefs.h >>conftest.$ac_ext
22492 cat >>conftest.$ac_ext <<_ACEOF
22493 /* end confdefs.h.  */
22494
22495 /* Override any gcc2 internal prototype to avoid an error.  */
22496 #ifdef __cplusplus
22497 extern "C"
22498 #endif
22499 /* We use char because int might match the return type of a gcc2
22500    builtin and then its argument prototype would still apply.  */
22501 char y1l ();
22502 int
22503 main ()
22504 {
22505 y1l ();
22506   ;
22507   return 0;
22508 }
22509 _ACEOF
22510 rm -f conftest.$ac_objext conftest$ac_exeext
22511 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22512   (eval $ac_link) 2>conftest.er1
22513   ac_status=$?
22514   grep -v '^ *+' conftest.er1 >conftest.err
22515   rm -f conftest.er1
22516   cat conftest.err >&5
22517   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22518   (exit $ac_status); } &&
22519          { ac_try='test -z "$ac_c_werror_flag"
22520                          || test ! -s conftest.err'
22521   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22522   (eval $ac_try) 2>&5
22523   ac_status=$?
22524   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22525   (exit $ac_status); }; } &&
22526          { ac_try='test -s conftest$ac_exeext'
22527   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22528   (eval $ac_try) 2>&5
22529   ac_status=$?
22530   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22531   (exit $ac_status); }; }; then
22532   ac_cv_lib_m_y1l=yes
22533 else
22534   echo "$as_me: failed program was:" >&5
22535 sed 's/^/| /' conftest.$ac_ext >&5
22536
22537 ac_cv_lib_m_y1l=no
22538 fi
22539 rm -f conftest.err conftest.$ac_objext \
22540       conftest$ac_exeext conftest.$ac_ext
22541 LIBS=$ac_check_lib_save_LIBS
22542 fi
22543 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1l" >&5
22544 echo "${ECHO_T}$ac_cv_lib_m_y1l" >&6
22545 if test $ac_cv_lib_m_y1l = yes; then
22546
22547 cat >>confdefs.h <<\_ACEOF
22548 #define HAVE_Y1L 1
22549 _ACEOF
22550
22551 fi
22552
22553 echo "$as_me:$LINENO: checking for ynf in -lm" >&5
22554 echo $ECHO_N "checking for ynf in -lm... $ECHO_C" >&6
22555 if test "${ac_cv_lib_m_ynf+set}" = set; then
22556   echo $ECHO_N "(cached) $ECHO_C" >&6
22557 else
22558   ac_check_lib_save_LIBS=$LIBS
22559 LIBS="-lm  $LIBS"
22560 if test x$gcc_no_link = xyes; then
22561   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22562 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22563    { (exit 1); exit 1; }; }
22564 fi
22565 cat >conftest.$ac_ext <<_ACEOF
22566 /* confdefs.h.  */
22567 _ACEOF
22568 cat confdefs.h >>conftest.$ac_ext
22569 cat >>conftest.$ac_ext <<_ACEOF
22570 /* end confdefs.h.  */
22571
22572 /* Override any gcc2 internal prototype to avoid an error.  */
22573 #ifdef __cplusplus
22574 extern "C"
22575 #endif
22576 /* We use char because int might match the return type of a gcc2
22577    builtin and then its argument prototype would still apply.  */
22578 char ynf ();
22579 int
22580 main ()
22581 {
22582 ynf ();
22583   ;
22584   return 0;
22585 }
22586 _ACEOF
22587 rm -f conftest.$ac_objext conftest$ac_exeext
22588 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22589   (eval $ac_link) 2>conftest.er1
22590   ac_status=$?
22591   grep -v '^ *+' conftest.er1 >conftest.err
22592   rm -f conftest.er1
22593   cat conftest.err >&5
22594   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22595   (exit $ac_status); } &&
22596          { ac_try='test -z "$ac_c_werror_flag"
22597                          || test ! -s conftest.err'
22598   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22599   (eval $ac_try) 2>&5
22600   ac_status=$?
22601   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22602   (exit $ac_status); }; } &&
22603          { ac_try='test -s conftest$ac_exeext'
22604   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22605   (eval $ac_try) 2>&5
22606   ac_status=$?
22607   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22608   (exit $ac_status); }; }; then
22609   ac_cv_lib_m_ynf=yes
22610 else
22611   echo "$as_me: failed program was:" >&5
22612 sed 's/^/| /' conftest.$ac_ext >&5
22613
22614 ac_cv_lib_m_ynf=no
22615 fi
22616 rm -f conftest.err conftest.$ac_objext \
22617       conftest$ac_exeext conftest.$ac_ext
22618 LIBS=$ac_check_lib_save_LIBS
22619 fi
22620 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ynf" >&5
22621 echo "${ECHO_T}$ac_cv_lib_m_ynf" >&6
22622 if test $ac_cv_lib_m_ynf = yes; then
22623
22624 cat >>confdefs.h <<\_ACEOF
22625 #define HAVE_YNF 1
22626 _ACEOF
22627
22628 fi
22629
22630 echo "$as_me:$LINENO: checking for yn in -lm" >&5
22631 echo $ECHO_N "checking for yn in -lm... $ECHO_C" >&6
22632 if test "${ac_cv_lib_m_yn+set}" = set; then
22633   echo $ECHO_N "(cached) $ECHO_C" >&6
22634 else
22635   ac_check_lib_save_LIBS=$LIBS
22636 LIBS="-lm  $LIBS"
22637 if test x$gcc_no_link = xyes; then
22638   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22639 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22640    { (exit 1); exit 1; }; }
22641 fi
22642 cat >conftest.$ac_ext <<_ACEOF
22643 /* confdefs.h.  */
22644 _ACEOF
22645 cat confdefs.h >>conftest.$ac_ext
22646 cat >>conftest.$ac_ext <<_ACEOF
22647 /* end confdefs.h.  */
22648
22649 /* Override any gcc2 internal prototype to avoid an error.  */
22650 #ifdef __cplusplus
22651 extern "C"
22652 #endif
22653 /* We use char because int might match the return type of a gcc2
22654    builtin and then its argument prototype would still apply.  */
22655 char yn ();
22656 int
22657 main ()
22658 {
22659 yn ();
22660   ;
22661   return 0;
22662 }
22663 _ACEOF
22664 rm -f conftest.$ac_objext conftest$ac_exeext
22665 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22666   (eval $ac_link) 2>conftest.er1
22667   ac_status=$?
22668   grep -v '^ *+' conftest.er1 >conftest.err
22669   rm -f conftest.er1
22670   cat conftest.err >&5
22671   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22672   (exit $ac_status); } &&
22673          { ac_try='test -z "$ac_c_werror_flag"
22674                          || test ! -s conftest.err'
22675   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22676   (eval $ac_try) 2>&5
22677   ac_status=$?
22678   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22679   (exit $ac_status); }; } &&
22680          { ac_try='test -s conftest$ac_exeext'
22681   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22682   (eval $ac_try) 2>&5
22683   ac_status=$?
22684   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22685   (exit $ac_status); }; }; then
22686   ac_cv_lib_m_yn=yes
22687 else
22688   echo "$as_me: failed program was:" >&5
22689 sed 's/^/| /' conftest.$ac_ext >&5
22690
22691 ac_cv_lib_m_yn=no
22692 fi
22693 rm -f conftest.err conftest.$ac_objext \
22694       conftest$ac_exeext conftest.$ac_ext
22695 LIBS=$ac_check_lib_save_LIBS
22696 fi
22697 echo "$as_me:$LINENO: result: $ac_cv_lib_m_yn" >&5
22698 echo "${ECHO_T}$ac_cv_lib_m_yn" >&6
22699 if test $ac_cv_lib_m_yn = yes; then
22700
22701 cat >>confdefs.h <<\_ACEOF
22702 #define HAVE_YN 1
22703 _ACEOF
22704
22705 fi
22706
22707 echo "$as_me:$LINENO: checking for ynl in -lm" >&5
22708 echo $ECHO_N "checking for ynl in -lm... $ECHO_C" >&6
22709 if test "${ac_cv_lib_m_ynl+set}" = set; then
22710   echo $ECHO_N "(cached) $ECHO_C" >&6
22711 else
22712   ac_check_lib_save_LIBS=$LIBS
22713 LIBS="-lm  $LIBS"
22714 if test x$gcc_no_link = xyes; then
22715   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22716 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22717    { (exit 1); exit 1; }; }
22718 fi
22719 cat >conftest.$ac_ext <<_ACEOF
22720 /* confdefs.h.  */
22721 _ACEOF
22722 cat confdefs.h >>conftest.$ac_ext
22723 cat >>conftest.$ac_ext <<_ACEOF
22724 /* end confdefs.h.  */
22725
22726 /* Override any gcc2 internal prototype to avoid an error.  */
22727 #ifdef __cplusplus
22728 extern "C"
22729 #endif
22730 /* We use char because int might match the return type of a gcc2
22731    builtin and then its argument prototype would still apply.  */
22732 char ynl ();
22733 int
22734 main ()
22735 {
22736 ynl ();
22737   ;
22738   return 0;
22739 }
22740 _ACEOF
22741 rm -f conftest.$ac_objext conftest$ac_exeext
22742 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22743   (eval $ac_link) 2>conftest.er1
22744   ac_status=$?
22745   grep -v '^ *+' conftest.er1 >conftest.err
22746   rm -f conftest.er1
22747   cat conftest.err >&5
22748   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22749   (exit $ac_status); } &&
22750          { ac_try='test -z "$ac_c_werror_flag"
22751                          || test ! -s conftest.err'
22752   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22753   (eval $ac_try) 2>&5
22754   ac_status=$?
22755   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22756   (exit $ac_status); }; } &&
22757          { ac_try='test -s conftest$ac_exeext'
22758   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22759   (eval $ac_try) 2>&5
22760   ac_status=$?
22761   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22762   (exit $ac_status); }; }; then
22763   ac_cv_lib_m_ynl=yes
22764 else
22765   echo "$as_me: failed program was:" >&5
22766 sed 's/^/| /' conftest.$ac_ext >&5
22767
22768 ac_cv_lib_m_ynl=no
22769 fi
22770 rm -f conftest.err conftest.$ac_objext \
22771       conftest$ac_exeext conftest.$ac_ext
22772 LIBS=$ac_check_lib_save_LIBS
22773 fi
22774 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ynl" >&5
22775 echo "${ECHO_T}$ac_cv_lib_m_ynl" >&6
22776 if test $ac_cv_lib_m_ynl = yes; then
22777
22778 cat >>confdefs.h <<\_ACEOF
22779 #define HAVE_YNL 1
22780 _ACEOF
22781
22782 fi
22783
22784
22785 # On AIX, clog is present in libm as __clog
22786 echo "$as_me:$LINENO: checking for __clog in -lm" >&5
22787 echo $ECHO_N "checking for __clog in -lm... $ECHO_C" >&6
22788 if test "${ac_cv_lib_m___clog+set}" = set; then
22789   echo $ECHO_N "(cached) $ECHO_C" >&6
22790 else
22791   ac_check_lib_save_LIBS=$LIBS
22792 LIBS="-lm  $LIBS"
22793 if test x$gcc_no_link = xyes; then
22794   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22795 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22796    { (exit 1); exit 1; }; }
22797 fi
22798 cat >conftest.$ac_ext <<_ACEOF
22799 /* confdefs.h.  */
22800 _ACEOF
22801 cat confdefs.h >>conftest.$ac_ext
22802 cat >>conftest.$ac_ext <<_ACEOF
22803 /* end confdefs.h.  */
22804
22805 /* Override any gcc2 internal prototype to avoid an error.  */
22806 #ifdef __cplusplus
22807 extern "C"
22808 #endif
22809 /* We use char because int might match the return type of a gcc2
22810    builtin and then its argument prototype would still apply.  */
22811 char __clog ();
22812 int
22813 main ()
22814 {
22815 __clog ();
22816   ;
22817   return 0;
22818 }
22819 _ACEOF
22820 rm -f conftest.$ac_objext conftest$ac_exeext
22821 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22822   (eval $ac_link) 2>conftest.er1
22823   ac_status=$?
22824   grep -v '^ *+' conftest.er1 >conftest.err
22825   rm -f conftest.er1
22826   cat conftest.err >&5
22827   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22828   (exit $ac_status); } &&
22829          { ac_try='test -z "$ac_c_werror_flag"
22830                          || test ! -s conftest.err'
22831   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22832   (eval $ac_try) 2>&5
22833   ac_status=$?
22834   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22835   (exit $ac_status); }; } &&
22836          { ac_try='test -s conftest$ac_exeext'
22837   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22838   (eval $ac_try) 2>&5
22839   ac_status=$?
22840   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22841   (exit $ac_status); }; }; then
22842   ac_cv_lib_m___clog=yes
22843 else
22844   echo "$as_me: failed program was:" >&5
22845 sed 's/^/| /' conftest.$ac_ext >&5
22846
22847 ac_cv_lib_m___clog=no
22848 fi
22849 rm -f conftest.err conftest.$ac_objext \
22850       conftest$ac_exeext conftest.$ac_ext
22851 LIBS=$ac_check_lib_save_LIBS
22852 fi
22853 echo "$as_me:$LINENO: result: $ac_cv_lib_m___clog" >&5
22854 echo "${ECHO_T}$ac_cv_lib_m___clog" >&6
22855 if test $ac_cv_lib_m___clog = yes; then
22856
22857 cat >>confdefs.h <<\_ACEOF
22858 #define HAVE_CLOG 1
22859 _ACEOF
22860
22861 fi
22862
22863
22864 # Check for a isfinite macro that works on long doubles.
22865
22866   echo "$as_me:$LINENO: checking whether isfinite is broken" >&5
22867 echo $ECHO_N "checking whether isfinite is broken... $ECHO_C" >&6
22868 if test "${have_broken_isfinite+set}" = set; then
22869   echo $ECHO_N "(cached) $ECHO_C" >&6
22870 else
22871
22872   libgfor_check_for_broken_isfinite_save_LIBS=$LIBS
22873   LIBS="$LIBS -lm"
22874   if test "$cross_compiling" = yes; then
22875
22876 case "${target}" in
22877   hppa*-*-hpux*) have_broken_isfinite=yes ;;
22878   *) have_broken_isfinite=no ;;
22879 esac
22880 else
22881   cat >conftest.$ac_ext <<_ACEOF
22882 /* confdefs.h.  */
22883 _ACEOF
22884 cat confdefs.h >>conftest.$ac_ext
22885 cat >>conftest.$ac_ext <<_ACEOF
22886 /* end confdefs.h.  */
22887
22888 #ifdef HAVE_MATH_H
22889 #include <math.h>
22890 #endif
22891 #include <float.h>
22892 int main ()
22893 {
22894 #ifdef isfinite
22895 #ifdef LDBL_MAX
22896   if (!isfinite(LDBL_MAX)) return 1;
22897 #endif
22898 #ifdef DBL_MAX
22899   if (!isfinite(DBL_MAX)) return 1;
22900 #endif
22901 #endif
22902 return 0;
22903 }
22904 _ACEOF
22905 rm -f conftest$ac_exeext
22906 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22907   (eval $ac_link) 2>&5
22908   ac_status=$?
22909   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22910   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
22911   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22912   (eval $ac_try) 2>&5
22913   ac_status=$?
22914   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22915   (exit $ac_status); }; }; then
22916   have_broken_isfinite=no
22917 else
22918   echo "$as_me: program exited with status $ac_status" >&5
22919 echo "$as_me: failed program was:" >&5
22920 sed 's/^/| /' conftest.$ac_ext >&5
22921
22922 ( exit $ac_status )
22923 have_broken_isfinite=yes
22924 fi
22925 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
22926 fi
22927   LIBS=$libgfor_check_for_broken_isfinite_save_LIBS
22928 fi
22929 echo "$as_me:$LINENO: result: $have_broken_isfinite" >&5
22930 echo "${ECHO_T}$have_broken_isfinite" >&6
22931 if test x"$have_broken_isfinite" = xyes; then
22932
22933 cat >>confdefs.h <<\_ACEOF
22934 #define HAVE_BROKEN_ISFINITE 1
22935 _ACEOF
22936
22937 fi
22938
22939 # Check for a isnan macro that works on long doubles.
22940
22941   echo "$as_me:$LINENO: checking whether isnan is broken" >&5
22942 echo $ECHO_N "checking whether isnan is broken... $ECHO_C" >&6
22943 if test "${have_broken_isnan+set}" = set; then
22944   echo $ECHO_N "(cached) $ECHO_C" >&6
22945 else
22946
22947   libgfor_check_for_broken_isnan_save_LIBS=$LIBS
22948   LIBS="$LIBS -lm"
22949   if test "$cross_compiling" = yes; then
22950
22951 case "${target}" in
22952   hppa*-*-hpux*) have_broken_isnan=yes ;;
22953   *) have_broken_isnan=no ;;
22954 esac
22955 else
22956   cat >conftest.$ac_ext <<_ACEOF
22957 /* confdefs.h.  */
22958 _ACEOF
22959 cat confdefs.h >>conftest.$ac_ext
22960 cat >>conftest.$ac_ext <<_ACEOF
22961 /* end confdefs.h.  */
22962
22963 #ifdef HAVE_MATH_H
22964 #include <math.h>
22965 #endif
22966 #include <float.h>
22967 int main ()
22968 {
22969 #ifdef isnan
22970 #ifdef LDBL_MAX
22971   {
22972     long double x;
22973     x = __builtin_nanl ("");
22974     if (!isnan(x)) return 1;
22975     if (isnan(LDBL_MAX)) return 1;
22976 #ifdef NAN
22977     x = (long double) NAN;
22978     if (!isnan(x)) return 1;
22979 #endif
22980   }
22981 #endif
22982 #ifdef DBL_MAX
22983   {
22984     double y;
22985     y = __builtin_nan ("");
22986     if (!isnan(y)) return 1;
22987     if (isnan(DBL_MAX)) return 1;
22988 #ifdef NAN
22989     y = (double) NAN;
22990     if (!isnan(y)) return 1;
22991 #endif
22992   }
22993 #endif
22994 #endif
22995 return 0;
22996 }
22997 _ACEOF
22998 rm -f conftest$ac_exeext
22999 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23000   (eval $ac_link) 2>&5
23001   ac_status=$?
23002   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23003   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
23004   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23005   (eval $ac_try) 2>&5
23006   ac_status=$?
23007   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23008   (exit $ac_status); }; }; then
23009   have_broken_isnan=no
23010 else
23011   echo "$as_me: program exited with status $ac_status" >&5
23012 echo "$as_me: failed program was:" >&5
23013 sed 's/^/| /' conftest.$ac_ext >&5
23014
23015 ( exit $ac_status )
23016 have_broken_isnan=yes
23017 fi
23018 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23019 fi
23020   LIBS=$libgfor_check_for_broken_isnan_save_LIBS
23021 fi
23022 echo "$as_me:$LINENO: result: $have_broken_isnan" >&5
23023 echo "${ECHO_T}$have_broken_isnan" >&6
23024 if test x"$have_broken_isnan" = xyes; then
23025
23026 cat >>confdefs.h <<\_ACEOF
23027 #define HAVE_BROKEN_ISNAN 1
23028 _ACEOF
23029
23030 fi
23031
23032 # Check for a fpclassify macro that works on long doubles.
23033
23034   echo "$as_me:$LINENO: checking whether fpclassify is broken" >&5
23035 echo $ECHO_N "checking whether fpclassify is broken... $ECHO_C" >&6
23036 if test "${have_broken_fpclassify+set}" = set; then
23037   echo $ECHO_N "(cached) $ECHO_C" >&6
23038 else
23039
23040   libgfor_check_for_broken_fpclassify_save_LIBS=$LIBS
23041   LIBS="$LIBS -lm"
23042   if test "$cross_compiling" = yes; then
23043
23044 case "${target}" in
23045   hppa*-*-hpux*) have_broken_fpclassify=yes ;;
23046   *) have_broken_fpclassify=no ;;
23047 esac
23048 else
23049   cat >conftest.$ac_ext <<_ACEOF
23050 /* confdefs.h.  */
23051 _ACEOF
23052 cat confdefs.h >>conftest.$ac_ext
23053 cat >>conftest.$ac_ext <<_ACEOF
23054 /* end confdefs.h.  */
23055
23056 #ifdef HAVE_MATH_H
23057 #include <math.h>
23058 #endif
23059 #include <float.h>
23060 int main ()
23061 {
23062 #ifdef fpclassify
23063 #ifdef LDBL_MAX
23064         if (fpclassify(LDBL_MAX) == FP_NAN
23065             || fpclassify(LDBL_MAX) == FP_INFINITE) return 1;
23066 #endif
23067 #ifdef DBL_MAX
23068         if (fpclassify(DBL_MAX) == FP_NAN
23069             || fpclassify(DBL_MAX) == FP_INFINITE) return 1;
23070 #endif
23071 #endif
23072 return 0;
23073 }
23074 _ACEOF
23075 rm -f conftest$ac_exeext
23076 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23077   (eval $ac_link) 2>&5
23078   ac_status=$?
23079   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23080   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
23081   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23082   (eval $ac_try) 2>&5
23083   ac_status=$?
23084   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23085   (exit $ac_status); }; }; then
23086   have_broken_fpclassify=no
23087 else
23088   echo "$as_me: program exited with status $ac_status" >&5
23089 echo "$as_me: failed program was:" >&5
23090 sed 's/^/| /' conftest.$ac_ext >&5
23091
23092 ( exit $ac_status )
23093 have_broken_fpclassify=yes
23094 fi
23095 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23096 fi
23097   LIBS=$libgfor_check_for_broken_fpclassify_save_LIBS
23098 fi
23099 echo "$as_me:$LINENO: result: $have_broken_fpclassify" >&5
23100 echo "${ECHO_T}$have_broken_fpclassify" >&6
23101 if test x"$have_broken_fpclassify" = xyes; then
23102
23103 cat >>confdefs.h <<\_ACEOF
23104 #define HAVE_BROKEN_FPCLASSIFY 1
23105 _ACEOF
23106
23107 fi
23108
23109 # Check whether the system has a working stat()
23110
23111   echo "$as_me:$LINENO: checking whether the target stat is reliable" >&5
23112 echo $ECHO_N "checking whether the target stat is reliable... $ECHO_C" >&6
23113 if test "${have_working_stat+set}" = set; then
23114   echo $ECHO_N "(cached) $ECHO_C" >&6
23115 else
23116
23117   if test "$cross_compiling" = yes; then
23118
23119 case "${target}" in
23120   *mingw*) have_working_stat=no ;;
23121   *) have_working_stat=yes;;
23122 esac
23123 else
23124   cat >conftest.$ac_ext <<_ACEOF
23125 /* confdefs.h.  */
23126 _ACEOF
23127 cat confdefs.h >>conftest.$ac_ext
23128 cat >>conftest.$ac_ext <<_ACEOF
23129 /* end confdefs.h.  */
23130
23131 #include <stdio.h>
23132 #include <sys/types.h>
23133 #include <sys/stat.h>
23134 #include <unistd.h>
23135
23136 int main ()
23137 {
23138   FILE *f, *g;
23139   struct stat st1, st2;
23140
23141   f = fopen ("foo", "w");
23142   g = fopen ("bar", "w");
23143   if (stat ("foo", &st1) != 0 || stat ("bar", &st2))
23144     return 1;
23145   if (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino)
23146     return 1;
23147   fclose(f);
23148   fclose(g);
23149   return 0;
23150 }
23151 _ACEOF
23152 rm -f conftest$ac_exeext
23153 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23154   (eval $ac_link) 2>&5
23155   ac_status=$?
23156   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23157   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
23158   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23159   (eval $ac_try) 2>&5
23160   ac_status=$?
23161   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23162   (exit $ac_status); }; }; then
23163   have_working_stat=yes
23164 else
23165   echo "$as_me: program exited with status $ac_status" >&5
23166 echo "$as_me: failed program was:" >&5
23167 sed 's/^/| /' conftest.$ac_ext >&5
23168
23169 ( exit $ac_status )
23170 have_working_stat=no
23171 fi
23172 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23173 fi
23174 fi
23175 echo "$as_me:$LINENO: result: $have_working_stat" >&5
23176 echo "${ECHO_T}$have_working_stat" >&6
23177 if test x"$have_working_stat" = xyes; then
23178
23179 cat >>confdefs.h <<\_ACEOF
23180 #define HAVE_WORKING_STAT 1
23181 _ACEOF
23182
23183 fi
23184
23185 # Fallback in case isfinite is not available.
23186 echo "$as_me:$LINENO: checking for finite in -lm" >&5
23187 echo $ECHO_N "checking for finite in -lm... $ECHO_C" >&6
23188 if test "${ac_cv_lib_m_finite+set}" = set; then
23189   echo $ECHO_N "(cached) $ECHO_C" >&6
23190 else
23191   ac_check_lib_save_LIBS=$LIBS
23192 LIBS="-lm  $LIBS"
23193 if test x$gcc_no_link = xyes; then
23194   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23195 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23196    { (exit 1); exit 1; }; }
23197 fi
23198 cat >conftest.$ac_ext <<_ACEOF
23199 /* confdefs.h.  */
23200 _ACEOF
23201 cat confdefs.h >>conftest.$ac_ext
23202 cat >>conftest.$ac_ext <<_ACEOF
23203 /* end confdefs.h.  */
23204
23205 /* Override any gcc2 internal prototype to avoid an error.  */
23206 #ifdef __cplusplus
23207 extern "C"
23208 #endif
23209 /* We use char because int might match the return type of a gcc2
23210    builtin and then its argument prototype would still apply.  */
23211 char finite ();
23212 int
23213 main ()
23214 {
23215 finite ();
23216   ;
23217   return 0;
23218 }
23219 _ACEOF
23220 rm -f conftest.$ac_objext conftest$ac_exeext
23221 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23222   (eval $ac_link) 2>conftest.er1
23223   ac_status=$?
23224   grep -v '^ *+' conftest.er1 >conftest.err
23225   rm -f conftest.er1
23226   cat conftest.err >&5
23227   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23228   (exit $ac_status); } &&
23229          { ac_try='test -z "$ac_c_werror_flag"
23230                          || test ! -s conftest.err'
23231   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23232   (eval $ac_try) 2>&5
23233   ac_status=$?
23234   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23235   (exit $ac_status); }; } &&
23236          { ac_try='test -s conftest$ac_exeext'
23237   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23238   (eval $ac_try) 2>&5
23239   ac_status=$?
23240   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23241   (exit $ac_status); }; }; then
23242   ac_cv_lib_m_finite=yes
23243 else
23244   echo "$as_me: failed program was:" >&5
23245 sed 's/^/| /' conftest.$ac_ext >&5
23246
23247 ac_cv_lib_m_finite=no
23248 fi
23249 rm -f conftest.err conftest.$ac_objext \
23250       conftest$ac_exeext conftest.$ac_ext
23251 LIBS=$ac_check_lib_save_LIBS
23252 fi
23253 echo "$as_me:$LINENO: result: $ac_cv_lib_m_finite" >&5
23254 echo "${ECHO_T}$ac_cv_lib_m_finite" >&6
23255 if test $ac_cv_lib_m_finite = yes; then
23256
23257 cat >>confdefs.h <<\_ACEOF
23258 #define HAVE_FINITE 1
23259 _ACEOF
23260
23261 fi
23262
23263
23264 # Check for GNU libc feenableexcept
23265 echo "$as_me:$LINENO: checking for feenableexcept in -lm" >&5
23266 echo $ECHO_N "checking for feenableexcept in -lm... $ECHO_C" >&6
23267 if test "${ac_cv_lib_m_feenableexcept+set}" = set; then
23268   echo $ECHO_N "(cached) $ECHO_C" >&6
23269 else
23270   ac_check_lib_save_LIBS=$LIBS
23271 LIBS="-lm  $LIBS"
23272 if test x$gcc_no_link = xyes; then
23273   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23274 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23275    { (exit 1); exit 1; }; }
23276 fi
23277 cat >conftest.$ac_ext <<_ACEOF
23278 /* confdefs.h.  */
23279 _ACEOF
23280 cat confdefs.h >>conftest.$ac_ext
23281 cat >>conftest.$ac_ext <<_ACEOF
23282 /* end confdefs.h.  */
23283
23284 /* Override any gcc2 internal prototype to avoid an error.  */
23285 #ifdef __cplusplus
23286 extern "C"
23287 #endif
23288 /* We use char because int might match the return type of a gcc2
23289    builtin and then its argument prototype would still apply.  */
23290 char feenableexcept ();
23291 int
23292 main ()
23293 {
23294 feenableexcept ();
23295   ;
23296   return 0;
23297 }
23298 _ACEOF
23299 rm -f conftest.$ac_objext conftest$ac_exeext
23300 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23301   (eval $ac_link) 2>conftest.er1
23302   ac_status=$?
23303   grep -v '^ *+' conftest.er1 >conftest.err
23304   rm -f conftest.er1
23305   cat conftest.err >&5
23306   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23307   (exit $ac_status); } &&
23308          { ac_try='test -z "$ac_c_werror_flag"
23309                          || test ! -s conftest.err'
23310   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23311   (eval $ac_try) 2>&5
23312   ac_status=$?
23313   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23314   (exit $ac_status); }; } &&
23315          { ac_try='test -s conftest$ac_exeext'
23316   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23317   (eval $ac_try) 2>&5
23318   ac_status=$?
23319   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23320   (exit $ac_status); }; }; then
23321   ac_cv_lib_m_feenableexcept=yes
23322 else
23323   echo "$as_me: failed program was:" >&5
23324 sed 's/^/| /' conftest.$ac_ext >&5
23325
23326 ac_cv_lib_m_feenableexcept=no
23327 fi
23328 rm -f conftest.err conftest.$ac_objext \
23329       conftest$ac_exeext conftest.$ac_ext
23330 LIBS=$ac_check_lib_save_LIBS
23331 fi
23332 echo "$as_me:$LINENO: result: $ac_cv_lib_m_feenableexcept" >&5
23333 echo "${ECHO_T}$ac_cv_lib_m_feenableexcept" >&6
23334 if test $ac_cv_lib_m_feenableexcept = yes; then
23335   have_feenableexcept=yes
23336 cat >>confdefs.h <<\_ACEOF
23337 #define HAVE_FEENABLEEXCEPT 1
23338 _ACEOF
23339
23340 fi
23341
23342
23343 # Check for SysV fpsetmask
23344
23345   echo "$as_me:$LINENO: checking whether fpsetmask is present" >&5
23346 echo $ECHO_N "checking whether fpsetmask is present... $ECHO_C" >&6
23347 if test "${have_fpsetmask+set}" = set; then
23348   echo $ECHO_N "(cached) $ECHO_C" >&6
23349 else
23350
23351     if test x$gcc_no_link = xyes; then
23352   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23353 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23354    { (exit 1); exit 1; }; }
23355 fi
23356 cat >conftest.$ac_ext <<_ACEOF
23357 /* confdefs.h.  */
23358 _ACEOF
23359 cat confdefs.h >>conftest.$ac_ext
23360 cat >>conftest.$ac_ext <<_ACEOF
23361 /* end confdefs.h.  */
23362
23363 #if HAVE_FLOATINGPOINT_H
23364 # include <floatingpoint.h>
23365 #endif /* HAVE_FLOATINGPOINT_H */
23366 #if HAVE_IEEEFP_H
23367 # include <ieeefp.h>
23368 #endif /* HAVE_IEEEFP_H */
23369 int
23370 main ()
23371 {
23372 fpsetmask(0);
23373   ;
23374   return 0;
23375 }
23376 _ACEOF
23377 rm -f conftest.$ac_objext conftest$ac_exeext
23378 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23379   (eval $ac_link) 2>conftest.er1
23380   ac_status=$?
23381   grep -v '^ *+' conftest.er1 >conftest.err
23382   rm -f conftest.er1
23383   cat conftest.err >&5
23384   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23385   (exit $ac_status); } &&
23386          { ac_try='test -z "$ac_c_werror_flag"
23387                          || test ! -s conftest.err'
23388   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23389   (eval $ac_try) 2>&5
23390   ac_status=$?
23391   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23392   (exit $ac_status); }; } &&
23393          { ac_try='test -s conftest$ac_exeext'
23394   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23395   (eval $ac_try) 2>&5
23396   ac_status=$?
23397   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23398   (exit $ac_status); }; }; then
23399   eval "have_fpsetmask=yes"
23400 else
23401   echo "$as_me: failed program was:" >&5
23402 sed 's/^/| /' conftest.$ac_ext >&5
23403
23404 eval "have_fpsetmask=no"
23405 fi
23406 rm -f conftest.err conftest.$ac_objext \
23407       conftest$ac_exeext conftest.$ac_ext
23408
23409 fi
23410 echo "$as_me:$LINENO: result: $have_fpsetmask" >&5
23411 echo "${ECHO_T}$have_fpsetmask" >&6
23412   if test x"$have_fpsetmask" = xyes; then
23413
23414 cat >>confdefs.h <<\_ACEOF
23415 #define HAVE_FPSETMASK 1
23416 _ACEOF
23417
23418   fi
23419
23420
23421 # Check for AIX fp_trap and fp_enable
23422 echo "$as_me:$LINENO: checking for fp_trap" >&5
23423 echo $ECHO_N "checking for fp_trap... $ECHO_C" >&6
23424 if test "${ac_cv_func_fp_trap+set}" = set; then
23425   echo $ECHO_N "(cached) $ECHO_C" >&6
23426 else
23427   if test x$gcc_no_link = xyes; then
23428   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23429 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23430    { (exit 1); exit 1; }; }
23431 fi
23432 cat >conftest.$ac_ext <<_ACEOF
23433 /* confdefs.h.  */
23434 _ACEOF
23435 cat confdefs.h >>conftest.$ac_ext
23436 cat >>conftest.$ac_ext <<_ACEOF
23437 /* end confdefs.h.  */
23438 /* Define fp_trap to an innocuous variant, in case <limits.h> declares fp_trap.
23439    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
23440 #define fp_trap innocuous_fp_trap
23441
23442 /* System header to define __stub macros and hopefully few prototypes,
23443     which can conflict with char fp_trap (); below.
23444     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
23445     <limits.h> exists even on freestanding compilers.  */
23446
23447 #ifdef __STDC__
23448 # include <limits.h>
23449 #else
23450 # include <assert.h>
23451 #endif
23452
23453 #undef fp_trap
23454
23455 /* Override any gcc2 internal prototype to avoid an error.  */
23456 #ifdef __cplusplus
23457 extern "C"
23458 {
23459 #endif
23460 /* We use char because int might match the return type of a gcc2
23461    builtin and then its argument prototype would still apply.  */
23462 char fp_trap ();
23463 /* The GNU C library defines this for functions which it implements
23464     to always fail with ENOSYS.  Some functions are actually named
23465     something starting with __ and the normal name is an alias.  */
23466 #if defined (__stub_fp_trap) || defined (__stub___fp_trap)
23467 choke me
23468 #else
23469 char (*f) () = fp_trap;
23470 #endif
23471 #ifdef __cplusplus
23472 }
23473 #endif
23474
23475 int
23476 main ()
23477 {
23478 return f != fp_trap;
23479   ;
23480   return 0;
23481 }
23482 _ACEOF
23483 rm -f conftest.$ac_objext conftest$ac_exeext
23484 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23485   (eval $ac_link) 2>conftest.er1
23486   ac_status=$?
23487   grep -v '^ *+' conftest.er1 >conftest.err
23488   rm -f conftest.er1
23489   cat conftest.err >&5
23490   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23491   (exit $ac_status); } &&
23492          { ac_try='test -z "$ac_c_werror_flag"
23493                          || test ! -s conftest.err'
23494   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23495   (eval $ac_try) 2>&5
23496   ac_status=$?
23497   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23498   (exit $ac_status); }; } &&
23499          { ac_try='test -s conftest$ac_exeext'
23500   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23501   (eval $ac_try) 2>&5
23502   ac_status=$?
23503   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23504   (exit $ac_status); }; }; then
23505   ac_cv_func_fp_trap=yes
23506 else
23507   echo "$as_me: failed program was:" >&5
23508 sed 's/^/| /' conftest.$ac_ext >&5
23509
23510 ac_cv_func_fp_trap=no
23511 fi
23512 rm -f conftest.err conftest.$ac_objext \
23513       conftest$ac_exeext conftest.$ac_ext
23514 fi
23515 echo "$as_me:$LINENO: result: $ac_cv_func_fp_trap" >&5
23516 echo "${ECHO_T}$ac_cv_func_fp_trap" >&6
23517 if test $ac_cv_func_fp_trap = yes; then
23518   have_fp_trap=yes
23519 cat >>confdefs.h <<\_ACEOF
23520 #define HAVE_FP_TRAP 1
23521 _ACEOF
23522
23523 fi
23524
23525 echo "$as_me:$LINENO: checking for fp_enable" >&5
23526 echo $ECHO_N "checking for fp_enable... $ECHO_C" >&6
23527 if test "${ac_cv_func_fp_enable+set}" = set; then
23528   echo $ECHO_N "(cached) $ECHO_C" >&6
23529 else
23530   if test x$gcc_no_link = xyes; then
23531   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23532 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23533    { (exit 1); exit 1; }; }
23534 fi
23535 cat >conftest.$ac_ext <<_ACEOF
23536 /* confdefs.h.  */
23537 _ACEOF
23538 cat confdefs.h >>conftest.$ac_ext
23539 cat >>conftest.$ac_ext <<_ACEOF
23540 /* end confdefs.h.  */
23541 /* Define fp_enable to an innocuous variant, in case <limits.h> declares fp_enable.
23542    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
23543 #define fp_enable innocuous_fp_enable
23544
23545 /* System header to define __stub macros and hopefully few prototypes,
23546     which can conflict with char fp_enable (); below.
23547     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
23548     <limits.h> exists even on freestanding compilers.  */
23549
23550 #ifdef __STDC__
23551 # include <limits.h>
23552 #else
23553 # include <assert.h>
23554 #endif
23555
23556 #undef fp_enable
23557
23558 /* Override any gcc2 internal prototype to avoid an error.  */
23559 #ifdef __cplusplus
23560 extern "C"
23561 {
23562 #endif
23563 /* We use char because int might match the return type of a gcc2
23564    builtin and then its argument prototype would still apply.  */
23565 char fp_enable ();
23566 /* The GNU C library defines this for functions which it implements
23567     to always fail with ENOSYS.  Some functions are actually named
23568     something starting with __ and the normal name is an alias.  */
23569 #if defined (__stub_fp_enable) || defined (__stub___fp_enable)
23570 choke me
23571 #else
23572 char (*f) () = fp_enable;
23573 #endif
23574 #ifdef __cplusplus
23575 }
23576 #endif
23577
23578 int
23579 main ()
23580 {
23581 return f != fp_enable;
23582   ;
23583   return 0;
23584 }
23585 _ACEOF
23586 rm -f conftest.$ac_objext conftest$ac_exeext
23587 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23588   (eval $ac_link) 2>conftest.er1
23589   ac_status=$?
23590   grep -v '^ *+' conftest.er1 >conftest.err
23591   rm -f conftest.er1
23592   cat conftest.err >&5
23593   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23594   (exit $ac_status); } &&
23595          { ac_try='test -z "$ac_c_werror_flag"
23596                          || test ! -s conftest.err'
23597   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23598   (eval $ac_try) 2>&5
23599   ac_status=$?
23600   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23601   (exit $ac_status); }; } &&
23602          { ac_try='test -s conftest$ac_exeext'
23603   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23604   (eval $ac_try) 2>&5
23605   ac_status=$?
23606   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23607   (exit $ac_status); }; }; then
23608   ac_cv_func_fp_enable=yes
23609 else
23610   echo "$as_me: failed program was:" >&5
23611 sed 's/^/| /' conftest.$ac_ext >&5
23612
23613 ac_cv_func_fp_enable=no
23614 fi
23615 rm -f conftest.err conftest.$ac_objext \
23616       conftest$ac_exeext conftest.$ac_ext
23617 fi
23618 echo "$as_me:$LINENO: result: $ac_cv_func_fp_enable" >&5
23619 echo "${ECHO_T}$ac_cv_func_fp_enable" >&6
23620 if test $ac_cv_func_fp_enable = yes; then
23621   have_fp_enable=yes
23622 cat >>confdefs.h <<\_ACEOF
23623 #define HAVE_FP_ENABLE 1
23624 _ACEOF
23625
23626 fi
23627
23628
23629 # Runs configure.host to set up necessary host-dependent shell variables.
23630 # We then display a message about it, and propagate them through the
23631 # build chain.
23632 . ${srcdir}/configure.host
23633 { echo "$as_me:$LINENO: FPU dependent file will be ${fpu_host}.h" >&5
23634 echo "$as_me: FPU dependent file will be ${fpu_host}.h" >&6;}
23635 FPU_HOST_HEADER=config/${fpu_host}.h
23636
23637
23638 # Attempt to assert that the target is of common type in case we don't
23639 # have C99 integer types at all.
23640
23641   echo "$as_me:$LINENO: checking whether the target is ILP32" >&5
23642 echo $ECHO_N "checking whether the target is ILP32... $ECHO_C" >&6
23643 if test "${target_ilp32+set}" = set; then
23644   echo $ECHO_N "(cached) $ECHO_C" >&6
23645 else
23646
23647   save_CFLAGS="$CFLAGS"
23648   CFLAGS="-O2"
23649   if test x$gcc_no_link = xyes; then
23650   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23651 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23652    { (exit 1); exit 1; }; }
23653 fi
23654 cat >conftest.$ac_ext <<_ACEOF
23655 /* confdefs.h.  */
23656 _ACEOF
23657 cat confdefs.h >>conftest.$ac_ext
23658 cat >>conftest.$ac_ext <<_ACEOF
23659 /* end confdefs.h.  */
23660
23661 int
23662 main ()
23663 {
23664
23665 if (sizeof(int) == 4 && sizeof(long) == 4 && sizeof(void *) == 4)
23666   ;
23667 else
23668   undefined_function ();
23669
23670   ;
23671   return 0;
23672 }
23673 _ACEOF
23674 rm -f conftest.$ac_objext conftest$ac_exeext
23675 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23676   (eval $ac_link) 2>conftest.er1
23677   ac_status=$?
23678   grep -v '^ *+' conftest.er1 >conftest.err
23679   rm -f conftest.er1
23680   cat conftest.err >&5
23681   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23682   (exit $ac_status); } &&
23683          { ac_try='test -z "$ac_c_werror_flag"
23684                          || test ! -s conftest.err'
23685   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23686   (eval $ac_try) 2>&5
23687   ac_status=$?
23688   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23689   (exit $ac_status); }; } &&
23690          { ac_try='test -s conftest$ac_exeext'
23691   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23692   (eval $ac_try) 2>&5
23693   ac_status=$?
23694   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23695   (exit $ac_status); }; }; then
23696   target_ilp32=yes
23697 else
23698   echo "$as_me: failed program was:" >&5
23699 sed 's/^/| /' conftest.$ac_ext >&5
23700
23701 target_ilp32=no
23702 fi
23703 rm -f conftest.err conftest.$ac_objext \
23704       conftest$ac_exeext conftest.$ac_ext
23705   CFLAGS="$save_CFLAGS"
23706 fi
23707 echo "$as_me:$LINENO: result: $target_ilp32" >&5
23708 echo "${ECHO_T}$target_ilp32" >&6
23709   if test $target_ilp32 = yes; then
23710
23711 cat >>confdefs.h <<\_ACEOF
23712 #define TARGET_ILP32 1
23713 _ACEOF
23714
23715   fi
23716
23717
23718 # Check out attribute support.
23719
23720   echo "$as_me:$LINENO: checking whether the target supports hidden visibility" >&5
23721 echo $ECHO_N "checking whether the target supports hidden visibility... $ECHO_C" >&6
23722 if test "${have_attribute_visibility+set}" = set; then
23723   echo $ECHO_N "(cached) $ECHO_C" >&6
23724 else
23725
23726   save_CFLAGS="$CFLAGS"
23727   CFLAGS="$CFLAGS -Werror"
23728   cat >conftest.$ac_ext <<_ACEOF
23729 /* confdefs.h.  */
23730 _ACEOF
23731 cat confdefs.h >>conftest.$ac_ext
23732 cat >>conftest.$ac_ext <<_ACEOF
23733 /* end confdefs.h.  */
23734 void __attribute__((visibility("hidden"))) foo(void) { }
23735 int
23736 main ()
23737 {
23738
23739   ;
23740   return 0;
23741 }
23742 _ACEOF
23743 rm -f conftest.$ac_objext
23744 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
23745   (eval $ac_compile) 2>conftest.er1
23746   ac_status=$?
23747   grep -v '^ *+' conftest.er1 >conftest.err
23748   rm -f conftest.er1
23749   cat conftest.err >&5
23750   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23751   (exit $ac_status); } &&
23752          { ac_try='test -z "$ac_c_werror_flag"
23753                          || test ! -s conftest.err'
23754   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23755   (eval $ac_try) 2>&5
23756   ac_status=$?
23757   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23758   (exit $ac_status); }; } &&
23759          { ac_try='test -s conftest.$ac_objext'
23760   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23761   (eval $ac_try) 2>&5
23762   ac_status=$?
23763   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23764   (exit $ac_status); }; }; then
23765   have_attribute_visibility=yes
23766 else
23767   echo "$as_me: failed program was:" >&5
23768 sed 's/^/| /' conftest.$ac_ext >&5
23769
23770 have_attribute_visibility=no
23771 fi
23772 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
23773   CFLAGS="$save_CFLAGS"
23774 fi
23775 echo "$as_me:$LINENO: result: $have_attribute_visibility" >&5
23776 echo "${ECHO_T}$have_attribute_visibility" >&6
23777   if test $have_attribute_visibility = yes; then
23778
23779 cat >>confdefs.h <<\_ACEOF
23780 #define HAVE_ATTRIBUTE_VISIBILITY 1
23781 _ACEOF
23782
23783   fi
23784
23785   echo "$as_me:$LINENO: checking whether the target supports dllexport" >&5
23786 echo $ECHO_N "checking whether the target supports dllexport... $ECHO_C" >&6
23787 if test "${have_attribute_dllexport+set}" = set; then
23788   echo $ECHO_N "(cached) $ECHO_C" >&6
23789 else
23790
23791   save_CFLAGS="$CFLAGS"
23792   CFLAGS="$CFLAGS -Werror"
23793   cat >conftest.$ac_ext <<_ACEOF
23794 /* confdefs.h.  */
23795 _ACEOF
23796 cat confdefs.h >>conftest.$ac_ext
23797 cat >>conftest.$ac_ext <<_ACEOF
23798 /* end confdefs.h.  */
23799 void __attribute__((dllexport)) foo(void) { }
23800 int
23801 main ()
23802 {
23803
23804   ;
23805   return 0;
23806 }
23807 _ACEOF
23808 rm -f conftest.$ac_objext
23809 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
23810   (eval $ac_compile) 2>conftest.er1
23811   ac_status=$?
23812   grep -v '^ *+' conftest.er1 >conftest.err
23813   rm -f conftest.er1
23814   cat conftest.err >&5
23815   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23816   (exit $ac_status); } &&
23817          { ac_try='test -z "$ac_c_werror_flag"
23818                          || test ! -s conftest.err'
23819   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23820   (eval $ac_try) 2>&5
23821   ac_status=$?
23822   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23823   (exit $ac_status); }; } &&
23824          { ac_try='test -s conftest.$ac_objext'
23825   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23826   (eval $ac_try) 2>&5
23827   ac_status=$?
23828   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23829   (exit $ac_status); }; }; then
23830   have_attribute_dllexport=yes
23831 else
23832   echo "$as_me: failed program was:" >&5
23833 sed 's/^/| /' conftest.$ac_ext >&5
23834
23835 have_attribute_dllexport=no
23836 fi
23837 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
23838   CFLAGS="$save_CFLAGS"
23839 fi
23840 echo "$as_me:$LINENO: result: $have_attribute_dllexport" >&5
23841 echo "${ECHO_T}$have_attribute_dllexport" >&6
23842   if test $have_attribute_dllexport = yes; then
23843
23844 cat >>confdefs.h <<\_ACEOF
23845 #define HAVE_ATTRIBUTE_DLLEXPORT 1
23846 _ACEOF
23847
23848   fi
23849
23850   echo "$as_me:$LINENO: checking whether the target supports symbol aliases" >&5
23851 echo $ECHO_N "checking whether the target supports symbol aliases... $ECHO_C" >&6
23852 if test "${have_attribute_alias+set}" = set; then
23853   echo $ECHO_N "(cached) $ECHO_C" >&6
23854 else
23855
23856   if test x$gcc_no_link = xyes; then
23857   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23858 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23859    { (exit 1); exit 1; }; }
23860 fi
23861 cat >conftest.$ac_ext <<_ACEOF
23862 /* confdefs.h.  */
23863 _ACEOF
23864 cat confdefs.h >>conftest.$ac_ext
23865 cat >>conftest.$ac_ext <<_ACEOF
23866 /* end confdefs.h.  */
23867
23868 void foo(void) { }
23869 extern void bar(void) __attribute__((alias("foo")));
23870 int
23871 main ()
23872 {
23873 bar();
23874   ;
23875   return 0;
23876 }
23877 _ACEOF
23878 rm -f conftest.$ac_objext conftest$ac_exeext
23879 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23880   (eval $ac_link) 2>conftest.er1
23881   ac_status=$?
23882   grep -v '^ *+' conftest.er1 >conftest.err
23883   rm -f conftest.er1
23884   cat conftest.err >&5
23885   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23886   (exit $ac_status); } &&
23887          { ac_try='test -z "$ac_c_werror_flag"
23888                          || test ! -s conftest.err'
23889   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23890   (eval $ac_try) 2>&5
23891   ac_status=$?
23892   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23893   (exit $ac_status); }; } &&
23894          { ac_try='test -s conftest$ac_exeext'
23895   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23896   (eval $ac_try) 2>&5
23897   ac_status=$?
23898   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23899   (exit $ac_status); }; }; then
23900   have_attribute_alias=yes
23901 else
23902   echo "$as_me: failed program was:" >&5
23903 sed 's/^/| /' conftest.$ac_ext >&5
23904
23905 have_attribute_alias=no
23906 fi
23907 rm -f conftest.err conftest.$ac_objext \
23908       conftest$ac_exeext conftest.$ac_ext
23909 fi
23910 echo "$as_me:$LINENO: result: $have_attribute_alias" >&5
23911 echo "${ECHO_T}$have_attribute_alias" >&6
23912   if test $have_attribute_alias = yes; then
23913
23914 cat >>confdefs.h <<\_ACEOF
23915 #define HAVE_ATTRIBUTE_ALIAS 1
23916 _ACEOF
23917
23918   fi
23919
23920 # Check out sync builtins support.
23921
23922   echo "$as_me:$LINENO: checking whether the target supports __sync_fetch_and_add" >&5
23923 echo $ECHO_N "checking whether the target supports __sync_fetch_and_add... $ECHO_C" >&6
23924 if test "${have_sync_fetch_and_add+set}" = set; then
23925   echo $ECHO_N "(cached) $ECHO_C" >&6
23926 else
23927
23928   if test x$gcc_no_link = xyes; then
23929   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23930 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23931    { (exit 1); exit 1; }; }
23932 fi
23933 cat >conftest.$ac_ext <<_ACEOF
23934 /* confdefs.h.  */
23935 _ACEOF
23936 cat confdefs.h >>conftest.$ac_ext
23937 cat >>conftest.$ac_ext <<_ACEOF
23938 /* end confdefs.h.  */
23939 int foovar = 0;
23940 int
23941 main ()
23942 {
23943
23944 if (foovar <= 0) return __sync_fetch_and_add (&foovar, 1);
23945 if (foovar > 10) return __sync_add_and_fetch (&foovar, -1);
23946   ;
23947   return 0;
23948 }
23949 _ACEOF
23950 rm -f conftest.$ac_objext conftest$ac_exeext
23951 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23952   (eval $ac_link) 2>conftest.er1
23953   ac_status=$?
23954   grep -v '^ *+' conftest.er1 >conftest.err
23955   rm -f conftest.er1
23956   cat conftest.err >&5
23957   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23958   (exit $ac_status); } &&
23959          { ac_try='test -z "$ac_c_werror_flag"
23960                          || test ! -s conftest.err'
23961   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23962   (eval $ac_try) 2>&5
23963   ac_status=$?
23964   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23965   (exit $ac_status); }; } &&
23966          { ac_try='test -s conftest$ac_exeext'
23967   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23968   (eval $ac_try) 2>&5
23969   ac_status=$?
23970   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23971   (exit $ac_status); }; }; then
23972   have_sync_fetch_and_add=yes
23973 else
23974   echo "$as_me: failed program was:" >&5
23975 sed 's/^/| /' conftest.$ac_ext >&5
23976
23977 have_sync_fetch_and_add=no
23978 fi
23979 rm -f conftest.err conftest.$ac_objext \
23980       conftest$ac_exeext conftest.$ac_ext
23981 fi
23982 echo "$as_me:$LINENO: result: $have_sync_fetch_and_add" >&5
23983 echo "${ECHO_T}$have_sync_fetch_and_add" >&6
23984   if test $have_sync_fetch_and_add = yes; then
23985
23986 cat >>confdefs.h <<\_ACEOF
23987 #define HAVE_SYNC_FETCH_AND_ADD 1
23988 _ACEOF
23989
23990   fi
23991
23992 # Check out thread support.
23993
23994   echo "$as_me:$LINENO: checking configured target thread model" >&5
23995 echo $ECHO_N "checking configured target thread model... $ECHO_C" >&6
23996 if test "${target_thread_file+set}" = set; then
23997   echo $ECHO_N "(cached) $ECHO_C" >&6
23998 else
23999
24000 target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`
24001 fi
24002 echo "$as_me:$LINENO: result: $target_thread_file" >&5
24003 echo "${ECHO_T}$target_thread_file" >&6
24004
24005   if test $target_thread_file != single; then
24006
24007 cat >>confdefs.h <<\_ACEOF
24008 #define HAVE_GTHR_DEFAULT 1
24009 _ACEOF
24010
24011   fi
24012
24013 # Check out #pragma weak.
24014
24015   echo "$as_me:$LINENO: checking whether pragma weak works" >&5
24016 echo $ECHO_N "checking whether pragma weak works... $ECHO_C" >&6
24017 if test "${have_pragma_weak+set}" = set; then
24018   echo $ECHO_N "(cached) $ECHO_C" >&6
24019 else
24020
24021   gfor_save_CFLAGS="$CFLAGS"
24022   CFLAGS="$CFLAGS -Wunknown-pragmas"
24023   cat >conftest.$ac_ext <<_ACEOF
24024 /* confdefs.h.  */
24025 _ACEOF
24026 cat confdefs.h >>conftest.$ac_ext
24027 cat >>conftest.$ac_ext <<_ACEOF
24028 /* end confdefs.h.  */
24029 void foo (void);
24030 #pragma weak foo
24031 int
24032 main ()
24033 {
24034 if (foo) foo ();
24035   ;
24036   return 0;
24037 }
24038 _ACEOF
24039 rm -f conftest.$ac_objext
24040 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
24041   (eval $ac_compile) 2>conftest.er1
24042   ac_status=$?
24043   grep -v '^ *+' conftest.er1 >conftest.err
24044   rm -f conftest.er1
24045   cat conftest.err >&5
24046   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24047   (exit $ac_status); } &&
24048          { ac_try='test -z "$ac_c_werror_flag"
24049                          || test ! -s conftest.err'
24050   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24051   (eval $ac_try) 2>&5
24052   ac_status=$?
24053   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24054   (exit $ac_status); }; } &&
24055          { ac_try='test -s conftest.$ac_objext'
24056   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24057   (eval $ac_try) 2>&5
24058   ac_status=$?
24059   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24060   (exit $ac_status); }; }; then
24061   have_pragma_weak=yes
24062 else
24063   echo "$as_me: failed program was:" >&5
24064 sed 's/^/| /' conftest.$ac_ext >&5
24065
24066 have_pragma_weak=no
24067 fi
24068 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
24069 fi
24070 echo "$as_me:$LINENO: result: $have_pragma_weak" >&5
24071 echo "${ECHO_T}$have_pragma_weak" >&6
24072   if test $have_pragma_weak = yes; then
24073
24074 cat >>confdefs.h <<\_ACEOF
24075 #define SUPPORTS_WEAK 1
24076 _ACEOF
24077
24078   fi
24079   case "$host" in
24080     *-*-darwin* | *-*-hpux* | *-*-cygwin*)
24081
24082 cat >>confdefs.h <<\_ACEOF
24083 #define GTHREAD_USE_WEAK 0
24084 _ACEOF
24085
24086       ;;
24087   esac
24088
24089 # Various other checks on target
24090
24091   echo "$as_me:$LINENO: checking whether the target can unlink an open file" >&5
24092 echo $ECHO_N "checking whether the target can unlink an open file... $ECHO_C" >&6
24093 if test "${have_unlink_open_file+set}" = set; then
24094   echo $ECHO_N "(cached) $ECHO_C" >&6
24095 else
24096
24097   if test "$cross_compiling" = yes; then
24098
24099 case "${target}" in
24100   *mingw*) have_unlink_open_file=no ;;
24101   *) have_unlink_open_file=yes;;
24102 esac
24103 else
24104   cat >conftest.$ac_ext <<_ACEOF
24105 /* confdefs.h.  */
24106 _ACEOF
24107 cat confdefs.h >>conftest.$ac_ext
24108 cat >>conftest.$ac_ext <<_ACEOF
24109 /* end confdefs.h.  */
24110
24111 #include <errno.h>
24112 #include <fcntl.h>
24113 #include <unistd.h>
24114 #include <sys/stat.h>
24115
24116 int main ()
24117 {
24118   int fd;
24119
24120   fd = open ("testfile", O_RDWR | O_CREAT, S_IWRITE | S_IREAD);
24121   if (fd <= 0)
24122     return 0;
24123   if (unlink ("testfile") == -1)
24124     return 1;
24125   write (fd, "This is a test\n", 15);
24126   close (fd);
24127
24128   if (open ("testfile", O_RDONLY, S_IWRITE | S_IREAD) == -1 && errno == ENOENT)
24129     return 0;
24130   else
24131     return 1;
24132 }
24133 _ACEOF
24134 rm -f conftest$ac_exeext
24135 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
24136   (eval $ac_link) 2>&5
24137   ac_status=$?
24138   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24139   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
24140   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24141   (eval $ac_try) 2>&5
24142   ac_status=$?
24143   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24144   (exit $ac_status); }; }; then
24145   have_unlink_open_file=yes
24146 else
24147   echo "$as_me: program exited with status $ac_status" >&5
24148 echo "$as_me: failed program was:" >&5
24149 sed 's/^/| /' conftest.$ac_ext >&5
24150
24151 ( exit $ac_status )
24152 have_unlink_open_file=no
24153 fi
24154 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
24155 fi
24156 fi
24157 echo "$as_me:$LINENO: result: $have_unlink_open_file" >&5
24158 echo "${ECHO_T}$have_unlink_open_file" >&6
24159 if test x"$have_unlink_open_file" = xyes; then
24160
24161 cat >>confdefs.h <<\_ACEOF
24162 #define HAVE_UNLINK_OPEN_FILE 1
24163 _ACEOF
24164
24165 fi
24166
24167 # Check whether line terminator is LF or CRLF
24168
24169   echo "$as_me:$LINENO: checking whether the target has CRLF as line terminator" >&5
24170 echo $ECHO_N "checking whether the target has CRLF as line terminator... $ECHO_C" >&6
24171 if test "${have_crlf+set}" = set; then
24172   echo $ECHO_N "(cached) $ECHO_C" >&6
24173 else
24174
24175   if test "$cross_compiling" = yes; then
24176
24177 case "${target}" in
24178   *mingw*) have_crlf=yes ;;
24179   *) have_crlf=no;;
24180 esac
24181 else
24182   cat >conftest.$ac_ext <<_ACEOF
24183 /* confdefs.h.  */
24184 _ACEOF
24185 cat confdefs.h >>conftest.$ac_ext
24186 cat >>conftest.$ac_ext <<_ACEOF
24187 /* end confdefs.h.  */
24188
24189 /* This test program should exit with status 0 if system uses a CRLF as
24190    line terminator, and status 1 otherwise.
24191    Since it is used to check for mingw systems, and should return 0 in any
24192    other case, in case of a failure we will not use CRLF.  */
24193 #include <sys/stat.h>
24194 #include <stdlib.h>
24195 #include <fcntl.h>
24196 #include <stdio.h>
24197
24198 int main ()
24199 {
24200 #ifndef O_BINARY
24201   exit(1);
24202 #else
24203   int fd, bytes;
24204   char buff[5];
24205
24206   fd = open ("foo", O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
24207   if (fd < 0)
24208     exit(1);
24209   if (write (fd, "\n", 1) < 0)
24210     perror ("write");
24211
24212   close (fd);
24213
24214   if ((fd = open ("foo", O_RDONLY | O_BINARY, S_IRWXU)) < 0)
24215     exit(1);
24216   bytes = read (fd, buff, 5);
24217   if (bytes == 2 && buff[0] == '\r' && buff[1] == '\n')
24218     exit(0);
24219   else
24220     exit(1);
24221 #endif
24222 }
24223 _ACEOF
24224 rm -f conftest$ac_exeext
24225 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
24226   (eval $ac_link) 2>&5
24227   ac_status=$?
24228   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24229   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
24230   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24231   (eval $ac_try) 2>&5
24232   ac_status=$?
24233   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24234   (exit $ac_status); }; }; then
24235   have_crlf=yes
24236 else
24237   echo "$as_me: program exited with status $ac_status" >&5
24238 echo "$as_me: failed program was:" >&5
24239 sed 's/^/| /' conftest.$ac_ext >&5
24240
24241 ( exit $ac_status )
24242 have_crlf=no
24243 fi
24244 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
24245 fi
24246 fi
24247 echo "$as_me:$LINENO: result: $have_crlf" >&5
24248 echo "${ECHO_T}$have_crlf" >&6
24249 if test x"$have_crlf" = xyes; then
24250
24251 cat >>confdefs.h <<\_ACEOF
24252 #define HAVE_CRLF 1
24253 _ACEOF
24254
24255 fi
24256
24257 cat >confcache <<\_ACEOF
24258 # This file is a shell script that caches the results of configure
24259 # tests run on this system so they can be shared between configure
24260 # scripts and configure runs, see configure's option --config-cache.
24261 # It is not useful on other systems.  If it contains results you don't
24262 # want to keep, you may remove or edit it.
24263 #
24264 # config.status only pays attention to the cache file if you give it
24265 # the --recheck option to rerun configure.
24266 #
24267 # `ac_cv_env_foo' variables (set or unset) will be overridden when
24268 # loading this file, other *unset* `ac_cv_foo' will be assigned the
24269 # following values.
24270
24271 _ACEOF
24272
24273 # The following way of writing the cache mishandles newlines in values,
24274 # but we know of no workaround that is simple, portable, and efficient.
24275 # So, don't put newlines in cache variables' values.
24276 # Ultrix sh set writes to stderr and can't be redirected directly,
24277 # and sets the high bit in the cache file unless we assign to the vars.
24278 {
24279   (set) 2>&1 |
24280     case `(ac_space=' '; set | grep ac_space) 2>&1` in
24281     *ac_space=\ *)
24282       # `set' does not quote correctly, so add quotes (double-quote
24283       # substitution turns \\\\ into \\, and sed turns \\ into \).
24284       sed -n \
24285         "s/'/'\\\\''/g;
24286           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
24287       ;;
24288     *)
24289       # `set' quotes correctly as required by POSIX, so do not add quotes.
24290       sed -n \
24291         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
24292       ;;
24293     esac;
24294 } |
24295   sed '
24296      t clear
24297      : clear
24298      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
24299      t end
24300      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
24301      : end' >>confcache
24302 if diff $cache_file confcache >/dev/null 2>&1; then :; else
24303   if test -w $cache_file; then
24304     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
24305     cat confcache >$cache_file
24306   else
24307     echo "not updating unwritable cache $cache_file"
24308   fi
24309 fi
24310 rm -f confcache
24311
24312 if test ${multilib} = yes; then
24313   multilib_arg="--enable-multilib"
24314 else
24315   multilib_arg=
24316 fi
24317
24318 # Write our Makefile.
24319           ac_config_files="$ac_config_files Makefile"
24320
24321 cat >confcache <<\_ACEOF
24322 # This file is a shell script that caches the results of configure
24323 # tests run on this system so they can be shared between configure
24324 # scripts and configure runs, see configure's option --config-cache.
24325 # It is not useful on other systems.  If it contains results you don't
24326 # want to keep, you may remove or edit it.
24327 #
24328 # config.status only pays attention to the cache file if you give it
24329 # the --recheck option to rerun configure.
24330 #
24331 # `ac_cv_env_foo' variables (set or unset) will be overridden when
24332 # loading this file, other *unset* `ac_cv_foo' will be assigned the
24333 # following values.
24334
24335 _ACEOF
24336
24337 # The following way of writing the cache mishandles newlines in values,
24338 # but we know of no workaround that is simple, portable, and efficient.
24339 # So, don't put newlines in cache variables' values.
24340 # Ultrix sh set writes to stderr and can't be redirected directly,
24341 # and sets the high bit in the cache file unless we assign to the vars.
24342 {
24343   (set) 2>&1 |
24344     case `(ac_space=' '; set | grep ac_space) 2>&1` in
24345     *ac_space=\ *)
24346       # `set' does not quote correctly, so add quotes (double-quote
24347       # substitution turns \\\\ into \\, and sed turns \\ into \).
24348       sed -n \
24349         "s/'/'\\\\''/g;
24350           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
24351       ;;
24352     *)
24353       # `set' quotes correctly as required by POSIX, so do not add quotes.
24354       sed -n \
24355         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
24356       ;;
24357     esac;
24358 } |
24359   sed '
24360      t clear
24361      : clear
24362      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
24363      t end
24364      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
24365      : end' >>confcache
24366 if diff $cache_file confcache >/dev/null 2>&1; then :; else
24367   if test -w $cache_file; then
24368     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
24369     cat confcache >$cache_file
24370   else
24371     echo "not updating unwritable cache $cache_file"
24372   fi
24373 fi
24374 rm -f confcache
24375
24376 test "x$prefix" = xNONE && prefix=$ac_default_prefix
24377 # Let make expand exec_prefix.
24378 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
24379
24380 # VPATH may cause trouble with some makes, so we remove $(srcdir),
24381 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
24382 # trailing colons and then remove the whole line if VPATH becomes empty
24383 # (actually we leave an empty line to preserve line numbers).
24384 if test "x$srcdir" = x.; then
24385   ac_vpsub='/^[  ]*VPATH[        ]*=/{
24386 s/:*\$(srcdir):*/:/;
24387 s/:*\${srcdir}:*/:/;
24388 s/:*@srcdir@:*/:/;
24389 s/^\([^=]*=[     ]*\):*/\1/;
24390 s/:*$//;
24391 s/^[^=]*=[       ]*$//;
24392 }'
24393 fi
24394
24395 DEFS=-DHAVE_CONFIG_H
24396
24397 ac_libobjs=
24398 ac_ltlibobjs=
24399 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
24400   # 1. Remove the extension, and $U if already installed.
24401   ac_i=`echo "$ac_i" |
24402          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
24403   # 2. Add them.
24404   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
24405   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
24406 done
24407 LIBOBJS=$ac_libobjs
24408
24409 LTLIBOBJS=$ac_ltlibobjs
24410
24411
24412 if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then
24413   { { echo "$as_me:$LINENO: error: conditional \"MAINTAINER_MODE\" was never defined.
24414 Usually this means the macro was only invoked conditionally." >&5
24415 echo "$as_me: error: conditional \"MAINTAINER_MODE\" was never defined.
24416 Usually this means the macro was only invoked conditionally." >&2;}
24417    { (exit 1); exit 1; }; }
24418 fi
24419 if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
24420   { { echo "$as_me:$LINENO: error: conditional \"AMDEP\" was never defined.
24421 Usually this means the macro was only invoked conditionally." >&5
24422 echo "$as_me: error: conditional \"AMDEP\" was never defined.
24423 Usually this means the macro was only invoked conditionally." >&2;}
24424    { (exit 1); exit 1; }; }
24425 fi
24426 if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
24427   { { echo "$as_me:$LINENO: error: conditional \"am__fastdepCC\" was never defined.
24428 Usually this means the macro was only invoked conditionally." >&5
24429 echo "$as_me: error: conditional \"am__fastdepCC\" was never defined.
24430 Usually this means the macro was only invoked conditionally." >&2;}
24431    { (exit 1); exit 1; }; }
24432 fi
24433
24434 : ${CONFIG_STATUS=./config.status}
24435 ac_clean_files_save=$ac_clean_files
24436 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
24437 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
24438 echo "$as_me: creating $CONFIG_STATUS" >&6;}
24439 cat >$CONFIG_STATUS <<_ACEOF
24440 #! $SHELL
24441 # Generated by $as_me.
24442 # Run this file to recreate the current configuration.
24443 # Compiler output produced by configure, useful for debugging
24444 # configure, is in config.log if it exists.
24445
24446 debug=false
24447 ac_cs_recheck=false
24448 ac_cs_silent=false
24449 SHELL=\${CONFIG_SHELL-$SHELL}
24450 _ACEOF
24451
24452 cat >>$CONFIG_STATUS <<\_ACEOF
24453 ## --------------------- ##
24454 ## M4sh Initialization.  ##
24455 ## --------------------- ##
24456
24457 # Be Bourne compatible
24458 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
24459   emulate sh
24460   NULLCMD=:
24461   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
24462   # is contrary to our usage.  Disable this feature.
24463   alias -g '${1+"$@"}'='"$@"'
24464 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
24465   set -o posix
24466 fi
24467 DUALCASE=1; export DUALCASE # for MKS sh
24468
24469 # Support unset when possible.
24470 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
24471   as_unset=unset
24472 else
24473   as_unset=false
24474 fi
24475
24476
24477 # Work around bugs in pre-3.0 UWIN ksh.
24478 $as_unset ENV MAIL MAILPATH
24479 PS1='$ '
24480 PS2='> '
24481 PS4='+ '
24482
24483 # NLS nuisances.
24484 for as_var in \
24485   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
24486   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
24487   LC_TELEPHONE LC_TIME
24488 do
24489   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
24490     eval $as_var=C; export $as_var
24491   else
24492     $as_unset $as_var
24493   fi
24494 done
24495
24496 # Required to use basename.
24497 if expr a : '\(a\)' >/dev/null 2>&1; then
24498   as_expr=expr
24499 else
24500   as_expr=false
24501 fi
24502
24503 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
24504   as_basename=basename
24505 else
24506   as_basename=false
24507 fi
24508
24509
24510 # Name of the executable.
24511 as_me=`$as_basename "$0" ||
24512 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
24513          X"$0" : 'X\(//\)$' \| \
24514          X"$0" : 'X\(/\)$' \| \
24515          .     : '\(.\)' 2>/dev/null ||
24516 echo X/"$0" |
24517     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
24518           /^X\/\(\/\/\)$/{ s//\1/; q; }
24519           /^X\/\(\/\).*/{ s//\1/; q; }
24520           s/.*/./; q'`
24521
24522
24523 # PATH needs CR, and LINENO needs CR and PATH.
24524 # Avoid depending upon Character Ranges.
24525 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
24526 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
24527 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
24528 as_cr_digits='0123456789'
24529 as_cr_alnum=$as_cr_Letters$as_cr_digits
24530
24531 # The user is always right.
24532 if test "${PATH_SEPARATOR+set}" != set; then
24533   echo "#! /bin/sh" >conf$$.sh
24534   echo  "exit 0"   >>conf$$.sh
24535   chmod +x conf$$.sh
24536   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
24537     PATH_SEPARATOR=';'
24538   else
24539     PATH_SEPARATOR=:
24540   fi
24541   rm -f conf$$.sh
24542 fi
24543
24544
24545   as_lineno_1=$LINENO
24546   as_lineno_2=$LINENO
24547   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
24548   test "x$as_lineno_1" != "x$as_lineno_2" &&
24549   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
24550   # Find who we are.  Look in the path if we contain no path at all
24551   # relative or not.
24552   case $0 in
24553     *[\\/]* ) as_myself=$0 ;;
24554     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24555 for as_dir in $PATH
24556 do
24557   IFS=$as_save_IFS
24558   test -z "$as_dir" && as_dir=.
24559   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
24560 done
24561
24562        ;;
24563   esac
24564   # We did not find ourselves, most probably we were run as `sh COMMAND'
24565   # in which case we are not to be found in the path.
24566   if test "x$as_myself" = x; then
24567     as_myself=$0
24568   fi
24569   if test ! -f "$as_myself"; then
24570     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
24571 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
24572    { (exit 1); exit 1; }; }
24573   fi
24574   case $CONFIG_SHELL in
24575   '')
24576     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24577 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
24578 do
24579   IFS=$as_save_IFS
24580   test -z "$as_dir" && as_dir=.
24581   for as_base in sh bash ksh sh5; do
24582          case $as_dir in
24583          /*)
24584            if ("$as_dir/$as_base" -c '
24585   as_lineno_1=$LINENO
24586   as_lineno_2=$LINENO
24587   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
24588   test "x$as_lineno_1" != "x$as_lineno_2" &&
24589   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
24590              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
24591              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
24592              CONFIG_SHELL=$as_dir/$as_base
24593              export CONFIG_SHELL
24594              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
24595            fi;;
24596          esac
24597        done
24598 done
24599 ;;
24600   esac
24601
24602   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
24603   # uniformly replaced by the line number.  The first 'sed' inserts a
24604   # line-number line before each line; the second 'sed' does the real
24605   # work.  The second script uses 'N' to pair each line-number line
24606   # with the numbered line, and appends trailing '-' during
24607   # substitution so that $LINENO is not a special case at line end.
24608   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
24609   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
24610   sed '=' <$as_myself |
24611     sed '
24612       N
24613       s,$,-,
24614       : loop
24615       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
24616       t loop
24617       s,-$,,
24618       s,^['$as_cr_digits']*\n,,
24619     ' >$as_me.lineno &&
24620   chmod +x $as_me.lineno ||
24621     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
24622 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
24623    { (exit 1); exit 1; }; }
24624
24625   # Don't try to exec as it changes $[0], causing all sort of problems
24626   # (the dirname of $[0] is not the place where we might find the
24627   # original and so on.  Autoconf is especially sensible to this).
24628   . ./$as_me.lineno
24629   # Exit status is that of the last command.
24630   exit
24631 }
24632
24633
24634 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
24635   *c*,-n*) ECHO_N= ECHO_C='
24636 ' ECHO_T='      ' ;;
24637   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
24638   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
24639 esac
24640
24641 if expr a : '\(a\)' >/dev/null 2>&1; then
24642   as_expr=expr
24643 else
24644   as_expr=false
24645 fi
24646
24647 rm -f conf$$ conf$$.exe conf$$.file
24648 echo >conf$$.file
24649 if ln -s conf$$.file conf$$ 2>/dev/null; then
24650   # We could just check for DJGPP; but this test a) works b) is more generic
24651   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
24652   if test -f conf$$.exe; then
24653     # Don't use ln at all; we don't have any links
24654     as_ln_s='cp -p'
24655   else
24656     as_ln_s='ln -s'
24657   fi
24658 elif ln conf$$.file conf$$ 2>/dev/null; then
24659   as_ln_s=ln
24660 else
24661   as_ln_s='cp -p'
24662 fi
24663 rm -f conf$$ conf$$.exe conf$$.file
24664
24665 if mkdir -p . 2>/dev/null; then
24666   as_mkdir_p=:
24667 else
24668   test -d ./-p && rmdir ./-p
24669   as_mkdir_p=false
24670 fi
24671
24672 as_executable_p="test -f"
24673
24674 # Sed expression to map a string onto a valid CPP name.
24675 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
24676
24677 # Sed expression to map a string onto a valid variable name.
24678 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
24679
24680
24681 # IFS
24682 # We need space, tab and new line, in precisely that order.
24683 as_nl='
24684 '
24685 IFS="   $as_nl"
24686
24687 # CDPATH.
24688 $as_unset CDPATH
24689
24690 exec 6>&1
24691
24692 # Open the log real soon, to keep \$[0] and so on meaningful, and to
24693 # report actual input values of CONFIG_FILES etc. instead of their
24694 # values after options handling.  Logging --version etc. is OK.
24695 exec 5>>config.log
24696 {
24697   echo
24698   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
24699 ## Running $as_me. ##
24700 _ASBOX
24701 } >&5
24702 cat >&5 <<_CSEOF
24703
24704 This file was extended by GNU Fortran Runtime Library $as_me 0.3, which was
24705 generated by GNU Autoconf 2.59.  Invocation command line was
24706
24707   CONFIG_FILES    = $CONFIG_FILES
24708   CONFIG_HEADERS  = $CONFIG_HEADERS
24709   CONFIG_LINKS    = $CONFIG_LINKS
24710   CONFIG_COMMANDS = $CONFIG_COMMANDS
24711   $ $0 $@
24712
24713 _CSEOF
24714 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
24715 echo >&5
24716 _ACEOF
24717
24718 # Files that config.status was made for.
24719 if test -n "$ac_config_files"; then
24720   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
24721 fi
24722
24723 if test -n "$ac_config_headers"; then
24724   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
24725 fi
24726
24727 if test -n "$ac_config_links"; then
24728   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
24729 fi
24730
24731 if test -n "$ac_config_commands"; then
24732   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
24733 fi
24734
24735 cat >>$CONFIG_STATUS <<\_ACEOF
24736
24737 ac_cs_usage="\
24738 \`$as_me' instantiates files from templates according to the
24739 current configuration.
24740
24741 Usage: $0 [OPTIONS] [FILE]...
24742
24743   -h, --help       print this help, then exit
24744   -V, --version    print version number, then exit
24745   -q, --quiet      do not print progress messages
24746   -d, --debug      don't remove temporary files
24747       --recheck    update $as_me by reconfiguring in the same conditions
24748   --file=FILE[:TEMPLATE]
24749                    instantiate the configuration file FILE
24750   --header=FILE[:TEMPLATE]
24751                    instantiate the configuration header FILE
24752
24753 Configuration files:
24754 $config_files
24755
24756 Configuration headers:
24757 $config_headers
24758
24759 Configuration commands:
24760 $config_commands
24761
24762 Report bugs to <bug-autoconf@gnu.org>."
24763 _ACEOF
24764
24765 cat >>$CONFIG_STATUS <<_ACEOF
24766 ac_cs_version="\\
24767 GNU Fortran Runtime Library config.status 0.3
24768 configured by $0, generated by GNU Autoconf 2.59,
24769   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
24770
24771 Copyright (C) 2003 Free Software Foundation, Inc.
24772 This config.status script is free software; the Free Software Foundation
24773 gives unlimited permission to copy, distribute and modify it."
24774 srcdir=$srcdir
24775 INSTALL="$INSTALL"
24776 _ACEOF
24777
24778 cat >>$CONFIG_STATUS <<\_ACEOF
24779 # If no file are specified by the user, then we need to provide default
24780 # value.  By we need to know if files were specified by the user.
24781 ac_need_defaults=:
24782 while test $# != 0
24783 do
24784   case $1 in
24785   --*=*)
24786     ac_option=`expr "x$1" : 'x\([^=]*\)='`
24787     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
24788     ac_shift=:
24789     ;;
24790   -*)
24791     ac_option=$1
24792     ac_optarg=$2
24793     ac_shift=shift
24794     ;;
24795   *) # This is not an option, so the user has probably given explicit
24796      # arguments.
24797      ac_option=$1
24798      ac_need_defaults=false;;
24799   esac
24800
24801   case $ac_option in
24802   # Handling of the options.
24803 _ACEOF
24804 cat >>$CONFIG_STATUS <<\_ACEOF
24805   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
24806     ac_cs_recheck=: ;;
24807   --version | --vers* | -V )
24808     echo "$ac_cs_version"; exit 0 ;;
24809   --he | --h)
24810     # Conflict between --help and --header
24811     { { echo "$as_me:$LINENO: error: ambiguous option: $1
24812 Try \`$0 --help' for more information." >&5
24813 echo "$as_me: error: ambiguous option: $1
24814 Try \`$0 --help' for more information." >&2;}
24815    { (exit 1); exit 1; }; };;
24816   --help | --hel | -h )
24817     echo "$ac_cs_usage"; exit 0 ;;
24818   --debug | --d* | -d )
24819     debug=: ;;
24820   --file | --fil | --fi | --f )
24821     $ac_shift
24822     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
24823     ac_need_defaults=false;;
24824   --header | --heade | --head | --hea )
24825     $ac_shift
24826     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
24827     ac_need_defaults=false;;
24828   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
24829   | -silent | --silent | --silen | --sile | --sil | --si | --s)
24830     ac_cs_silent=: ;;
24831
24832   # This is an error.
24833   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
24834 Try \`$0 --help' for more information." >&5
24835 echo "$as_me: error: unrecognized option: $1
24836 Try \`$0 --help' for more information." >&2;}
24837    { (exit 1); exit 1; }; } ;;
24838
24839   *) ac_config_targets="$ac_config_targets $1" ;;
24840
24841   esac
24842   shift
24843 done
24844
24845 ac_configure_extra_args=
24846
24847 if $ac_cs_silent; then
24848   exec 6>/dev/null
24849   ac_configure_extra_args="$ac_configure_extra_args --silent"
24850 fi
24851
24852 _ACEOF
24853 cat >>$CONFIG_STATUS <<_ACEOF
24854 if \$ac_cs_recheck; then
24855   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
24856   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
24857 fi
24858
24859 _ACEOF
24860
24861 cat >>$CONFIG_STATUS <<_ACEOF
24862 #
24863 # INIT-COMMANDS section.
24864 #
24865
24866
24867 srcdir="$srcdir"
24868 host="$host"
24869 target="$target"
24870 with_multisubdir="$with_multisubdir"
24871 with_multisrctop="$with_multisrctop"
24872 with_target_subdir="$with_target_subdir"
24873 ac_configure_args="${multilib_arg} ${ac_configure_args}"
24874 multi_basedir="$multi_basedir"
24875 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
24876 CC="$CC"
24877 AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
24878
24879 GCC="$GCC"
24880 CC="$CC"
24881 acx_cv_header_stdint="$acx_cv_header_stdint"
24882 acx_cv_type_int8_t="$acx_cv_type_int8_t"
24883 acx_cv_type_int16_t="$acx_cv_type_int16_t"
24884 acx_cv_type_int32_t="$acx_cv_type_int32_t"
24885 acx_cv_type_int64_t="$acx_cv_type_int64_t"
24886 acx_cv_type_intptr_t="$acx_cv_type_intptr_t"
24887 ac_cv_type_uintmax_t="$ac_cv_type_uintmax_t"
24888 ac_cv_type_uintptr_t="$ac_cv_type_uintptr_t"
24889 ac_cv_type_uint64_t="$ac_cv_type_uint64_t"
24890 ac_cv_type_u_int64_t="$ac_cv_type_u_int64_t"
24891 ac_cv_type_u_int32_t="$ac_cv_type_u_int32_t"
24892 ac_cv_type_int_least32_t="$ac_cv_type_int_least32_t"
24893 ac_cv_type_int_fast32_t="$ac_cv_type_int_fast32_t"
24894 ac_cv_sizeof_void_p="$ac_cv_sizeof_void_p"
24895
24896
24897 _ACEOF
24898
24899
24900
24901 cat >>$CONFIG_STATUS <<\_ACEOF
24902 for ac_config_target in $ac_config_targets
24903 do
24904   case "$ac_config_target" in
24905   # Handling of arguments.
24906   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
24907   "default-1" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default-1" ;;
24908   "depfiles" ) CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
24909   "gstdint.h" ) CONFIG_COMMANDS="$CONFIG_COMMANDS gstdint.h" ;;
24910   "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
24911   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
24912 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
24913    { (exit 1); exit 1; }; };;
24914   esac
24915 done
24916
24917 # If the user did not use the arguments to specify the items to instantiate,
24918 # then the envvar interface is used.  Set only those that are not.
24919 # We use the long form for the default assignment because of an extremely
24920 # bizarre bug on SunOS 4.1.3.
24921 if $ac_need_defaults; then
24922   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
24923   test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
24924   test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
24925 fi
24926
24927 # Have a temporary directory for convenience.  Make it in the build tree
24928 # simply because there is no reason to put it here, and in addition,
24929 # creating and moving files from /tmp can sometimes cause problems.
24930 # Create a temporary directory, and hook for its removal unless debugging.
24931 $debug ||
24932 {
24933   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
24934   trap '{ (exit 1); exit 1; }' 1 2 13 15
24935 }
24936
24937 # Create a (secure) tmp directory for tmp files.
24938
24939 {
24940   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
24941   test -n "$tmp" && test -d "$tmp"
24942 }  ||
24943 {
24944   tmp=./confstat$$-$RANDOM
24945   (umask 077 && mkdir $tmp)
24946 } ||
24947 {
24948    echo "$me: cannot create a temporary directory in ." >&2
24949    { (exit 1); exit 1; }
24950 }
24951
24952 _ACEOF
24953
24954 cat >>$CONFIG_STATUS <<_ACEOF
24955
24956 #
24957 # CONFIG_FILES section.
24958 #
24959
24960 # No need to generate the scripts if there are no CONFIG_FILES.
24961 # This happens for instance when ./config.status config.h
24962 if test -n "\$CONFIG_FILES"; then
24963   # Protect against being on the right side of a sed subst in config.status.
24964   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
24965    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
24966 s,@SHELL@,$SHELL,;t t
24967 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
24968 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
24969 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
24970 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
24971 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
24972 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
24973 s,@exec_prefix@,$exec_prefix,;t t
24974 s,@prefix@,$prefix,;t t
24975 s,@program_transform_name@,$program_transform_name,;t t
24976 s,@bindir@,$bindir,;t t
24977 s,@sbindir@,$sbindir,;t t
24978 s,@libexecdir@,$libexecdir,;t t
24979 s,@datadir@,$datadir,;t t
24980 s,@sysconfdir@,$sysconfdir,;t t
24981 s,@sharedstatedir@,$sharedstatedir,;t t
24982 s,@localstatedir@,$localstatedir,;t t
24983 s,@libdir@,$libdir,;t t
24984 s,@includedir@,$includedir,;t t
24985 s,@oldincludedir@,$oldincludedir,;t t
24986 s,@infodir@,$infodir,;t t
24987 s,@mandir@,$mandir,;t t
24988 s,@build_alias@,$build_alias,;t t
24989 s,@host_alias@,$host_alias,;t t
24990 s,@target_alias@,$target_alias,;t t
24991 s,@DEFS@,$DEFS,;t t
24992 s,@ECHO_C@,$ECHO_C,;t t
24993 s,@ECHO_N@,$ECHO_N,;t t
24994 s,@ECHO_T@,$ECHO_T,;t t
24995 s,@LIBS@,$LIBS,;t t
24996 s,@build@,$build,;t t
24997 s,@build_cpu@,$build_cpu,;t t
24998 s,@build_vendor@,$build_vendor,;t t
24999 s,@build_os@,$build_os,;t t
25000 s,@build_libsubdir@,$build_libsubdir,;t t
25001 s,@build_subdir@,$build_subdir,;t t
25002 s,@host_subdir@,$host_subdir,;t t
25003 s,@target_subdir@,$target_subdir,;t t
25004 s,@host@,$host,;t t
25005 s,@host_cpu@,$host_cpu,;t t
25006 s,@host_vendor@,$host_vendor,;t t
25007 s,@host_os@,$host_os,;t t
25008 s,@target@,$target,;t t
25009 s,@target_cpu@,$target_cpu,;t t
25010 s,@target_vendor@,$target_vendor,;t t
25011 s,@target_os@,$target_os,;t t
25012 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
25013 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
25014 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
25015 s,@CYGPATH_W@,$CYGPATH_W,;t t
25016 s,@PACKAGE@,$PACKAGE,;t t
25017 s,@VERSION@,$VERSION,;t t
25018 s,@ACLOCAL@,$ACLOCAL,;t t
25019 s,@AUTOCONF@,$AUTOCONF,;t t
25020 s,@AUTOMAKE@,$AUTOMAKE,;t t
25021 s,@AUTOHEADER@,$AUTOHEADER,;t t
25022 s,@MAKEINFO@,$MAKEINFO,;t t
25023 s,@install_sh@,$install_sh,;t t
25024 s,@STRIP@,$STRIP,;t t
25025 s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t
25026 s,@INSTALL_STRIP_PROGRAM@,$INSTALL_STRIP_PROGRAM,;t t
25027 s,@mkdir_p@,$mkdir_p,;t t
25028 s,@AWK@,$AWK,;t t
25029 s,@SET_MAKE@,$SET_MAKE,;t t
25030 s,@am__leading_dot@,$am__leading_dot,;t t
25031 s,@AMTAR@,$AMTAR,;t t
25032 s,@am__tar@,$am__tar,;t t
25033 s,@am__untar@,$am__untar,;t t
25034 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
25035 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
25036 s,@MAINT@,$MAINT,;t t
25037 s,@multi_basedir@,$multi_basedir,;t t
25038 s,@toolexecdir@,$toolexecdir,;t t
25039 s,@toolexeclibdir@,$toolexeclibdir,;t t
25040 s,@CC@,$CC,;t t
25041 s,@ac_ct_CC@,$ac_ct_CC,;t t
25042 s,@EXEEXT@,$EXEEXT,;t t
25043 s,@OBJEXT@,$OBJEXT,;t t
25044 s,@DEPDIR@,$DEPDIR,;t t
25045 s,@am__include@,$am__include,;t t
25046 s,@am__quote@,$am__quote,;t t
25047 s,@AMDEP_TRUE@,$AMDEP_TRUE,;t t
25048 s,@AMDEP_FALSE@,$AMDEP_FALSE,;t t
25049 s,@AMDEPBACKSLASH@,$AMDEPBACKSLASH,;t t
25050 s,@CCDEPMODE@,$CCDEPMODE,;t t
25051 s,@am__fastdepCC_TRUE@,$am__fastdepCC_TRUE,;t t
25052 s,@am__fastdepCC_FALSE@,$am__fastdepCC_FALSE,;t t
25053 s,@AM_FCFLAGS@,$AM_FCFLAGS,;t t
25054 s,@AM_CFLAGS@,$AM_CFLAGS,;t t
25055 s,@AS@,$AS,;t t
25056 s,@ac_ct_AS@,$ac_ct_AS,;t t
25057 s,@AR@,$AR,;t t
25058 s,@ac_ct_AR@,$ac_ct_AR,;t t
25059 s,@RANLIB@,$RANLIB,;t t
25060 s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
25061 s,@LN_S@,$LN_S,;t t
25062 s,@LIBTOOL@,$LIBTOOL,;t t
25063 s,@enable_shared@,$enable_shared,;t t
25064 s,@enable_static@,$enable_static,;t t
25065 s,@FC@,$FC,;t t
25066 s,@FCFLAGS@,$FCFLAGS,;t t
25067 s,@LDFLAGS@,$LDFLAGS,;t t
25068 s,@ac_ct_FC@,$ac_ct_FC,;t t
25069 s,@extra_ldflags_libgfortran@,$extra_ldflags_libgfortran,;t t
25070 s,@CPP@,$CPP,;t t
25071 s,@CPPFLAGS@,$CPPFLAGS,;t t
25072 s,@EGREP@,$EGREP,;t t
25073 s,@FPU_HOST_HEADER@,$FPU_HOST_HEADER,;t t
25074 s,@LIBOBJS@,$LIBOBJS,;t t
25075 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
25076 CEOF
25077
25078 _ACEOF
25079
25080   cat >>$CONFIG_STATUS <<\_ACEOF
25081   # Split the substitutions into bite-sized pieces for seds with
25082   # small command number limits, like on Digital OSF/1 and HP-UX.
25083   ac_max_sed_lines=48
25084   ac_sed_frag=1 # Number of current file.
25085   ac_beg=1 # First line for current file.
25086   ac_end=$ac_max_sed_lines # Line after last line for current file.
25087   ac_more_lines=:
25088   ac_sed_cmds=
25089   while $ac_more_lines; do
25090     if test $ac_beg -gt 1; then
25091       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
25092     else
25093       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
25094     fi
25095     if test ! -s $tmp/subs.frag; then
25096       ac_more_lines=false
25097     else
25098       # The purpose of the label and of the branching condition is to
25099       # speed up the sed processing (if there are no `@' at all, there
25100       # is no need to browse any of the substitutions).
25101       # These are the two extra sed commands mentioned above.
25102       (echo ':t
25103   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
25104       if test -z "$ac_sed_cmds"; then
25105         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
25106       else
25107         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
25108       fi
25109       ac_sed_frag=`expr $ac_sed_frag + 1`
25110       ac_beg=$ac_end
25111       ac_end=`expr $ac_end + $ac_max_sed_lines`
25112     fi
25113   done
25114   if test -z "$ac_sed_cmds"; then
25115     ac_sed_cmds=cat
25116   fi
25117 fi # test -n "$CONFIG_FILES"
25118
25119 _ACEOF
25120 cat >>$CONFIG_STATUS <<\_ACEOF
25121 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
25122   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
25123   case $ac_file in
25124   - | *:- | *:-:* ) # input from stdin
25125         cat >$tmp/stdin
25126         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25127         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25128   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25129         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25130   * )   ac_file_in=$ac_file.in ;;
25131   esac
25132
25133   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
25134   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
25135 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25136          X"$ac_file" : 'X\(//\)[^/]' \| \
25137          X"$ac_file" : 'X\(//\)$' \| \
25138          X"$ac_file" : 'X\(/\)' \| \
25139          .     : '\(.\)' 2>/dev/null ||
25140 echo X"$ac_file" |
25141     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25142           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25143           /^X\(\/\/\)$/{ s//\1/; q; }
25144           /^X\(\/\).*/{ s//\1/; q; }
25145           s/.*/./; q'`
25146   { if $as_mkdir_p; then
25147     mkdir -p "$ac_dir"
25148   else
25149     as_dir="$ac_dir"
25150     as_dirs=
25151     while test ! -d "$as_dir"; do
25152       as_dirs="$as_dir $as_dirs"
25153       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25154 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25155          X"$as_dir" : 'X\(//\)[^/]' \| \
25156          X"$as_dir" : 'X\(//\)$' \| \
25157          X"$as_dir" : 'X\(/\)' \| \
25158          .     : '\(.\)' 2>/dev/null ||
25159 echo X"$as_dir" |
25160     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25161           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25162           /^X\(\/\/\)$/{ s//\1/; q; }
25163           /^X\(\/\).*/{ s//\1/; q; }
25164           s/.*/./; q'`
25165     done
25166     test ! -n "$as_dirs" || mkdir $as_dirs
25167   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
25168 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
25169    { (exit 1); exit 1; }; }; }
25170
25171   ac_builddir=.
25172
25173 if test "$ac_dir" != .; then
25174   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
25175   # A "../" for each directory in $ac_dir_suffix.
25176   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
25177 else
25178   ac_dir_suffix= ac_top_builddir=
25179 fi
25180
25181 case $srcdir in
25182   .)  # No --srcdir option.  We are building in place.
25183     ac_srcdir=.
25184     if test -z "$ac_top_builddir"; then
25185        ac_top_srcdir=.
25186     else
25187        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
25188     fi ;;
25189   [\\/]* | ?:[\\/]* )  # Absolute path.
25190     ac_srcdir=$srcdir$ac_dir_suffix;
25191     ac_top_srcdir=$srcdir ;;
25192   *) # Relative path.
25193     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
25194     ac_top_srcdir=$ac_top_builddir$srcdir ;;
25195 esac
25196
25197 # Do not use `cd foo && pwd` to compute absolute paths, because
25198 # the directories may not exist.
25199 case `pwd` in
25200 .) ac_abs_builddir="$ac_dir";;
25201 *)
25202   case "$ac_dir" in
25203   .) ac_abs_builddir=`pwd`;;
25204   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
25205   *) ac_abs_builddir=`pwd`/"$ac_dir";;
25206   esac;;
25207 esac
25208 case $ac_abs_builddir in
25209 .) ac_abs_top_builddir=${ac_top_builddir}.;;
25210 *)
25211   case ${ac_top_builddir}. in
25212   .) ac_abs_top_builddir=$ac_abs_builddir;;
25213   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
25214   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
25215   esac;;
25216 esac
25217 case $ac_abs_builddir in
25218 .) ac_abs_srcdir=$ac_srcdir;;
25219 *)
25220   case $ac_srcdir in
25221   .) ac_abs_srcdir=$ac_abs_builddir;;
25222   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
25223   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
25224   esac;;
25225 esac
25226 case $ac_abs_builddir in
25227 .) ac_abs_top_srcdir=$ac_top_srcdir;;
25228 *)
25229   case $ac_top_srcdir in
25230   .) ac_abs_top_srcdir=$ac_abs_builddir;;
25231   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
25232   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
25233   esac;;
25234 esac
25235
25236
25237   case $INSTALL in
25238   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
25239   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
25240   esac
25241
25242   if test x"$ac_file" != x-; then
25243     { echo "$as_me:$LINENO: creating $ac_file" >&5
25244 echo "$as_me: creating $ac_file" >&6;}
25245     rm -f "$ac_file"
25246   fi
25247   # Let's still pretend it is `configure' which instantiates (i.e., don't
25248   # use $as_me), people would be surprised to read:
25249   #    /* config.h.  Generated by config.status.  */
25250   if test x"$ac_file" = x-; then
25251     configure_input=
25252   else
25253     configure_input="$ac_file.  "
25254   fi
25255   configure_input=$configure_input"Generated from `echo $ac_file_in |
25256                                      sed 's,.*/,,'` by configure."
25257
25258   # First look for the input files in the build tree, otherwise in the
25259   # src tree.
25260   ac_file_inputs=`IFS=:
25261     for f in $ac_file_in; do
25262       case $f in
25263       -) echo $tmp/stdin ;;
25264       [\\/$]*)
25265          # Absolute (can't be DOS-style, as IFS=:)
25266          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25267 echo "$as_me: error: cannot find input file: $f" >&2;}
25268    { (exit 1); exit 1; }; }
25269          echo "$f";;
25270       *) # Relative
25271          if test -f "$f"; then
25272            # Build tree
25273            echo "$f"
25274          elif test -f "$srcdir/$f"; then
25275            # Source tree
25276            echo "$srcdir/$f"
25277          else
25278            # /dev/null tree
25279            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25280 echo "$as_me: error: cannot find input file: $f" >&2;}
25281    { (exit 1); exit 1; }; }
25282          fi;;
25283       esac
25284     done` || { (exit 1); exit 1; }
25285 _ACEOF
25286 cat >>$CONFIG_STATUS <<_ACEOF
25287   sed "$ac_vpsub
25288 $extrasub
25289 _ACEOF
25290 cat >>$CONFIG_STATUS <<\_ACEOF
25291 :t
25292 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
25293 s,@configure_input@,$configure_input,;t t
25294 s,@srcdir@,$ac_srcdir,;t t
25295 s,@abs_srcdir@,$ac_abs_srcdir,;t t
25296 s,@top_srcdir@,$ac_top_srcdir,;t t
25297 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
25298 s,@builddir@,$ac_builddir,;t t
25299 s,@abs_builddir@,$ac_abs_builddir,;t t
25300 s,@top_builddir@,$ac_top_builddir,;t t
25301 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
25302 s,@INSTALL@,$ac_INSTALL,;t t
25303 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
25304   rm -f $tmp/stdin
25305   if test x"$ac_file" != x-; then
25306     mv $tmp/out $ac_file
25307   else
25308     cat $tmp/out
25309     rm -f $tmp/out
25310   fi
25311
25312 done
25313 _ACEOF
25314 cat >>$CONFIG_STATUS <<\_ACEOF
25315
25316 #
25317 # CONFIG_HEADER section.
25318 #
25319
25320 # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
25321 # NAME is the cpp macro being defined and VALUE is the value it is being given.
25322 #
25323 # ac_d sets the value in "#define NAME VALUE" lines.
25324 ac_dA='s,^\([    ]*\)#\([        ]*define[       ][      ]*\)'
25325 ac_dB='[         ].*$,\1#\2'
25326 ac_dC=' '
25327 ac_dD=',;t'
25328 # ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
25329 ac_uA='s,^\([    ]*\)#\([        ]*\)undef\([    ][      ]*\)'
25330 ac_uB='$,\1#\2define\3'
25331 ac_uC=' '
25332 ac_uD=',;t'
25333
25334 for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue
25335   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
25336   case $ac_file in
25337   - | *:- | *:-:* ) # input from stdin
25338         cat >$tmp/stdin
25339         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25340         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25341   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25342         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25343   * )   ac_file_in=$ac_file.in ;;
25344   esac
25345
25346   test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5
25347 echo "$as_me: creating $ac_file" >&6;}
25348
25349   # First look for the input files in the build tree, otherwise in the
25350   # src tree.
25351   ac_file_inputs=`IFS=:
25352     for f in $ac_file_in; do
25353       case $f in
25354       -) echo $tmp/stdin ;;
25355       [\\/$]*)
25356          # Absolute (can't be DOS-style, as IFS=:)
25357          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25358 echo "$as_me: error: cannot find input file: $f" >&2;}
25359    { (exit 1); exit 1; }; }
25360          # Do quote $f, to prevent DOS paths from being IFS'd.
25361          echo "$f";;
25362       *) # Relative
25363          if test -f "$f"; then
25364            # Build tree
25365            echo "$f"
25366          elif test -f "$srcdir/$f"; then
25367            # Source tree
25368            echo "$srcdir/$f"
25369          else
25370            # /dev/null tree
25371            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25372 echo "$as_me: error: cannot find input file: $f" >&2;}
25373    { (exit 1); exit 1; }; }
25374          fi;;
25375       esac
25376     done` || { (exit 1); exit 1; }
25377   # Remove the trailing spaces.
25378   sed 's/[       ]*$//' $ac_file_inputs >$tmp/in
25379
25380 _ACEOF
25381
25382 # Transform confdefs.h into two sed scripts, `conftest.defines' and
25383 # `conftest.undefs', that substitutes the proper values into
25384 # config.h.in to produce config.h.  The first handles `#define'
25385 # templates, and the second `#undef' templates.
25386 # And first: Protect against being on the right side of a sed subst in
25387 # config.status.  Protect against being in an unquoted here document
25388 # in config.status.
25389 rm -f conftest.defines conftest.undefs
25390 # Using a here document instead of a string reduces the quoting nightmare.
25391 # Putting comments in sed scripts is not portable.
25392 #
25393 # `end' is used to avoid that the second main sed command (meant for
25394 # 0-ary CPP macros) applies to n-ary macro definitions.
25395 # See the Autoconf documentation for `clear'.
25396 cat >confdef2sed.sed <<\_ACEOF
25397 s/[\\&,]/\\&/g
25398 s,[\\$`],\\&,g
25399 t clear
25400 : clear
25401 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
25402 t end
25403 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
25404 : end
25405 _ACEOF
25406 # If some macros were called several times there might be several times
25407 # the same #defines, which is useless.  Nevertheless, we may not want to
25408 # sort them, since we want the *last* AC-DEFINE to be honored.
25409 uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines
25410 sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs
25411 rm -f confdef2sed.sed
25412
25413 # This sed command replaces #undef with comments.  This is necessary, for
25414 # example, in the case of _POSIX_SOURCE, which is predefined and required
25415 # on some systems where configure will not decide to define it.
25416 cat >>conftest.undefs <<\_ACEOF
25417 s,^[     ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
25418 _ACEOF
25419
25420 # Break up conftest.defines because some shells have a limit on the size
25421 # of here documents, and old seds have small limits too (100 cmds).
25422 echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
25423 echo '  if grep "^[      ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
25424 echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
25425 echo '  :' >>$CONFIG_STATUS
25426 rm -f conftest.tail
25427 while grep . conftest.defines >/dev/null
25428 do
25429   # Write a limited-size here document to $tmp/defines.sed.
25430   echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
25431   # Speed up: don't consider the non `#define' lines.
25432   echo '/^[      ]*#[    ]*define/!b' >>$CONFIG_STATUS
25433   # Work around the forget-to-reset-the-flag bug.
25434   echo 't clr' >>$CONFIG_STATUS
25435   echo ': clr' >>$CONFIG_STATUS
25436   sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS
25437   echo 'CEOF
25438   sed -f $tmp/defines.sed $tmp/in >$tmp/out
25439   rm -f $tmp/in
25440   mv $tmp/out $tmp/in
25441 ' >>$CONFIG_STATUS
25442   sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail
25443   rm -f conftest.defines
25444   mv conftest.tail conftest.defines
25445 done
25446 rm -f conftest.defines
25447 echo '  fi # grep' >>$CONFIG_STATUS
25448 echo >>$CONFIG_STATUS
25449
25450 # Break up conftest.undefs because some shells have a limit on the size
25451 # of here documents, and old seds have small limits too (100 cmds).
25452 echo '  # Handle all the #undef templates' >>$CONFIG_STATUS
25453 rm -f conftest.tail
25454 while grep . conftest.undefs >/dev/null
25455 do
25456   # Write a limited-size here document to $tmp/undefs.sed.
25457   echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
25458   # Speed up: don't consider the non `#undef'
25459   echo '/^[      ]*#[    ]*undef/!b' >>$CONFIG_STATUS
25460   # Work around the forget-to-reset-the-flag bug.
25461   echo 't clr' >>$CONFIG_STATUS
25462   echo ': clr' >>$CONFIG_STATUS
25463   sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS
25464   echo 'CEOF
25465   sed -f $tmp/undefs.sed $tmp/in >$tmp/out
25466   rm -f $tmp/in
25467   mv $tmp/out $tmp/in
25468 ' >>$CONFIG_STATUS
25469   sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail
25470   rm -f conftest.undefs
25471   mv conftest.tail conftest.undefs
25472 done
25473 rm -f conftest.undefs
25474
25475 cat >>$CONFIG_STATUS <<\_ACEOF
25476   # Let's still pretend it is `configure' which instantiates (i.e., don't
25477   # use $as_me), people would be surprised to read:
25478   #    /* config.h.  Generated by config.status.  */
25479   if test x"$ac_file" = x-; then
25480     echo "/* Generated by configure.  */" >$tmp/config.h
25481   else
25482     echo "/* $ac_file.  Generated by configure.  */" >$tmp/config.h
25483   fi
25484   cat $tmp/in >>$tmp/config.h
25485   rm -f $tmp/in
25486   if test x"$ac_file" != x-; then
25487     if diff $ac_file $tmp/config.h >/dev/null 2>&1; then
25488       { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
25489 echo "$as_me: $ac_file is unchanged" >&6;}
25490     else
25491       ac_dir=`(dirname "$ac_file") 2>/dev/null ||
25492 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25493          X"$ac_file" : 'X\(//\)[^/]' \| \
25494          X"$ac_file" : 'X\(//\)$' \| \
25495          X"$ac_file" : 'X\(/\)' \| \
25496          .     : '\(.\)' 2>/dev/null ||
25497 echo X"$ac_file" |
25498     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25499           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25500           /^X\(\/\/\)$/{ s//\1/; q; }
25501           /^X\(\/\).*/{ s//\1/; q; }
25502           s/.*/./; q'`
25503       { if $as_mkdir_p; then
25504     mkdir -p "$ac_dir"
25505   else
25506     as_dir="$ac_dir"
25507     as_dirs=
25508     while test ! -d "$as_dir"; do
25509       as_dirs="$as_dir $as_dirs"
25510       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25511 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25512          X"$as_dir" : 'X\(//\)[^/]' \| \
25513          X"$as_dir" : 'X\(//\)$' \| \
25514          X"$as_dir" : 'X\(/\)' \| \
25515          .     : '\(.\)' 2>/dev/null ||
25516 echo X"$as_dir" |
25517     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25518           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25519           /^X\(\/\/\)$/{ s//\1/; q; }
25520           /^X\(\/\).*/{ s//\1/; q; }
25521           s/.*/./; q'`
25522     done
25523     test ! -n "$as_dirs" || mkdir $as_dirs
25524   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
25525 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
25526    { (exit 1); exit 1; }; }; }
25527
25528       rm -f $ac_file
25529       mv $tmp/config.h $ac_file
25530     fi
25531   else
25532     cat $tmp/config.h
25533     rm -f $tmp/config.h
25534   fi
25535 # Compute $ac_file's index in $config_headers.
25536 _am_stamp_count=1
25537 for _am_header in $config_headers :; do
25538   case $_am_header in
25539     $ac_file | $ac_file:* )
25540       break ;;
25541     * )
25542       _am_stamp_count=`expr $_am_stamp_count + 1` ;;
25543   esac
25544 done
25545 echo "timestamp for $ac_file" >`(dirname $ac_file) 2>/dev/null ||
25546 $as_expr X$ac_file : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25547          X$ac_file : 'X\(//\)[^/]' \| \
25548          X$ac_file : 'X\(//\)$' \| \
25549          X$ac_file : 'X\(/\)' \| \
25550          .     : '\(.\)' 2>/dev/null ||
25551 echo X$ac_file |
25552     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25553           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25554           /^X\(\/\/\)$/{ s//\1/; q; }
25555           /^X\(\/\).*/{ s//\1/; q; }
25556           s/.*/./; q'`/stamp-h$_am_stamp_count
25557 done
25558 _ACEOF
25559 cat >>$CONFIG_STATUS <<\_ACEOF
25560
25561 #
25562 # CONFIG_COMMANDS section.
25563 #
25564 for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue
25565   ac_dest=`echo "$ac_file" | sed 's,:.*,,'`
25566   ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`
25567   ac_dir=`(dirname "$ac_dest") 2>/dev/null ||
25568 $as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25569          X"$ac_dest" : 'X\(//\)[^/]' \| \
25570          X"$ac_dest" : 'X\(//\)$' \| \
25571          X"$ac_dest" : 'X\(/\)' \| \
25572          .     : '\(.\)' 2>/dev/null ||
25573 echo X"$ac_dest" |
25574     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25575           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25576           /^X\(\/\/\)$/{ s//\1/; q; }
25577           /^X\(\/\).*/{ s//\1/; q; }
25578           s/.*/./; q'`
25579   { if $as_mkdir_p; then
25580     mkdir -p "$ac_dir"
25581   else
25582     as_dir="$ac_dir"
25583     as_dirs=
25584     while test ! -d "$as_dir"; do
25585       as_dirs="$as_dir $as_dirs"
25586       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25587 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25588          X"$as_dir" : 'X\(//\)[^/]' \| \
25589          X"$as_dir" : 'X\(//\)$' \| \
25590          X"$as_dir" : 'X\(/\)' \| \
25591          .     : '\(.\)' 2>/dev/null ||
25592 echo X"$as_dir" |
25593     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25594           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25595           /^X\(\/\/\)$/{ s//\1/; q; }
25596           /^X\(\/\).*/{ s//\1/; q; }
25597           s/.*/./; q'`
25598     done
25599     test ! -n "$as_dirs" || mkdir $as_dirs
25600   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
25601 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
25602    { (exit 1); exit 1; }; }; }
25603
25604   ac_builddir=.
25605
25606 if test "$ac_dir" != .; then
25607   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
25608   # A "../" for each directory in $ac_dir_suffix.
25609   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
25610 else
25611   ac_dir_suffix= ac_top_builddir=
25612 fi
25613
25614 case $srcdir in
25615   .)  # No --srcdir option.  We are building in place.
25616     ac_srcdir=.
25617     if test -z "$ac_top_builddir"; then
25618        ac_top_srcdir=.
25619     else
25620        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
25621     fi ;;
25622   [\\/]* | ?:[\\/]* )  # Absolute path.
25623     ac_srcdir=$srcdir$ac_dir_suffix;
25624     ac_top_srcdir=$srcdir ;;
25625   *) # Relative path.
25626     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
25627     ac_top_srcdir=$ac_top_builddir$srcdir ;;
25628 esac
25629
25630 # Do not use `cd foo && pwd` to compute absolute paths, because
25631 # the directories may not exist.
25632 case `pwd` in
25633 .) ac_abs_builddir="$ac_dir";;
25634 *)
25635   case "$ac_dir" in
25636   .) ac_abs_builddir=`pwd`;;
25637   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
25638   *) ac_abs_builddir=`pwd`/"$ac_dir";;
25639   esac;;
25640 esac
25641 case $ac_abs_builddir in
25642 .) ac_abs_top_builddir=${ac_top_builddir}.;;
25643 *)
25644   case ${ac_top_builddir}. in
25645   .) ac_abs_top_builddir=$ac_abs_builddir;;
25646   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
25647   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
25648   esac;;
25649 esac
25650 case $ac_abs_builddir in
25651 .) ac_abs_srcdir=$ac_srcdir;;
25652 *)
25653   case $ac_srcdir in
25654   .) ac_abs_srcdir=$ac_abs_builddir;;
25655   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
25656   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
25657   esac;;
25658 esac
25659 case $ac_abs_builddir in
25660 .) ac_abs_top_srcdir=$ac_top_srcdir;;
25661 *)
25662   case $ac_top_srcdir in
25663   .) ac_abs_top_srcdir=$ac_abs_builddir;;
25664   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
25665   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
25666   esac;;
25667 esac
25668
25669
25670   { echo "$as_me:$LINENO: executing $ac_dest commands" >&5
25671 echo "$as_me: executing $ac_dest commands" >&6;}
25672   case $ac_dest in
25673     default-1 )
25674 # Only add multilib support code if we just rebuilt the top-level
25675 # Makefile.
25676 case " $CONFIG_FILES " in
25677  *" Makefile "*)
25678    ac_file=Makefile . ${multi_basedir}/config-ml.in
25679    ;;
25680 esac ;;
25681     depfiles ) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do
25682   # Strip MF so we end up with the name of the file.
25683   mf=`echo "$mf" | sed -e 's/:.*$//'`
25684   # Check whether this is an Automake generated Makefile or not.
25685   # We used to match only the files named `Makefile.in', but
25686   # some people rename them; so instead we look at the file content.
25687   # Grep'ing the first line is not enough: some people post-process
25688   # each Makefile.in and add a new line on top of each file to say so.
25689   # So let's grep whole file.
25690   if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then
25691     dirpart=`(dirname "$mf") 2>/dev/null ||
25692 $as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25693          X"$mf" : 'X\(//\)[^/]' \| \
25694          X"$mf" : 'X\(//\)$' \| \
25695          X"$mf" : 'X\(/\)' \| \
25696          .     : '\(.\)' 2>/dev/null ||
25697 echo X"$mf" |
25698     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25699           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25700           /^X\(\/\/\)$/{ s//\1/; q; }
25701           /^X\(\/\).*/{ s//\1/; q; }
25702           s/.*/./; q'`
25703   else
25704     continue
25705   fi
25706   # Extract the definition of DEPDIR, am__include, and am__quote
25707   # from the Makefile without running `make'.
25708   DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
25709   test -z "$DEPDIR" && continue
25710   am__include=`sed -n 's/^am__include = //p' < "$mf"`
25711   test -z "am__include" && continue
25712   am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
25713   # When using ansi2knr, U may be empty or an underscore; expand it
25714   U=`sed -n 's/^U = //p' < "$mf"`
25715   # Find all dependency output files, they are included files with
25716   # $(DEPDIR) in their names.  We invoke sed twice because it is the
25717   # simplest approach to changing $(DEPDIR) to its actual value in the
25718   # expansion.
25719   for file in `sed -n "
25720     s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
25721        sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
25722     # Make sure the directory exists.
25723     test -f "$dirpart/$file" && continue
25724     fdir=`(dirname "$file") 2>/dev/null ||
25725 $as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25726          X"$file" : 'X\(//\)[^/]' \| \
25727          X"$file" : 'X\(//\)$' \| \
25728          X"$file" : 'X\(/\)' \| \
25729          .     : '\(.\)' 2>/dev/null ||
25730 echo X"$file" |
25731     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25732           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25733           /^X\(\/\/\)$/{ s//\1/; q; }
25734           /^X\(\/\).*/{ s//\1/; q; }
25735           s/.*/./; q'`
25736     { if $as_mkdir_p; then
25737     mkdir -p $dirpart/$fdir
25738   else
25739     as_dir=$dirpart/$fdir
25740     as_dirs=
25741     while test ! -d "$as_dir"; do
25742       as_dirs="$as_dir $as_dirs"
25743       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25744 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25745          X"$as_dir" : 'X\(//\)[^/]' \| \
25746          X"$as_dir" : 'X\(//\)$' \| \
25747          X"$as_dir" : 'X\(/\)' \| \
25748          .     : '\(.\)' 2>/dev/null ||
25749 echo X"$as_dir" |
25750     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25751           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25752           /^X\(\/\/\)$/{ s//\1/; q; }
25753           /^X\(\/\).*/{ s//\1/; q; }
25754           s/.*/./; q'`
25755     done
25756     test ! -n "$as_dirs" || mkdir $as_dirs
25757   fi || { { echo "$as_me:$LINENO: error: cannot create directory $dirpart/$fdir" >&5
25758 echo "$as_me: error: cannot create directory $dirpart/$fdir" >&2;}
25759    { (exit 1); exit 1; }; }; }
25760
25761     # echo "creating $dirpart/$file"
25762     echo '# dummy' > "$dirpart/$file"
25763   done
25764 done
25765  ;;
25766     gstdint.h )
25767 if test "$GCC" = yes; then
25768   echo "/* generated for " `$CC --version | sed 1q` "*/" > tmp-stdint.h
25769 else
25770   echo "/* generated for $CC */" > tmp-stdint.h
25771 fi
25772
25773 sed 's/^ *//' >> tmp-stdint.h <<EOF
25774
25775   #ifndef GCC_GENERATED_STDINT_H
25776   #define GCC_GENERATED_STDINT_H 1
25777
25778   #include <sys/types.h>
25779 EOF
25780
25781 if test "$acx_cv_header_stdint" != stdint.h; then
25782   echo "#include <stddef.h>" >> tmp-stdint.h
25783 fi
25784 if test "$acx_cv_header_stdint" != stddef.h; then
25785   echo "#include <$acx_cv_header_stdint>" >> tmp-stdint.h
25786 fi
25787
25788 sed 's/^ *//' >> tmp-stdint.h <<EOF
25789   /* glibc uses these symbols as guards to prevent redefinitions.  */
25790   #ifdef __int8_t_defined
25791   #define _INT8_T
25792   #define _INT16_T
25793   #define _INT32_T
25794   #endif
25795   #ifdef __uint32_t_defined
25796   #define _UINT32_T
25797   #endif
25798
25799 EOF
25800
25801 # ----------------- done header, emit basic int types -------------
25802 if test "$acx_cv_header_stdint" = stddef.h; then
25803   sed 's/^ *//' >> tmp-stdint.h <<EOF
25804
25805     #ifndef _UINT8_T
25806     #define _UINT8_T
25807     typedef unsigned $acx_cv_type_int8_t uint8_t;
25808     #endif
25809
25810     #ifndef _UINT16_T
25811     #define _UINT16_T
25812     typedef unsigned $acx_cv_type_int16_t uint16_t;
25813     #endif
25814
25815     #ifndef _UINT32_T
25816     #define _UINT32_T
25817     typedef unsigned $acx_cv_type_int32_t uint32_t;
25818     #endif
25819
25820     #ifndef _INT8_T
25821     #define _INT8_T
25822     typedef $acx_cv_type_int8_t int8_t;
25823     #endif
25824
25825     #ifndef _INT16_T
25826     #define _INT16_T
25827     typedef $acx_cv_type_int16_t int16_t;
25828     #endif
25829
25830     #ifndef _INT32_T
25831     #define _INT32_T
25832     typedef $acx_cv_type_int32_t int32_t;
25833     #endif
25834 EOF
25835 elif test "$ac_cv_type_u_int32_t" = yes; then
25836   sed 's/^ *//' >> tmp-stdint.h <<EOF
25837
25838     /* int8_t int16_t int32_t defined by inet code, we do the u_intXX types */
25839     #ifndef _INT8_T
25840     #define _INT8_T
25841     #endif
25842     #ifndef _INT16_T
25843     #define _INT16_T
25844     #endif
25845     #ifndef _INT32_T
25846     #define _INT32_T
25847     #endif
25848
25849     #ifndef _UINT8_T
25850     #define _UINT8_T
25851     typedef u_int8_t uint8_t;
25852     #endif
25853
25854     #ifndef _UINT16_T
25855     #define _UINT16_T
25856     typedef u_int16_t uint16_t;
25857     #endif
25858
25859     #ifndef _UINT32_T
25860     #define _UINT32_T
25861     typedef u_int32_t uint32_t;
25862     #endif
25863 EOF
25864 else
25865   sed 's/^ *//' >> tmp-stdint.h <<EOF
25866
25867     /* Some systems have guard macros to prevent redefinitions, define them.  */
25868     #ifndef _INT8_T
25869     #define _INT8_T
25870     #endif
25871     #ifndef _INT16_T
25872     #define _INT16_T
25873     #endif
25874     #ifndef _INT32_T
25875     #define _INT32_T
25876     #endif
25877     #ifndef _UINT8_T
25878     #define _UINT8_T
25879     #endif
25880     #ifndef _UINT16_T
25881     #define _UINT16_T
25882     #endif
25883     #ifndef _UINT32_T
25884     #define _UINT32_T
25885     #endif
25886 EOF
25887 fi
25888
25889 # ------------- done basic int types, emit int64_t types ------------
25890 if test "$ac_cv_type_uint64_t" = yes; then
25891   sed 's/^ *//' >> tmp-stdint.h <<EOF
25892
25893     /* system headers have good uint64_t and int64_t */
25894     #ifndef _INT64_T
25895     #define _INT64_T
25896     #endif
25897     #ifndef _UINT64_T
25898     #define _UINT64_T
25899     #endif
25900 EOF
25901 elif test "$ac_cv_type_u_int64_t" = yes; then
25902   sed 's/^ *//' >> tmp-stdint.h <<EOF
25903
25904     /* system headers have an u_int64_t (and int64_t) */
25905     #ifndef _INT64_T
25906     #define _INT64_T
25907     #endif
25908     #ifndef _UINT64_T
25909     #define _UINT64_T
25910     typedef u_int64_t uint64_t;
25911     #endif
25912 EOF
25913 elif test -n "$acx_cv_type_int64_t"; then
25914   sed 's/^ *//' >> tmp-stdint.h <<EOF
25915
25916     /* architecture has a 64-bit type, $acx_cv_type_int64_t */
25917     #ifndef _INT64_T
25918     #define _INT64_T
25919     typedef $acx_cv_type_int64_t int64_t;
25920     #endif
25921     #ifndef _UINT64_T
25922     #define _UINT64_T
25923     typedef unsigned $acx_cv_type_int64_t uint64_t;
25924     #endif
25925 EOF
25926 else
25927   sed 's/^ *//' >> tmp-stdint.h <<EOF
25928
25929     /* some common heuristics for int64_t, using compiler-specific tests */
25930     #if defined __STDC_VERSION__ && (__STDC_VERSION__-0) >= 199901L
25931     #ifndef _INT64_T
25932     #define _INT64_T
25933     typedef long long int64_t;
25934     #endif
25935     #ifndef _UINT64_T
25936     #define _UINT64_T
25937     typedef unsigned long long uint64_t;
25938     #endif
25939
25940     #elif defined __GNUC__ && defined (__STDC__) && __STDC__-0
25941     /* NextStep 2.0 cc is really gcc 1.93 but it defines __GNUC__ = 2 and
25942        does not implement __extension__.  But that compiler doesn't define
25943        __GNUC_MINOR__.  */
25944     # if __GNUC__ < 2 || (__NeXT__ && !__GNUC_MINOR__)
25945     # define __extension__
25946     # endif
25947
25948     # ifndef _INT64_T
25949     # define _INT64_T
25950     __extension__ typedef long long int64_t;
25951     # endif
25952     # ifndef _UINT64_T
25953     # define _UINT64_T
25954     __extension__ typedef unsigned long long uint64_t;
25955     # endif
25956
25957     #elif !defined __STRICT_ANSI__
25958     # if defined _MSC_VER || defined __WATCOMC__ || defined __BORLANDC__
25959
25960     #  ifndef _INT64_T
25961     #  define _INT64_T
25962     typedef __int64 int64_t;
25963     #  endif
25964     #  ifndef _UINT64_T
25965     #  define _UINT64_T
25966     typedef unsigned __int64 uint64_t;
25967     #  endif
25968     # endif /* compiler */
25969
25970     #endif /* ANSI version */
25971 EOF
25972 fi
25973
25974 # ------------- done int64_t types, emit intptr types ------------
25975 if test "$ac_cv_type_uintptr_t" != yes; then
25976   sed 's/^ *//' >> tmp-stdint.h <<EOF
25977
25978     /* Define intptr_t based on sizeof(void*) = $ac_cv_sizeof_void_p */
25979     typedef u$acx_cv_type_intptr_t uintptr_t;
25980     typedef $acx_cv_type_intptr_t  intptr_t;
25981 EOF
25982 fi
25983
25984 # ------------- done intptr types, emit int_least types ------------
25985 if test "$ac_cv_type_int_least32_t" != yes; then
25986   sed 's/^ *//' >> tmp-stdint.h <<EOF
25987
25988     /* Define int_least types */
25989     typedef int8_t     int_least8_t;
25990     typedef int16_t    int_least16_t;
25991     typedef int32_t    int_least32_t;
25992     #ifdef _INT64_T
25993     typedef int64_t    int_least64_t;
25994     #endif
25995
25996     typedef uint8_t    uint_least8_t;
25997     typedef uint16_t   uint_least16_t;
25998     typedef uint32_t   uint_least32_t;
25999     #ifdef _UINT64_T
26000     typedef uint64_t   uint_least64_t;
26001     #endif
26002 EOF
26003 fi
26004
26005 # ------------- done intptr types, emit int_fast types ------------
26006 if test "$ac_cv_type_int_fast32_t" != yes; then
26007       sed 's/^ *//' >> tmp-stdint.h <<EOF
26008
26009     /* Define int_fast types.  short is often slow */
26010     typedef int8_t       int_fast8_t;
26011     typedef int          int_fast16_t;
26012     typedef int32_t      int_fast32_t;
26013     #ifdef _INT64_T
26014     typedef int64_t      int_fast64_t;
26015     #endif
26016
26017     typedef uint8_t      uint_fast8_t;
26018     typedef unsigned int uint_fast16_t;
26019     typedef uint32_t     uint_fast32_t;
26020     #ifdef _UINT64_T
26021     typedef uint64_t     uint_fast64_t;
26022     #endif
26023 EOF
26024 fi
26025
26026 if test "$ac_cv_type_uintmax_t" != yes; then
26027   sed 's/^ *//' >> tmp-stdint.h <<EOF
26028
26029     /* Define intmax based on what we found */
26030     #ifdef _INT64_T
26031     typedef int64_t       intmax_t;
26032     #else
26033     typedef long          intmax_t;
26034     #endif
26035     #ifdef _UINT64_T
26036     typedef uint64_t      uintmax_t;
26037     #else
26038     typedef unsigned long uintmax_t;
26039     #endif
26040 EOF
26041 fi
26042
26043 sed 's/^ *//' >> tmp-stdint.h <<EOF
26044
26045   #endif /* GCC_GENERATED_STDINT_H */
26046 EOF
26047
26048 if test -r gstdint.h && cmp -s tmp-stdint.h gstdint.h; then
26049   rm -f tmp-stdint.h
26050 else
26051   mv -f tmp-stdint.h gstdint.h
26052 fi
26053
26054  ;;
26055   esac
26056 done
26057 _ACEOF
26058
26059 cat >>$CONFIG_STATUS <<\_ACEOF
26060
26061 { (exit 0); exit 0; }
26062 _ACEOF
26063 chmod +x $CONFIG_STATUS
26064 ac_clean_files=$ac_clean_files_save
26065
26066
26067 # configure is writing to config.log, and then calls config.status.
26068 # config.status does its own redirection, appending to config.log.
26069 # Unfortunately, on DOS this fails, as config.log is still kept open
26070 # by configure, so config.status won't be able to write to it; its
26071 # output is simply discarded.  So we exec the FD to /dev/null,
26072 # effectively closing config.log, so it can be properly (re)opened and
26073 # appended to by config.status.  When coming back to configure, we
26074 # need to make the FD available again.
26075 if test "$no_create" != yes; then
26076   ac_cs_success=:
26077   ac_config_status_args=
26078   test "$silent" = yes &&
26079     ac_config_status_args="$ac_config_status_args --quiet"
26080   exec 5>/dev/null
26081   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
26082   exec 5>>config.log
26083   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
26084   # would make configure fail if this is the last instruction.
26085   $ac_cs_success || { (exit 1); exit 1; }
26086 fi
26087