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 # Check whether --enable-largefile or --disable-largefile was given.
4900 if test "${enable_largefile+set}" = set; then
4901   enableval="$enable_largefile"
4902
4903 fi;
4904 if test "$enable_largefile" != no; then
4905
4906   echo "$as_me:$LINENO: checking for special C compiler options needed for large files" >&5
4907 echo $ECHO_N "checking for special C compiler options needed for large files... $ECHO_C" >&6
4908 if test "${ac_cv_sys_largefile_CC+set}" = set; then
4909   echo $ECHO_N "(cached) $ECHO_C" >&6
4910 else
4911   ac_cv_sys_largefile_CC=no
4912      if test "$GCC" != yes; then
4913        ac_save_CC=$CC
4914        while :; do
4915          # IRIX 6.2 and later do not support large files by default,
4916          # so use the C compiler's -n32 option if that helps.
4917          cat >conftest.$ac_ext <<_ACEOF
4918 /* confdefs.h.  */
4919 _ACEOF
4920 cat confdefs.h >>conftest.$ac_ext
4921 cat >>conftest.$ac_ext <<_ACEOF
4922 /* end confdefs.h.  */
4923 #include <sys/types.h>
4924  /* Check that off_t can represent 2**63 - 1 correctly.
4925     We can't simply define LARGE_OFF_T to be 9223372036854775807,
4926     since some C++ compilers masquerading as C compilers
4927     incorrectly reject 9223372036854775807.  */
4928 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4929   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4930                        && LARGE_OFF_T % 2147483647 == 1)
4931                       ? 1 : -1];
4932 int
4933 main ()
4934 {
4935
4936   ;
4937   return 0;
4938 }
4939 _ACEOF
4940          rm -f conftest.$ac_objext
4941 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4942   (eval $ac_compile) 2>conftest.er1
4943   ac_status=$?
4944   grep -v '^ *+' conftest.er1 >conftest.err
4945   rm -f conftest.er1
4946   cat conftest.err >&5
4947   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4948   (exit $ac_status); } &&
4949          { ac_try='test -z "$ac_c_werror_flag"
4950                          || test ! -s conftest.err'
4951   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4952   (eval $ac_try) 2>&5
4953   ac_status=$?
4954   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4955   (exit $ac_status); }; } &&
4956          { ac_try='test -s conftest.$ac_objext'
4957   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4958   (eval $ac_try) 2>&5
4959   ac_status=$?
4960   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4961   (exit $ac_status); }; }; then
4962   break
4963 else
4964   echo "$as_me: failed program was:" >&5
4965 sed 's/^/| /' conftest.$ac_ext >&5
4966
4967 fi
4968 rm -f conftest.err conftest.$ac_objext
4969          CC="$CC -n32"
4970          rm -f conftest.$ac_objext
4971 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4972   (eval $ac_compile) 2>conftest.er1
4973   ac_status=$?
4974   grep -v '^ *+' conftest.er1 >conftest.err
4975   rm -f conftest.er1
4976   cat conftest.err >&5
4977   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4978   (exit $ac_status); } &&
4979          { ac_try='test -z "$ac_c_werror_flag"
4980                          || test ! -s conftest.err'
4981   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4982   (eval $ac_try) 2>&5
4983   ac_status=$?
4984   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4985   (exit $ac_status); }; } &&
4986          { ac_try='test -s conftest.$ac_objext'
4987   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4988   (eval $ac_try) 2>&5
4989   ac_status=$?
4990   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4991   (exit $ac_status); }; }; then
4992   ac_cv_sys_largefile_CC=' -n32'; break
4993 else
4994   echo "$as_me: failed program was:" >&5
4995 sed 's/^/| /' conftest.$ac_ext >&5
4996
4997 fi
4998 rm -f conftest.err conftest.$ac_objext
4999          break
5000        done
5001        CC=$ac_save_CC
5002        rm -f conftest.$ac_ext
5003     fi
5004 fi
5005 echo "$as_me:$LINENO: result: $ac_cv_sys_largefile_CC" >&5
5006 echo "${ECHO_T}$ac_cv_sys_largefile_CC" >&6
5007   if test "$ac_cv_sys_largefile_CC" != no; then
5008     CC=$CC$ac_cv_sys_largefile_CC
5009   fi
5010
5011   echo "$as_me:$LINENO: checking for _FILE_OFFSET_BITS value needed for large files" >&5
5012 echo $ECHO_N "checking for _FILE_OFFSET_BITS value needed for large files... $ECHO_C" >&6
5013 if test "${ac_cv_sys_file_offset_bits+set}" = set; then
5014   echo $ECHO_N "(cached) $ECHO_C" >&6
5015 else
5016   while :; do
5017   ac_cv_sys_file_offset_bits=no
5018   cat >conftest.$ac_ext <<_ACEOF
5019 /* confdefs.h.  */
5020 _ACEOF
5021 cat confdefs.h >>conftest.$ac_ext
5022 cat >>conftest.$ac_ext <<_ACEOF
5023 /* end confdefs.h.  */
5024 #include <sys/types.h>
5025  /* Check that off_t can represent 2**63 - 1 correctly.
5026     We can't simply define LARGE_OFF_T to be 9223372036854775807,
5027     since some C++ compilers masquerading as C compilers
5028     incorrectly reject 9223372036854775807.  */
5029 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5030   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5031                        && LARGE_OFF_T % 2147483647 == 1)
5032                       ? 1 : -1];
5033 int
5034 main ()
5035 {
5036
5037   ;
5038   return 0;
5039 }
5040 _ACEOF
5041 rm -f conftest.$ac_objext
5042 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5043   (eval $ac_compile) 2>conftest.er1
5044   ac_status=$?
5045   grep -v '^ *+' conftest.er1 >conftest.err
5046   rm -f conftest.er1
5047   cat conftest.err >&5
5048   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5049   (exit $ac_status); } &&
5050          { ac_try='test -z "$ac_c_werror_flag"
5051                          || test ! -s conftest.err'
5052   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5053   (eval $ac_try) 2>&5
5054   ac_status=$?
5055   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5056   (exit $ac_status); }; } &&
5057          { ac_try='test -s conftest.$ac_objext'
5058   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5059   (eval $ac_try) 2>&5
5060   ac_status=$?
5061   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5062   (exit $ac_status); }; }; then
5063   break
5064 else
5065   echo "$as_me: failed program was:" >&5
5066 sed 's/^/| /' conftest.$ac_ext >&5
5067
5068 fi
5069 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5070   cat >conftest.$ac_ext <<_ACEOF
5071 /* confdefs.h.  */
5072 _ACEOF
5073 cat confdefs.h >>conftest.$ac_ext
5074 cat >>conftest.$ac_ext <<_ACEOF
5075 /* end confdefs.h.  */
5076 #define _FILE_OFFSET_BITS 64
5077 #include <sys/types.h>
5078  /* Check that off_t can represent 2**63 - 1 correctly.
5079     We can't simply define LARGE_OFF_T to be 9223372036854775807,
5080     since some C++ compilers masquerading as C compilers
5081     incorrectly reject 9223372036854775807.  */
5082 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5083   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5084                        && LARGE_OFF_T % 2147483647 == 1)
5085                       ? 1 : -1];
5086 int
5087 main ()
5088 {
5089
5090   ;
5091   return 0;
5092 }
5093 _ACEOF
5094 rm -f conftest.$ac_objext
5095 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5096   (eval $ac_compile) 2>conftest.er1
5097   ac_status=$?
5098   grep -v '^ *+' conftest.er1 >conftest.err
5099   rm -f conftest.er1
5100   cat conftest.err >&5
5101   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5102   (exit $ac_status); } &&
5103          { ac_try='test -z "$ac_c_werror_flag"
5104                          || test ! -s conftest.err'
5105   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5106   (eval $ac_try) 2>&5
5107   ac_status=$?
5108   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5109   (exit $ac_status); }; } &&
5110          { ac_try='test -s conftest.$ac_objext'
5111   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5112   (eval $ac_try) 2>&5
5113   ac_status=$?
5114   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5115   (exit $ac_status); }; }; then
5116   ac_cv_sys_file_offset_bits=64; break
5117 else
5118   echo "$as_me: failed program was:" >&5
5119 sed 's/^/| /' conftest.$ac_ext >&5
5120
5121 fi
5122 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5123   break
5124 done
5125 fi
5126 echo "$as_me:$LINENO: result: $ac_cv_sys_file_offset_bits" >&5
5127 echo "${ECHO_T}$ac_cv_sys_file_offset_bits" >&6
5128 if test "$ac_cv_sys_file_offset_bits" != no; then
5129
5130 cat >>confdefs.h <<_ACEOF
5131 #define _FILE_OFFSET_BITS $ac_cv_sys_file_offset_bits
5132 _ACEOF
5133
5134 fi
5135 rm -f conftest*
5136   echo "$as_me:$LINENO: checking for _LARGE_FILES value needed for large files" >&5
5137 echo $ECHO_N "checking for _LARGE_FILES value needed for large files... $ECHO_C" >&6
5138 if test "${ac_cv_sys_large_files+set}" = set; then
5139   echo $ECHO_N "(cached) $ECHO_C" >&6
5140 else
5141   while :; do
5142   ac_cv_sys_large_files=no
5143   cat >conftest.$ac_ext <<_ACEOF
5144 /* confdefs.h.  */
5145 _ACEOF
5146 cat confdefs.h >>conftest.$ac_ext
5147 cat >>conftest.$ac_ext <<_ACEOF
5148 /* end confdefs.h.  */
5149 #include <sys/types.h>
5150  /* Check that off_t can represent 2**63 - 1 correctly.
5151     We can't simply define LARGE_OFF_T to be 9223372036854775807,
5152     since some C++ compilers masquerading as C compilers
5153     incorrectly reject 9223372036854775807.  */
5154 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5155   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5156                        && LARGE_OFF_T % 2147483647 == 1)
5157                       ? 1 : -1];
5158 int
5159 main ()
5160 {
5161
5162   ;
5163   return 0;
5164 }
5165 _ACEOF
5166 rm -f conftest.$ac_objext
5167 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5168   (eval $ac_compile) 2>conftest.er1
5169   ac_status=$?
5170   grep -v '^ *+' conftest.er1 >conftest.err
5171   rm -f conftest.er1
5172   cat conftest.err >&5
5173   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5174   (exit $ac_status); } &&
5175          { ac_try='test -z "$ac_c_werror_flag"
5176                          || test ! -s conftest.err'
5177   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5178   (eval $ac_try) 2>&5
5179   ac_status=$?
5180   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5181   (exit $ac_status); }; } &&
5182          { ac_try='test -s conftest.$ac_objext'
5183   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5184   (eval $ac_try) 2>&5
5185   ac_status=$?
5186   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5187   (exit $ac_status); }; }; then
5188   break
5189 else
5190   echo "$as_me: failed program was:" >&5
5191 sed 's/^/| /' conftest.$ac_ext >&5
5192
5193 fi
5194 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5195   cat >conftest.$ac_ext <<_ACEOF
5196 /* confdefs.h.  */
5197 _ACEOF
5198 cat confdefs.h >>conftest.$ac_ext
5199 cat >>conftest.$ac_ext <<_ACEOF
5200 /* end confdefs.h.  */
5201 #define _LARGE_FILES 1
5202 #include <sys/types.h>
5203  /* Check that off_t can represent 2**63 - 1 correctly.
5204     We can't simply define LARGE_OFF_T to be 9223372036854775807,
5205     since some C++ compilers masquerading as C compilers
5206     incorrectly reject 9223372036854775807.  */
5207 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5208   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5209                        && LARGE_OFF_T % 2147483647 == 1)
5210                       ? 1 : -1];
5211 int
5212 main ()
5213 {
5214
5215   ;
5216   return 0;
5217 }
5218 _ACEOF
5219 rm -f conftest.$ac_objext
5220 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5221   (eval $ac_compile) 2>conftest.er1
5222   ac_status=$?
5223   grep -v '^ *+' conftest.er1 >conftest.err
5224   rm -f conftest.er1
5225   cat conftest.err >&5
5226   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5227   (exit $ac_status); } &&
5228          { ac_try='test -z "$ac_c_werror_flag"
5229                          || test ! -s conftest.err'
5230   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5231   (eval $ac_try) 2>&5
5232   ac_status=$?
5233   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5234   (exit $ac_status); }; } &&
5235          { ac_try='test -s conftest.$ac_objext'
5236   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5237   (eval $ac_try) 2>&5
5238   ac_status=$?
5239   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5240   (exit $ac_status); }; }; then
5241   ac_cv_sys_large_files=1; break
5242 else
5243   echo "$as_me: failed program was:" >&5
5244 sed 's/^/| /' conftest.$ac_ext >&5
5245
5246 fi
5247 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5248   break
5249 done
5250 fi
5251 echo "$as_me:$LINENO: result: $ac_cv_sys_large_files" >&5
5252 echo "${ECHO_T}$ac_cv_sys_large_files" >&6
5253 if test "$ac_cv_sys_large_files" != no; then
5254
5255 cat >>confdefs.h <<_ACEOF
5256 #define _LARGE_FILES $ac_cv_sys_large_files
5257 _ACEOF
5258
5259 fi
5260 rm -f conftest*
5261 fi
5262
5263 ac_ext=c
5264 ac_cpp='$CPP $CPPFLAGS'
5265 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5266 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5267 ac_compiler_gnu=$ac_cv_c_compiler_gnu
5268 echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
5269 echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
5270 # On Suns, sometimes $CPP names a directory.
5271 if test -n "$CPP" && test -d "$CPP"; then
5272   CPP=
5273 fi
5274 if test -z "$CPP"; then
5275   if test "${ac_cv_prog_CPP+set}" = set; then
5276   echo $ECHO_N "(cached) $ECHO_C" >&6
5277 else
5278       # Double quotes because CPP needs to be expanded
5279     for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
5280     do
5281       ac_preproc_ok=false
5282 for ac_c_preproc_warn_flag in '' yes
5283 do
5284   # Use a header file that comes with gcc, so configuring glibc
5285   # with a fresh cross-compiler works.
5286   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5287   # <limits.h> exists even on freestanding compilers.
5288   # On the NeXT, cc -E runs the code through the compiler's parser,
5289   # not just through cpp. "Syntax error" is here to catch this case.
5290   cat >conftest.$ac_ext <<_ACEOF
5291 /* confdefs.h.  */
5292 _ACEOF
5293 cat confdefs.h >>conftest.$ac_ext
5294 cat >>conftest.$ac_ext <<_ACEOF
5295 /* end confdefs.h.  */
5296 #ifdef __STDC__
5297 # include <limits.h>
5298 #else
5299 # include <assert.h>
5300 #endif
5301                      Syntax error
5302 _ACEOF
5303 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5304   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5305   ac_status=$?
5306   grep -v '^ *+' conftest.er1 >conftest.err
5307   rm -f conftest.er1
5308   cat conftest.err >&5
5309   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5310   (exit $ac_status); } >/dev/null; then
5311   if test -s conftest.err; then
5312     ac_cpp_err=$ac_c_preproc_warn_flag
5313     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5314   else
5315     ac_cpp_err=
5316   fi
5317 else
5318   ac_cpp_err=yes
5319 fi
5320 if test -z "$ac_cpp_err"; then
5321   :
5322 else
5323   echo "$as_me: failed program was:" >&5
5324 sed 's/^/| /' conftest.$ac_ext >&5
5325
5326   # Broken: fails on valid input.
5327 continue
5328 fi
5329 rm -f conftest.err conftest.$ac_ext
5330
5331   # OK, works on sane cases.  Now check whether non-existent headers
5332   # can be detected and how.
5333   cat >conftest.$ac_ext <<_ACEOF
5334 /* confdefs.h.  */
5335 _ACEOF
5336 cat confdefs.h >>conftest.$ac_ext
5337 cat >>conftest.$ac_ext <<_ACEOF
5338 /* end confdefs.h.  */
5339 #include <ac_nonexistent.h>
5340 _ACEOF
5341 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5342   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5343   ac_status=$?
5344   grep -v '^ *+' conftest.er1 >conftest.err
5345   rm -f conftest.er1
5346   cat conftest.err >&5
5347   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5348   (exit $ac_status); } >/dev/null; then
5349   if test -s conftest.err; then
5350     ac_cpp_err=$ac_c_preproc_warn_flag
5351     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5352   else
5353     ac_cpp_err=
5354   fi
5355 else
5356   ac_cpp_err=yes
5357 fi
5358 if test -z "$ac_cpp_err"; then
5359   # Broken: success on invalid input.
5360 continue
5361 else
5362   echo "$as_me: failed program was:" >&5
5363 sed 's/^/| /' conftest.$ac_ext >&5
5364
5365   # Passes both tests.
5366 ac_preproc_ok=:
5367 break
5368 fi
5369 rm -f conftest.err conftest.$ac_ext
5370
5371 done
5372 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5373 rm -f conftest.err conftest.$ac_ext
5374 if $ac_preproc_ok; then
5375   break
5376 fi
5377
5378     done
5379     ac_cv_prog_CPP=$CPP
5380
5381 fi
5382   CPP=$ac_cv_prog_CPP
5383 else
5384   ac_cv_prog_CPP=$CPP
5385 fi
5386 echo "$as_me:$LINENO: result: $CPP" >&5
5387 echo "${ECHO_T}$CPP" >&6
5388 ac_preproc_ok=false
5389 for ac_c_preproc_warn_flag in '' yes
5390 do
5391   # Use a header file that comes with gcc, so configuring glibc
5392   # with a fresh cross-compiler works.
5393   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5394   # <limits.h> exists even on freestanding compilers.
5395   # On the NeXT, cc -E runs the code through the compiler's parser,
5396   # not just through cpp. "Syntax error" is here to catch this case.
5397   cat >conftest.$ac_ext <<_ACEOF
5398 /* confdefs.h.  */
5399 _ACEOF
5400 cat confdefs.h >>conftest.$ac_ext
5401 cat >>conftest.$ac_ext <<_ACEOF
5402 /* end confdefs.h.  */
5403 #ifdef __STDC__
5404 # include <limits.h>
5405 #else
5406 # include <assert.h>
5407 #endif
5408                      Syntax error
5409 _ACEOF
5410 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5411   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5412   ac_status=$?
5413   grep -v '^ *+' conftest.er1 >conftest.err
5414   rm -f conftest.er1
5415   cat conftest.err >&5
5416   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5417   (exit $ac_status); } >/dev/null; then
5418   if test -s conftest.err; then
5419     ac_cpp_err=$ac_c_preproc_warn_flag
5420     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5421   else
5422     ac_cpp_err=
5423   fi
5424 else
5425   ac_cpp_err=yes
5426 fi
5427 if test -z "$ac_cpp_err"; then
5428   :
5429 else
5430   echo "$as_me: failed program was:" >&5
5431 sed 's/^/| /' conftest.$ac_ext >&5
5432
5433   # Broken: fails on valid input.
5434 continue
5435 fi
5436 rm -f conftest.err conftest.$ac_ext
5437
5438   # OK, works on sane cases.  Now check whether non-existent headers
5439   # can be detected and how.
5440   cat >conftest.$ac_ext <<_ACEOF
5441 /* confdefs.h.  */
5442 _ACEOF
5443 cat confdefs.h >>conftest.$ac_ext
5444 cat >>conftest.$ac_ext <<_ACEOF
5445 /* end confdefs.h.  */
5446 #include <ac_nonexistent.h>
5447 _ACEOF
5448 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5449   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5450   ac_status=$?
5451   grep -v '^ *+' conftest.er1 >conftest.err
5452   rm -f conftest.er1
5453   cat conftest.err >&5
5454   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5455   (exit $ac_status); } >/dev/null; then
5456   if test -s conftest.err; then
5457     ac_cpp_err=$ac_c_preproc_warn_flag
5458     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5459   else
5460     ac_cpp_err=
5461   fi
5462 else
5463   ac_cpp_err=yes
5464 fi
5465 if test -z "$ac_cpp_err"; then
5466   # Broken: success on invalid input.
5467 continue
5468 else
5469   echo "$as_me: failed program was:" >&5
5470 sed 's/^/| /' conftest.$ac_ext >&5
5471
5472   # Passes both tests.
5473 ac_preproc_ok=:
5474 break
5475 fi
5476 rm -f conftest.err conftest.$ac_ext
5477
5478 done
5479 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5480 rm -f conftest.err conftest.$ac_ext
5481 if $ac_preproc_ok; then
5482   :
5483 else
5484   { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
5485 See \`config.log' for more details." >&5
5486 echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
5487 See \`config.log' for more details." >&2;}
5488    { (exit 1); exit 1; }; }
5489 fi
5490
5491 ac_ext=c
5492 ac_cpp='$CPP $CPPFLAGS'
5493 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5494 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5495 ac_compiler_gnu=$ac_cv_c_compiler_gnu
5496
5497
5498 echo "$as_me:$LINENO: checking for egrep" >&5
5499 echo $ECHO_N "checking for egrep... $ECHO_C" >&6
5500 if test "${ac_cv_prog_egrep+set}" = set; then
5501   echo $ECHO_N "(cached) $ECHO_C" >&6
5502 else
5503   if echo a | (grep -E '(a|b)') >/dev/null 2>&1
5504     then ac_cv_prog_egrep='grep -E'
5505     else ac_cv_prog_egrep='egrep'
5506     fi
5507 fi
5508 echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
5509 echo "${ECHO_T}$ac_cv_prog_egrep" >&6
5510  EGREP=$ac_cv_prog_egrep
5511
5512
5513 echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5514 echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5515 if test "${ac_cv_header_stdc+set}" = set; then
5516   echo $ECHO_N "(cached) $ECHO_C" >&6
5517 else
5518   cat >conftest.$ac_ext <<_ACEOF
5519 /* confdefs.h.  */
5520 _ACEOF
5521 cat confdefs.h >>conftest.$ac_ext
5522 cat >>conftest.$ac_ext <<_ACEOF
5523 /* end confdefs.h.  */
5524 #include <stdlib.h>
5525 #include <stdarg.h>
5526 #include <string.h>
5527 #include <float.h>
5528
5529 int
5530 main ()
5531 {
5532
5533   ;
5534   return 0;
5535 }
5536 _ACEOF
5537 rm -f conftest.$ac_objext
5538 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5539   (eval $ac_compile) 2>conftest.er1
5540   ac_status=$?
5541   grep -v '^ *+' conftest.er1 >conftest.err
5542   rm -f conftest.er1
5543   cat conftest.err >&5
5544   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5545   (exit $ac_status); } &&
5546          { ac_try='test -z "$ac_c_werror_flag"
5547                          || test ! -s conftest.err'
5548   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5549   (eval $ac_try) 2>&5
5550   ac_status=$?
5551   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5552   (exit $ac_status); }; } &&
5553          { ac_try='test -s conftest.$ac_objext'
5554   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5555   (eval $ac_try) 2>&5
5556   ac_status=$?
5557   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5558   (exit $ac_status); }; }; then
5559   ac_cv_header_stdc=yes
5560 else
5561   echo "$as_me: failed program was:" >&5
5562 sed 's/^/| /' conftest.$ac_ext >&5
5563
5564 ac_cv_header_stdc=no
5565 fi
5566 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5567
5568 if test $ac_cv_header_stdc = yes; then
5569   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5570   cat >conftest.$ac_ext <<_ACEOF
5571 /* confdefs.h.  */
5572 _ACEOF
5573 cat confdefs.h >>conftest.$ac_ext
5574 cat >>conftest.$ac_ext <<_ACEOF
5575 /* end confdefs.h.  */
5576 #include <string.h>
5577
5578 _ACEOF
5579 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5580   $EGREP "memchr" >/dev/null 2>&1; then
5581   :
5582 else
5583   ac_cv_header_stdc=no
5584 fi
5585 rm -f conftest*
5586
5587 fi
5588
5589 if test $ac_cv_header_stdc = yes; then
5590   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5591   cat >conftest.$ac_ext <<_ACEOF
5592 /* confdefs.h.  */
5593 _ACEOF
5594 cat confdefs.h >>conftest.$ac_ext
5595 cat >>conftest.$ac_ext <<_ACEOF
5596 /* end confdefs.h.  */
5597 #include <stdlib.h>
5598
5599 _ACEOF
5600 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5601   $EGREP "free" >/dev/null 2>&1; then
5602   :
5603 else
5604   ac_cv_header_stdc=no
5605 fi
5606 rm -f conftest*
5607
5608 fi
5609
5610 if test $ac_cv_header_stdc = yes; then
5611   # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5612   if test "$cross_compiling" = yes; then
5613   :
5614 else
5615   cat >conftest.$ac_ext <<_ACEOF
5616 /* confdefs.h.  */
5617 _ACEOF
5618 cat confdefs.h >>conftest.$ac_ext
5619 cat >>conftest.$ac_ext <<_ACEOF
5620 /* end confdefs.h.  */
5621 #include <ctype.h>
5622 #if ((' ' & 0x0FF) == 0x020)
5623 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5624 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5625 #else
5626 # define ISLOWER(c) \
5627                    (('a' <= (c) && (c) <= 'i') \
5628                      || ('j' <= (c) && (c) <= 'r') \
5629                      || ('s' <= (c) && (c) <= 'z'))
5630 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5631 #endif
5632
5633 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5634 int
5635 main ()
5636 {
5637   int i;
5638   for (i = 0; i < 256; i++)
5639     if (XOR (islower (i), ISLOWER (i))
5640         || toupper (i) != TOUPPER (i))
5641       exit(2);
5642   exit (0);
5643 }
5644 _ACEOF
5645 rm -f conftest$ac_exeext
5646 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5647   (eval $ac_link) 2>&5
5648   ac_status=$?
5649   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5650   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5651   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5652   (eval $ac_try) 2>&5
5653   ac_status=$?
5654   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5655   (exit $ac_status); }; }; then
5656   :
5657 else
5658   echo "$as_me: program exited with status $ac_status" >&5
5659 echo "$as_me: failed program was:" >&5
5660 sed 's/^/| /' conftest.$ac_ext >&5
5661
5662 ( exit $ac_status )
5663 ac_cv_header_stdc=no
5664 fi
5665 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5666 fi
5667 fi
5668 fi
5669 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5670 echo "${ECHO_T}$ac_cv_header_stdc" >&6
5671 if test $ac_cv_header_stdc = yes; then
5672
5673 cat >>confdefs.h <<\_ACEOF
5674 #define STDC_HEADERS 1
5675 _ACEOF
5676
5677 fi
5678
5679 # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5680
5681
5682
5683
5684
5685
5686
5687
5688
5689 for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5690                   inttypes.h stdint.h unistd.h
5691 do
5692 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5693 echo "$as_me:$LINENO: checking for $ac_header" >&5
5694 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5695 if eval "test \"\${$as_ac_Header+set}\" = set"; then
5696   echo $ECHO_N "(cached) $ECHO_C" >&6
5697 else
5698   cat >conftest.$ac_ext <<_ACEOF
5699 /* confdefs.h.  */
5700 _ACEOF
5701 cat confdefs.h >>conftest.$ac_ext
5702 cat >>conftest.$ac_ext <<_ACEOF
5703 /* end confdefs.h.  */
5704 $ac_includes_default
5705
5706 #include <$ac_header>
5707 _ACEOF
5708 rm -f conftest.$ac_objext
5709 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5710   (eval $ac_compile) 2>conftest.er1
5711   ac_status=$?
5712   grep -v '^ *+' conftest.er1 >conftest.err
5713   rm -f conftest.er1
5714   cat conftest.err >&5
5715   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5716   (exit $ac_status); } &&
5717          { ac_try='test -z "$ac_c_werror_flag"
5718                          || test ! -s conftest.err'
5719   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5720   (eval $ac_try) 2>&5
5721   ac_status=$?
5722   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5723   (exit $ac_status); }; } &&
5724          { ac_try='test -s conftest.$ac_objext'
5725   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5726   (eval $ac_try) 2>&5
5727   ac_status=$?
5728   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5729   (exit $ac_status); }; }; then
5730   eval "$as_ac_Header=yes"
5731 else
5732   echo "$as_me: failed program was:" >&5
5733 sed 's/^/| /' conftest.$ac_ext >&5
5734
5735 eval "$as_ac_Header=no"
5736 fi
5737 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5738 fi
5739 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5740 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5741 if test `eval echo '${'$as_ac_Header'}'` = yes; then
5742   cat >>confdefs.h <<_ACEOF
5743 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5744 _ACEOF
5745
5746 fi
5747
5748 done
5749
5750
5751 echo "$as_me:$LINENO: checking for off_t" >&5
5752 echo $ECHO_N "checking for off_t... $ECHO_C" >&6
5753 if test "${ac_cv_type_off_t+set}" = set; then
5754   echo $ECHO_N "(cached) $ECHO_C" >&6
5755 else
5756   cat >conftest.$ac_ext <<_ACEOF
5757 /* confdefs.h.  */
5758 _ACEOF
5759 cat confdefs.h >>conftest.$ac_ext
5760 cat >>conftest.$ac_ext <<_ACEOF
5761 /* end confdefs.h.  */
5762 $ac_includes_default
5763 int
5764 main ()
5765 {
5766 if ((off_t *) 0)
5767   return 0;
5768 if (sizeof (off_t))
5769   return 0;
5770   ;
5771   return 0;
5772 }
5773 _ACEOF
5774 rm -f conftest.$ac_objext
5775 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5776   (eval $ac_compile) 2>conftest.er1
5777   ac_status=$?
5778   grep -v '^ *+' conftest.er1 >conftest.err
5779   rm -f conftest.er1
5780   cat conftest.err >&5
5781   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5782   (exit $ac_status); } &&
5783          { ac_try='test -z "$ac_c_werror_flag"
5784                          || test ! -s conftest.err'
5785   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5786   (eval $ac_try) 2>&5
5787   ac_status=$?
5788   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5789   (exit $ac_status); }; } &&
5790          { ac_try='test -s conftest.$ac_objext'
5791   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5792   (eval $ac_try) 2>&5
5793   ac_status=$?
5794   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5795   (exit $ac_status); }; }; then
5796   ac_cv_type_off_t=yes
5797 else
5798   echo "$as_me: failed program was:" >&5
5799 sed 's/^/| /' conftest.$ac_ext >&5
5800
5801 ac_cv_type_off_t=no
5802 fi
5803 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5804 fi
5805 echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5
5806 echo "${ECHO_T}$ac_cv_type_off_t" >&6
5807 if test $ac_cv_type_off_t = yes; then
5808   :
5809 else
5810
5811 cat >>confdefs.h <<_ACEOF
5812 #define off_t long
5813 _ACEOF
5814
5815 fi
5816
5817
5818 # check header files
5819 echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5820 echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5821 if test "${ac_cv_header_stdc+set}" = set; then
5822   echo $ECHO_N "(cached) $ECHO_C" >&6
5823 else
5824   cat >conftest.$ac_ext <<_ACEOF
5825 /* confdefs.h.  */
5826 _ACEOF
5827 cat confdefs.h >>conftest.$ac_ext
5828 cat >>conftest.$ac_ext <<_ACEOF
5829 /* end confdefs.h.  */
5830 #include <stdlib.h>
5831 #include <stdarg.h>
5832 #include <string.h>
5833 #include <float.h>
5834
5835 int
5836 main ()
5837 {
5838
5839   ;
5840   return 0;
5841 }
5842 _ACEOF
5843 rm -f conftest.$ac_objext
5844 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5845   (eval $ac_compile) 2>conftest.er1
5846   ac_status=$?
5847   grep -v '^ *+' conftest.er1 >conftest.err
5848   rm -f conftest.er1
5849   cat conftest.err >&5
5850   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5851   (exit $ac_status); } &&
5852          { ac_try='test -z "$ac_c_werror_flag"
5853                          || test ! -s conftest.err'
5854   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5855   (eval $ac_try) 2>&5
5856   ac_status=$?
5857   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5858   (exit $ac_status); }; } &&
5859          { ac_try='test -s conftest.$ac_objext'
5860   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5861   (eval $ac_try) 2>&5
5862   ac_status=$?
5863   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5864   (exit $ac_status); }; }; then
5865   ac_cv_header_stdc=yes
5866 else
5867   echo "$as_me: failed program was:" >&5
5868 sed 's/^/| /' conftest.$ac_ext >&5
5869
5870 ac_cv_header_stdc=no
5871 fi
5872 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5873
5874 if test $ac_cv_header_stdc = yes; then
5875   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5876   cat >conftest.$ac_ext <<_ACEOF
5877 /* confdefs.h.  */
5878 _ACEOF
5879 cat confdefs.h >>conftest.$ac_ext
5880 cat >>conftest.$ac_ext <<_ACEOF
5881 /* end confdefs.h.  */
5882 #include <string.h>
5883
5884 _ACEOF
5885 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5886   $EGREP "memchr" >/dev/null 2>&1; then
5887   :
5888 else
5889   ac_cv_header_stdc=no
5890 fi
5891 rm -f conftest*
5892
5893 fi
5894
5895 if test $ac_cv_header_stdc = yes; then
5896   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5897   cat >conftest.$ac_ext <<_ACEOF
5898 /* confdefs.h.  */
5899 _ACEOF
5900 cat confdefs.h >>conftest.$ac_ext
5901 cat >>conftest.$ac_ext <<_ACEOF
5902 /* end confdefs.h.  */
5903 #include <stdlib.h>
5904
5905 _ACEOF
5906 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5907   $EGREP "free" >/dev/null 2>&1; then
5908   :
5909 else
5910   ac_cv_header_stdc=no
5911 fi
5912 rm -f conftest*
5913
5914 fi
5915
5916 if test $ac_cv_header_stdc = yes; then
5917   # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5918   if test "$cross_compiling" = yes; then
5919   :
5920 else
5921   cat >conftest.$ac_ext <<_ACEOF
5922 /* confdefs.h.  */
5923 _ACEOF
5924 cat confdefs.h >>conftest.$ac_ext
5925 cat >>conftest.$ac_ext <<_ACEOF
5926 /* end confdefs.h.  */
5927 #include <ctype.h>
5928 #if ((' ' & 0x0FF) == 0x020)
5929 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5930 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5931 #else
5932 # define ISLOWER(c) \
5933                    (('a' <= (c) && (c) <= 'i') \
5934                      || ('j' <= (c) && (c) <= 'r') \
5935                      || ('s' <= (c) && (c) <= 'z'))
5936 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5937 #endif
5938
5939 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5940 int
5941 main ()
5942 {
5943   int i;
5944   for (i = 0; i < 256; i++)
5945     if (XOR (islower (i), ISLOWER (i))
5946         || toupper (i) != TOUPPER (i))
5947       exit(2);
5948   exit (0);
5949 }
5950 _ACEOF
5951 rm -f conftest$ac_exeext
5952 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5953   (eval $ac_link) 2>&5
5954   ac_status=$?
5955   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5956   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5957   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5958   (eval $ac_try) 2>&5
5959   ac_status=$?
5960   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5961   (exit $ac_status); }; }; then
5962   :
5963 else
5964   echo "$as_me: program exited with status $ac_status" >&5
5965 echo "$as_me: failed program was:" >&5
5966 sed 's/^/| /' conftest.$ac_ext >&5
5967
5968 ( exit $ac_status )
5969 ac_cv_header_stdc=no
5970 fi
5971 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5972 fi
5973 fi
5974 fi
5975 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5976 echo "${ECHO_T}$ac_cv_header_stdc" >&6
5977 if test $ac_cv_header_stdc = yes; then
5978
5979 cat >>confdefs.h <<\_ACEOF
5980 #define STDC_HEADERS 1
5981 _ACEOF
5982
5983 fi
5984
5985
5986
5987
5988
5989
5990
5991
5992 for ac_header in stdlib.h stdio.h string.h stddef.h math.h unistd.h signal.h
5993 do
5994 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5995 if eval "test \"\${$as_ac_Header+set}\" = set"; then
5996   echo "$as_me:$LINENO: checking for $ac_header" >&5
5997 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5998 if eval "test \"\${$as_ac_Header+set}\" = set"; then
5999   echo $ECHO_N "(cached) $ECHO_C" >&6
6000 fi
6001 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6002 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6003 else
6004   # Is the header compilable?
6005 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6006 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6007 cat >conftest.$ac_ext <<_ACEOF
6008 /* confdefs.h.  */
6009 _ACEOF
6010 cat confdefs.h >>conftest.$ac_ext
6011 cat >>conftest.$ac_ext <<_ACEOF
6012 /* end confdefs.h.  */
6013 $ac_includes_default
6014 #include <$ac_header>
6015 _ACEOF
6016 rm -f conftest.$ac_objext
6017 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6018   (eval $ac_compile) 2>conftest.er1
6019   ac_status=$?
6020   grep -v '^ *+' conftest.er1 >conftest.err
6021   rm -f conftest.er1
6022   cat conftest.err >&5
6023   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6024   (exit $ac_status); } &&
6025          { ac_try='test -z "$ac_c_werror_flag"
6026                          || test ! -s conftest.err'
6027   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6028   (eval $ac_try) 2>&5
6029   ac_status=$?
6030   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6031   (exit $ac_status); }; } &&
6032          { ac_try='test -s conftest.$ac_objext'
6033   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6034   (eval $ac_try) 2>&5
6035   ac_status=$?
6036   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6037   (exit $ac_status); }; }; then
6038   ac_header_compiler=yes
6039 else
6040   echo "$as_me: failed program was:" >&5
6041 sed 's/^/| /' conftest.$ac_ext >&5
6042
6043 ac_header_compiler=no
6044 fi
6045 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6046 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6047 echo "${ECHO_T}$ac_header_compiler" >&6
6048
6049 # Is the header present?
6050 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6051 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6052 cat >conftest.$ac_ext <<_ACEOF
6053 /* confdefs.h.  */
6054 _ACEOF
6055 cat confdefs.h >>conftest.$ac_ext
6056 cat >>conftest.$ac_ext <<_ACEOF
6057 /* end confdefs.h.  */
6058 #include <$ac_header>
6059 _ACEOF
6060 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6061   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6062   ac_status=$?
6063   grep -v '^ *+' conftest.er1 >conftest.err
6064   rm -f conftest.er1
6065   cat conftest.err >&5
6066   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6067   (exit $ac_status); } >/dev/null; then
6068   if test -s conftest.err; then
6069     ac_cpp_err=$ac_c_preproc_warn_flag
6070     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6071   else
6072     ac_cpp_err=
6073   fi
6074 else
6075   ac_cpp_err=yes
6076 fi
6077 if test -z "$ac_cpp_err"; then
6078   ac_header_preproc=yes
6079 else
6080   echo "$as_me: failed program was:" >&5
6081 sed 's/^/| /' conftest.$ac_ext >&5
6082
6083   ac_header_preproc=no
6084 fi
6085 rm -f conftest.err conftest.$ac_ext
6086 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6087 echo "${ECHO_T}$ac_header_preproc" >&6
6088
6089 # So?  What about this header?
6090 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6091   yes:no: )
6092     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6093 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6094     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6095 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6096     ac_header_preproc=yes
6097     ;;
6098   no:yes:* )
6099     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6100 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6101     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6102 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6103     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6104 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6105     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6106 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6107     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6108 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6109     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6110 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6111     (
6112       cat <<\_ASBOX
6113 ## ------------------------------------------------------ ##
6114 ## Report this to the GNU Fortran Runtime Library lists.  ##
6115 ## ------------------------------------------------------ ##
6116 _ASBOX
6117     ) |
6118       sed "s/^/$as_me: WARNING:     /" >&2
6119     ;;
6120 esac
6121 echo "$as_me:$LINENO: checking for $ac_header" >&5
6122 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6123 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6124   echo $ECHO_N "(cached) $ECHO_C" >&6
6125 else
6126   eval "$as_ac_Header=\$ac_header_preproc"
6127 fi
6128 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6129 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6130
6131 fi
6132 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6133   cat >>confdefs.h <<_ACEOF
6134 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6135 _ACEOF
6136
6137 fi
6138
6139 done
6140
6141
6142
6143
6144
6145
6146 for ac_header in time.h sys/params.h sys/time.h sys/times.h sys/resource.h
6147 do
6148 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6149 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6150   echo "$as_me:$LINENO: checking for $ac_header" >&5
6151 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6152 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6153   echo $ECHO_N "(cached) $ECHO_C" >&6
6154 fi
6155 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6156 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6157 else
6158   # Is the header compilable?
6159 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6160 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6161 cat >conftest.$ac_ext <<_ACEOF
6162 /* confdefs.h.  */
6163 _ACEOF
6164 cat confdefs.h >>conftest.$ac_ext
6165 cat >>conftest.$ac_ext <<_ACEOF
6166 /* end confdefs.h.  */
6167 $ac_includes_default
6168 #include <$ac_header>
6169 _ACEOF
6170 rm -f conftest.$ac_objext
6171 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6172   (eval $ac_compile) 2>conftest.er1
6173   ac_status=$?
6174   grep -v '^ *+' conftest.er1 >conftest.err
6175   rm -f conftest.er1
6176   cat conftest.err >&5
6177   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6178   (exit $ac_status); } &&
6179          { ac_try='test -z "$ac_c_werror_flag"
6180                          || test ! -s conftest.err'
6181   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6182   (eval $ac_try) 2>&5
6183   ac_status=$?
6184   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6185   (exit $ac_status); }; } &&
6186          { ac_try='test -s conftest.$ac_objext'
6187   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6188   (eval $ac_try) 2>&5
6189   ac_status=$?
6190   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6191   (exit $ac_status); }; }; then
6192   ac_header_compiler=yes
6193 else
6194   echo "$as_me: failed program was:" >&5
6195 sed 's/^/| /' conftest.$ac_ext >&5
6196
6197 ac_header_compiler=no
6198 fi
6199 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6200 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6201 echo "${ECHO_T}$ac_header_compiler" >&6
6202
6203 # Is the header present?
6204 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6205 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6206 cat >conftest.$ac_ext <<_ACEOF
6207 /* confdefs.h.  */
6208 _ACEOF
6209 cat confdefs.h >>conftest.$ac_ext
6210 cat >>conftest.$ac_ext <<_ACEOF
6211 /* end confdefs.h.  */
6212 #include <$ac_header>
6213 _ACEOF
6214 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6215   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6216   ac_status=$?
6217   grep -v '^ *+' conftest.er1 >conftest.err
6218   rm -f conftest.er1
6219   cat conftest.err >&5
6220   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6221   (exit $ac_status); } >/dev/null; then
6222   if test -s conftest.err; then
6223     ac_cpp_err=$ac_c_preproc_warn_flag
6224     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6225   else
6226     ac_cpp_err=
6227   fi
6228 else
6229   ac_cpp_err=yes
6230 fi
6231 if test -z "$ac_cpp_err"; then
6232   ac_header_preproc=yes
6233 else
6234   echo "$as_me: failed program was:" >&5
6235 sed 's/^/| /' conftest.$ac_ext >&5
6236
6237   ac_header_preproc=no
6238 fi
6239 rm -f conftest.err conftest.$ac_ext
6240 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6241 echo "${ECHO_T}$ac_header_preproc" >&6
6242
6243 # So?  What about this header?
6244 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6245   yes:no: )
6246     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6247 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6248     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6249 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6250     ac_header_preproc=yes
6251     ;;
6252   no:yes:* )
6253     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6254 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6255     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6256 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6257     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6258 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6259     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6260 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6261     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6262 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6263     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6264 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6265     (
6266       cat <<\_ASBOX
6267 ## ------------------------------------------------------ ##
6268 ## Report this to the GNU Fortran Runtime Library lists.  ##
6269 ## ------------------------------------------------------ ##
6270 _ASBOX
6271     ) |
6272       sed "s/^/$as_me: WARNING:     /" >&2
6273     ;;
6274 esac
6275 echo "$as_me:$LINENO: checking for $ac_header" >&5
6276 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6277 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6278   echo $ECHO_N "(cached) $ECHO_C" >&6
6279 else
6280   eval "$as_ac_Header=\$ac_header_preproc"
6281 fi
6282 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6283 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6284
6285 fi
6286 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6287   cat >>confdefs.h <<_ACEOF
6288 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6289 _ACEOF
6290
6291 fi
6292
6293 done
6294
6295
6296
6297
6298
6299
6300 for ac_header in sys/types.h sys/stat.h sys/wait.h floatingpoint.h ieeefp.h
6301 do
6302 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6303 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6304   echo "$as_me:$LINENO: checking for $ac_header" >&5
6305 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6306 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6307   echo $ECHO_N "(cached) $ECHO_C" >&6
6308 fi
6309 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6310 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6311 else
6312   # Is the header compilable?
6313 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6314 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6315 cat >conftest.$ac_ext <<_ACEOF
6316 /* confdefs.h.  */
6317 _ACEOF
6318 cat confdefs.h >>conftest.$ac_ext
6319 cat >>conftest.$ac_ext <<_ACEOF
6320 /* end confdefs.h.  */
6321 $ac_includes_default
6322 #include <$ac_header>
6323 _ACEOF
6324 rm -f conftest.$ac_objext
6325 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6326   (eval $ac_compile) 2>conftest.er1
6327   ac_status=$?
6328   grep -v '^ *+' conftest.er1 >conftest.err
6329   rm -f conftest.er1
6330   cat conftest.err >&5
6331   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6332   (exit $ac_status); } &&
6333          { ac_try='test -z "$ac_c_werror_flag"
6334                          || test ! -s conftest.err'
6335   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6336   (eval $ac_try) 2>&5
6337   ac_status=$?
6338   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6339   (exit $ac_status); }; } &&
6340          { ac_try='test -s conftest.$ac_objext'
6341   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6342   (eval $ac_try) 2>&5
6343   ac_status=$?
6344   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6345   (exit $ac_status); }; }; then
6346   ac_header_compiler=yes
6347 else
6348   echo "$as_me: failed program was:" >&5
6349 sed 's/^/| /' conftest.$ac_ext >&5
6350
6351 ac_header_compiler=no
6352 fi
6353 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6354 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6355 echo "${ECHO_T}$ac_header_compiler" >&6
6356
6357 # Is the header present?
6358 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6359 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6360 cat >conftest.$ac_ext <<_ACEOF
6361 /* confdefs.h.  */
6362 _ACEOF
6363 cat confdefs.h >>conftest.$ac_ext
6364 cat >>conftest.$ac_ext <<_ACEOF
6365 /* end confdefs.h.  */
6366 #include <$ac_header>
6367 _ACEOF
6368 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6369   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6370   ac_status=$?
6371   grep -v '^ *+' conftest.er1 >conftest.err
6372   rm -f conftest.er1
6373   cat conftest.err >&5
6374   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6375   (exit $ac_status); } >/dev/null; then
6376   if test -s conftest.err; then
6377     ac_cpp_err=$ac_c_preproc_warn_flag
6378     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6379   else
6380     ac_cpp_err=
6381   fi
6382 else
6383   ac_cpp_err=yes
6384 fi
6385 if test -z "$ac_cpp_err"; then
6386   ac_header_preproc=yes
6387 else
6388   echo "$as_me: failed program was:" >&5
6389 sed 's/^/| /' conftest.$ac_ext >&5
6390
6391   ac_header_preproc=no
6392 fi
6393 rm -f conftest.err conftest.$ac_ext
6394 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6395 echo "${ECHO_T}$ac_header_preproc" >&6
6396
6397 # So?  What about this header?
6398 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6399   yes:no: )
6400     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6401 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6402     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6403 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6404     ac_header_preproc=yes
6405     ;;
6406   no:yes:* )
6407     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6408 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6409     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6410 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6411     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6412 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6413     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6414 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6415     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6416 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6417     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6418 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6419     (
6420       cat <<\_ASBOX
6421 ## ------------------------------------------------------ ##
6422 ## Report this to the GNU Fortran Runtime Library lists.  ##
6423 ## ------------------------------------------------------ ##
6424 _ASBOX
6425     ) |
6426       sed "s/^/$as_me: WARNING:     /" >&2
6427     ;;
6428 esac
6429 echo "$as_me:$LINENO: checking for $ac_header" >&5
6430 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6431 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6432   echo $ECHO_N "(cached) $ECHO_C" >&6
6433 else
6434   eval "$as_ac_Header=\$ac_header_preproc"
6435 fi
6436 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6437 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6438
6439 fi
6440 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6441   cat >>confdefs.h <<_ACEOF
6442 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6443 _ACEOF
6444
6445 fi
6446
6447 done
6448
6449
6450
6451
6452 for ac_header in fenv.h fptrap.h float.h
6453 do
6454 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6455 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6456   echo "$as_me:$LINENO: checking for $ac_header" >&5
6457 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6458 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6459   echo $ECHO_N "(cached) $ECHO_C" >&6
6460 fi
6461 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6462 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6463 else
6464   # Is the header compilable?
6465 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6466 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6467 cat >conftest.$ac_ext <<_ACEOF
6468 /* confdefs.h.  */
6469 _ACEOF
6470 cat confdefs.h >>conftest.$ac_ext
6471 cat >>conftest.$ac_ext <<_ACEOF
6472 /* end confdefs.h.  */
6473 $ac_includes_default
6474 #include <$ac_header>
6475 _ACEOF
6476 rm -f conftest.$ac_objext
6477 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6478   (eval $ac_compile) 2>conftest.er1
6479   ac_status=$?
6480   grep -v '^ *+' conftest.er1 >conftest.err
6481   rm -f conftest.er1
6482   cat conftest.err >&5
6483   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6484   (exit $ac_status); } &&
6485          { ac_try='test -z "$ac_c_werror_flag"
6486                          || test ! -s conftest.err'
6487   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6488   (eval $ac_try) 2>&5
6489   ac_status=$?
6490   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6491   (exit $ac_status); }; } &&
6492          { ac_try='test -s conftest.$ac_objext'
6493   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6494   (eval $ac_try) 2>&5
6495   ac_status=$?
6496   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6497   (exit $ac_status); }; }; then
6498   ac_header_compiler=yes
6499 else
6500   echo "$as_me: failed program was:" >&5
6501 sed 's/^/| /' conftest.$ac_ext >&5
6502
6503 ac_header_compiler=no
6504 fi
6505 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6506 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6507 echo "${ECHO_T}$ac_header_compiler" >&6
6508
6509 # Is the header present?
6510 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6511 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6512 cat >conftest.$ac_ext <<_ACEOF
6513 /* confdefs.h.  */
6514 _ACEOF
6515 cat confdefs.h >>conftest.$ac_ext
6516 cat >>conftest.$ac_ext <<_ACEOF
6517 /* end confdefs.h.  */
6518 #include <$ac_header>
6519 _ACEOF
6520 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6521   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6522   ac_status=$?
6523   grep -v '^ *+' conftest.er1 >conftest.err
6524   rm -f conftest.er1
6525   cat conftest.err >&5
6526   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6527   (exit $ac_status); } >/dev/null; then
6528   if test -s conftest.err; then
6529     ac_cpp_err=$ac_c_preproc_warn_flag
6530     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6531   else
6532     ac_cpp_err=
6533   fi
6534 else
6535   ac_cpp_err=yes
6536 fi
6537 if test -z "$ac_cpp_err"; then
6538   ac_header_preproc=yes
6539 else
6540   echo "$as_me: failed program was:" >&5
6541 sed 's/^/| /' conftest.$ac_ext >&5
6542
6543   ac_header_preproc=no
6544 fi
6545 rm -f conftest.err conftest.$ac_ext
6546 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6547 echo "${ECHO_T}$ac_header_preproc" >&6
6548
6549 # So?  What about this header?
6550 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6551   yes:no: )
6552     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6553 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6554     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6555 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6556     ac_header_preproc=yes
6557     ;;
6558   no:yes:* )
6559     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6560 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6561     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6562 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6563     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6564 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6565     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6566 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6567     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6568 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6569     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6570 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6571     (
6572       cat <<\_ASBOX
6573 ## ------------------------------------------------------ ##
6574 ## Report this to the GNU Fortran Runtime Library lists.  ##
6575 ## ------------------------------------------------------ ##
6576 _ASBOX
6577     ) |
6578       sed "s/^/$as_me: WARNING:     /" >&2
6579     ;;
6580 esac
6581 echo "$as_me:$LINENO: checking for $ac_header" >&5
6582 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6583 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6584   echo $ECHO_N "(cached) $ECHO_C" >&6
6585 else
6586   eval "$as_ac_Header=\$ac_header_preproc"
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
6591 fi
6592 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6593   cat >>confdefs.h <<_ACEOF
6594 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6595 _ACEOF
6596
6597 fi
6598
6599 done
6600
6601 if test "${ac_cv_header_complex_h+set}" = set; then
6602   echo "$as_me:$LINENO: checking for complex.h" >&5
6603 echo $ECHO_N "checking for complex.h... $ECHO_C" >&6
6604 if test "${ac_cv_header_complex_h+set}" = set; then
6605   echo $ECHO_N "(cached) $ECHO_C" >&6
6606 fi
6607 echo "$as_me:$LINENO: result: $ac_cv_header_complex_h" >&5
6608 echo "${ECHO_T}$ac_cv_header_complex_h" >&6
6609 else
6610   # Is the header compilable?
6611 echo "$as_me:$LINENO: checking complex.h usability" >&5
6612 echo $ECHO_N "checking complex.h usability... $ECHO_C" >&6
6613 cat >conftest.$ac_ext <<_ACEOF
6614 /* confdefs.h.  */
6615 _ACEOF
6616 cat confdefs.h >>conftest.$ac_ext
6617 cat >>conftest.$ac_ext <<_ACEOF
6618 /* end confdefs.h.  */
6619 $ac_includes_default
6620 #include <complex.h>
6621 _ACEOF
6622 rm -f conftest.$ac_objext
6623 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6624   (eval $ac_compile) 2>conftest.er1
6625   ac_status=$?
6626   grep -v '^ *+' conftest.er1 >conftest.err
6627   rm -f conftest.er1
6628   cat conftest.err >&5
6629   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6630   (exit $ac_status); } &&
6631          { ac_try='test -z "$ac_c_werror_flag"
6632                          || test ! -s conftest.err'
6633   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6634   (eval $ac_try) 2>&5
6635   ac_status=$?
6636   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6637   (exit $ac_status); }; } &&
6638          { ac_try='test -s conftest.$ac_objext'
6639   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6640   (eval $ac_try) 2>&5
6641   ac_status=$?
6642   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6643   (exit $ac_status); }; }; then
6644   ac_header_compiler=yes
6645 else
6646   echo "$as_me: failed program was:" >&5
6647 sed 's/^/| /' conftest.$ac_ext >&5
6648
6649 ac_header_compiler=no
6650 fi
6651 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6652 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6653 echo "${ECHO_T}$ac_header_compiler" >&6
6654
6655 # Is the header present?
6656 echo "$as_me:$LINENO: checking complex.h presence" >&5
6657 echo $ECHO_N "checking complex.h presence... $ECHO_C" >&6
6658 cat >conftest.$ac_ext <<_ACEOF
6659 /* confdefs.h.  */
6660 _ACEOF
6661 cat confdefs.h >>conftest.$ac_ext
6662 cat >>conftest.$ac_ext <<_ACEOF
6663 /* end confdefs.h.  */
6664 #include <complex.h>
6665 _ACEOF
6666 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6667   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6668   ac_status=$?
6669   grep -v '^ *+' conftest.er1 >conftest.err
6670   rm -f conftest.er1
6671   cat conftest.err >&5
6672   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6673   (exit $ac_status); } >/dev/null; then
6674   if test -s conftest.err; then
6675     ac_cpp_err=$ac_c_preproc_warn_flag
6676     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6677   else
6678     ac_cpp_err=
6679   fi
6680 else
6681   ac_cpp_err=yes
6682 fi
6683 if test -z "$ac_cpp_err"; then
6684   ac_header_preproc=yes
6685 else
6686   echo "$as_me: failed program was:" >&5
6687 sed 's/^/| /' conftest.$ac_ext >&5
6688
6689   ac_header_preproc=no
6690 fi
6691 rm -f conftest.err conftest.$ac_ext
6692 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6693 echo "${ECHO_T}$ac_header_preproc" >&6
6694
6695 # So?  What about this header?
6696 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6697   yes:no: )
6698     { echo "$as_me:$LINENO: WARNING: complex.h: accepted by the compiler, rejected by the preprocessor!" >&5
6699 echo "$as_me: WARNING: complex.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6700     { echo "$as_me:$LINENO: WARNING: complex.h: proceeding with the compiler's result" >&5
6701 echo "$as_me: WARNING: complex.h: proceeding with the compiler's result" >&2;}
6702     ac_header_preproc=yes
6703     ;;
6704   no:yes:* )
6705     { echo "$as_me:$LINENO: WARNING: complex.h: present but cannot be compiled" >&5
6706 echo "$as_me: WARNING: complex.h: present but cannot be compiled" >&2;}
6707     { echo "$as_me:$LINENO: WARNING: complex.h:     check for missing prerequisite headers?" >&5
6708 echo "$as_me: WARNING: complex.h:     check for missing prerequisite headers?" >&2;}
6709     { echo "$as_me:$LINENO: WARNING: complex.h: see the Autoconf documentation" >&5
6710 echo "$as_me: WARNING: complex.h: see the Autoconf documentation" >&2;}
6711     { echo "$as_me:$LINENO: WARNING: complex.h:     section \"Present But Cannot Be Compiled\"" >&5
6712 echo "$as_me: WARNING: complex.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6713     { echo "$as_me:$LINENO: WARNING: complex.h: proceeding with the preprocessor's result" >&5
6714 echo "$as_me: WARNING: complex.h: proceeding with the preprocessor's result" >&2;}
6715     { echo "$as_me:$LINENO: WARNING: complex.h: in the future, the compiler will take precedence" >&5
6716 echo "$as_me: WARNING: complex.h: in the future, the compiler will take precedence" >&2;}
6717     (
6718       cat <<\_ASBOX
6719 ## ------------------------------------------------------ ##
6720 ## Report this to the GNU Fortran Runtime Library lists.  ##
6721 ## ------------------------------------------------------ ##
6722 _ASBOX
6723     ) |
6724       sed "s/^/$as_me: WARNING:     /" >&2
6725     ;;
6726 esac
6727 echo "$as_me:$LINENO: checking for complex.h" >&5
6728 echo $ECHO_N "checking for complex.h... $ECHO_C" >&6
6729 if test "${ac_cv_header_complex_h+set}" = set; then
6730   echo $ECHO_N "(cached) $ECHO_C" >&6
6731 else
6732   ac_cv_header_complex_h=$ac_header_preproc
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
6737 fi
6738 if test $ac_cv_header_complex_h = yes; then
6739
6740 cat >>confdefs.h <<\_ACEOF
6741 #define HAVE_COMPLEX_H 1
6742 _ACEOF
6743
6744 fi
6745
6746
6747
6748
6749 inttype_headers=`echo inttypes.h sys/inttypes.h  | sed -e 's/,/ /g'`
6750
6751 acx_cv_header_stdint=stddef.h
6752 acx_cv_header_stdint_kind="(already complete)"
6753 for i in stdint.h $inttype_headers; do
6754   unset ac_cv_type_uintptr_t
6755   unset ac_cv_type_uintmax_t
6756   unset ac_cv_type_int_least32_t
6757   unset ac_cv_type_int_fast32_t
6758   unset ac_cv_type_uint64_t
6759   echo $ECHO_N "looking for a compliant stdint.h in $i, $ECHO_C" >&6
6760   echo "$as_me:$LINENO: checking for uintmax_t" >&5
6761 echo $ECHO_N "checking for uintmax_t... $ECHO_C" >&6
6762 if test "${ac_cv_type_uintmax_t+set}" = set; then
6763   echo $ECHO_N "(cached) $ECHO_C" >&6
6764 else
6765   cat >conftest.$ac_ext <<_ACEOF
6766 /* confdefs.h.  */
6767 _ACEOF
6768 cat confdefs.h >>conftest.$ac_ext
6769 cat >>conftest.$ac_ext <<_ACEOF
6770 /* end confdefs.h.  */
6771 #include <sys/types.h>
6772 #include <$i>
6773
6774 int
6775 main ()
6776 {
6777 if ((uintmax_t *) 0)
6778   return 0;
6779 if (sizeof (uintmax_t))
6780   return 0;
6781   ;
6782   return 0;
6783 }
6784 _ACEOF
6785 rm -f conftest.$ac_objext
6786 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6787   (eval $ac_compile) 2>conftest.er1
6788   ac_status=$?
6789   grep -v '^ *+' conftest.er1 >conftest.err
6790   rm -f conftest.er1
6791   cat conftest.err >&5
6792   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6793   (exit $ac_status); } &&
6794          { ac_try='test -z "$ac_c_werror_flag"
6795                          || test ! -s conftest.err'
6796   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6797   (eval $ac_try) 2>&5
6798   ac_status=$?
6799   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6800   (exit $ac_status); }; } &&
6801          { ac_try='test -s conftest.$ac_objext'
6802   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6803   (eval $ac_try) 2>&5
6804   ac_status=$?
6805   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6806   (exit $ac_status); }; }; then
6807   ac_cv_type_uintmax_t=yes
6808 else
6809   echo "$as_me: failed program was:" >&5
6810 sed 's/^/| /' conftest.$ac_ext >&5
6811
6812 ac_cv_type_uintmax_t=no
6813 fi
6814 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6815 fi
6816 echo "$as_me:$LINENO: result: $ac_cv_type_uintmax_t" >&5
6817 echo "${ECHO_T}$ac_cv_type_uintmax_t" >&6
6818 if test $ac_cv_type_uintmax_t = yes; then
6819   acx_cv_header_stdint=$i
6820 else
6821   continue
6822 fi
6823
6824   echo "$as_me:$LINENO: checking for uintptr_t" >&5
6825 echo $ECHO_N "checking for uintptr_t... $ECHO_C" >&6
6826 if test "${ac_cv_type_uintptr_t+set}" = set; then
6827   echo $ECHO_N "(cached) $ECHO_C" >&6
6828 else
6829   cat >conftest.$ac_ext <<_ACEOF
6830 /* confdefs.h.  */
6831 _ACEOF
6832 cat confdefs.h >>conftest.$ac_ext
6833 cat >>conftest.$ac_ext <<_ACEOF
6834 /* end confdefs.h.  */
6835 #include <sys/types.h>
6836 #include <$i>
6837
6838 int
6839 main ()
6840 {
6841 if ((uintptr_t *) 0)
6842   return 0;
6843 if (sizeof (uintptr_t))
6844   return 0;
6845   ;
6846   return 0;
6847 }
6848 _ACEOF
6849 rm -f conftest.$ac_objext
6850 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6851   (eval $ac_compile) 2>conftest.er1
6852   ac_status=$?
6853   grep -v '^ *+' conftest.er1 >conftest.err
6854   rm -f conftest.er1
6855   cat conftest.err >&5
6856   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6857   (exit $ac_status); } &&
6858          { ac_try='test -z "$ac_c_werror_flag"
6859                          || test ! -s conftest.err'
6860   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6861   (eval $ac_try) 2>&5
6862   ac_status=$?
6863   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6864   (exit $ac_status); }; } &&
6865          { ac_try='test -s conftest.$ac_objext'
6866   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6867   (eval $ac_try) 2>&5
6868   ac_status=$?
6869   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6870   (exit $ac_status); }; }; then
6871   ac_cv_type_uintptr_t=yes
6872 else
6873   echo "$as_me: failed program was:" >&5
6874 sed 's/^/| /' conftest.$ac_ext >&5
6875
6876 ac_cv_type_uintptr_t=no
6877 fi
6878 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6879 fi
6880 echo "$as_me:$LINENO: result: $ac_cv_type_uintptr_t" >&5
6881 echo "${ECHO_T}$ac_cv_type_uintptr_t" >&6
6882 if test $ac_cv_type_uintptr_t = yes; then
6883   :
6884 else
6885   acx_cv_header_stdint_kind="(mostly complete)"
6886 fi
6887
6888   echo "$as_me:$LINENO: checking for int_least32_t" >&5
6889 echo $ECHO_N "checking for int_least32_t... $ECHO_C" >&6
6890 if test "${ac_cv_type_int_least32_t+set}" = set; then
6891   echo $ECHO_N "(cached) $ECHO_C" >&6
6892 else
6893   cat >conftest.$ac_ext <<_ACEOF
6894 /* confdefs.h.  */
6895 _ACEOF
6896 cat confdefs.h >>conftest.$ac_ext
6897 cat >>conftest.$ac_ext <<_ACEOF
6898 /* end confdefs.h.  */
6899 #include <sys/types.h>
6900 #include <$i>
6901
6902 int
6903 main ()
6904 {
6905 if ((int_least32_t *) 0)
6906   return 0;
6907 if (sizeof (int_least32_t))
6908   return 0;
6909   ;
6910   return 0;
6911 }
6912 _ACEOF
6913 rm -f conftest.$ac_objext
6914 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6915   (eval $ac_compile) 2>conftest.er1
6916   ac_status=$?
6917   grep -v '^ *+' conftest.er1 >conftest.err
6918   rm -f conftest.er1
6919   cat conftest.err >&5
6920   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6921   (exit $ac_status); } &&
6922          { ac_try='test -z "$ac_c_werror_flag"
6923                          || test ! -s conftest.err'
6924   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6925   (eval $ac_try) 2>&5
6926   ac_status=$?
6927   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6928   (exit $ac_status); }; } &&
6929          { ac_try='test -s conftest.$ac_objext'
6930   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6931   (eval $ac_try) 2>&5
6932   ac_status=$?
6933   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6934   (exit $ac_status); }; }; then
6935   ac_cv_type_int_least32_t=yes
6936 else
6937   echo "$as_me: failed program was:" >&5
6938 sed 's/^/| /' conftest.$ac_ext >&5
6939
6940 ac_cv_type_int_least32_t=no
6941 fi
6942 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6943 fi
6944 echo "$as_me:$LINENO: result: $ac_cv_type_int_least32_t" >&5
6945 echo "${ECHO_T}$ac_cv_type_int_least32_t" >&6
6946 if test $ac_cv_type_int_least32_t = yes; then
6947   :
6948 else
6949   acx_cv_header_stdint_kind="(mostly complete)"
6950 fi
6951
6952   echo "$as_me:$LINENO: checking for int_fast32_t" >&5
6953 echo $ECHO_N "checking for int_fast32_t... $ECHO_C" >&6
6954 if test "${ac_cv_type_int_fast32_t+set}" = set; then
6955   echo $ECHO_N "(cached) $ECHO_C" >&6
6956 else
6957   cat >conftest.$ac_ext <<_ACEOF
6958 /* confdefs.h.  */
6959 _ACEOF
6960 cat confdefs.h >>conftest.$ac_ext
6961 cat >>conftest.$ac_ext <<_ACEOF
6962 /* end confdefs.h.  */
6963 #include <sys/types.h>
6964 #include <$i>
6965
6966 int
6967 main ()
6968 {
6969 if ((int_fast32_t *) 0)
6970   return 0;
6971 if (sizeof (int_fast32_t))
6972   return 0;
6973   ;
6974   return 0;
6975 }
6976 _ACEOF
6977 rm -f conftest.$ac_objext
6978 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6979   (eval $ac_compile) 2>conftest.er1
6980   ac_status=$?
6981   grep -v '^ *+' conftest.er1 >conftest.err
6982   rm -f conftest.er1
6983   cat conftest.err >&5
6984   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6985   (exit $ac_status); } &&
6986          { ac_try='test -z "$ac_c_werror_flag"
6987                          || test ! -s conftest.err'
6988   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6989   (eval $ac_try) 2>&5
6990   ac_status=$?
6991   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6992   (exit $ac_status); }; } &&
6993          { ac_try='test -s conftest.$ac_objext'
6994   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6995   (eval $ac_try) 2>&5
6996   ac_status=$?
6997   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6998   (exit $ac_status); }; }; then
6999   ac_cv_type_int_fast32_t=yes
7000 else
7001   echo "$as_me: failed program was:" >&5
7002 sed 's/^/| /' conftest.$ac_ext >&5
7003
7004 ac_cv_type_int_fast32_t=no
7005 fi
7006 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7007 fi
7008 echo "$as_me:$LINENO: result: $ac_cv_type_int_fast32_t" >&5
7009 echo "${ECHO_T}$ac_cv_type_int_fast32_t" >&6
7010 if test $ac_cv_type_int_fast32_t = yes; then
7011   :
7012 else
7013   acx_cv_header_stdint_kind="(mostly complete)"
7014 fi
7015
7016   echo "$as_me:$LINENO: checking for uint64_t" >&5
7017 echo $ECHO_N "checking for uint64_t... $ECHO_C" >&6
7018 if test "${ac_cv_type_uint64_t+set}" = set; then
7019   echo $ECHO_N "(cached) $ECHO_C" >&6
7020 else
7021   cat >conftest.$ac_ext <<_ACEOF
7022 /* confdefs.h.  */
7023 _ACEOF
7024 cat confdefs.h >>conftest.$ac_ext
7025 cat >>conftest.$ac_ext <<_ACEOF
7026 /* end confdefs.h.  */
7027 #include <sys/types.h>
7028 #include <$i>
7029
7030 int
7031 main ()
7032 {
7033 if ((uint64_t *) 0)
7034   return 0;
7035 if (sizeof (uint64_t))
7036   return 0;
7037   ;
7038   return 0;
7039 }
7040 _ACEOF
7041 rm -f conftest.$ac_objext
7042 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7043   (eval $ac_compile) 2>conftest.er1
7044   ac_status=$?
7045   grep -v '^ *+' conftest.er1 >conftest.err
7046   rm -f conftest.er1
7047   cat conftest.err >&5
7048   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7049   (exit $ac_status); } &&
7050          { ac_try='test -z "$ac_c_werror_flag"
7051                          || test ! -s conftest.err'
7052   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7053   (eval $ac_try) 2>&5
7054   ac_status=$?
7055   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7056   (exit $ac_status); }; } &&
7057          { ac_try='test -s conftest.$ac_objext'
7058   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7059   (eval $ac_try) 2>&5
7060   ac_status=$?
7061   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7062   (exit $ac_status); }; }; then
7063   ac_cv_type_uint64_t=yes
7064 else
7065   echo "$as_me: failed program was:" >&5
7066 sed 's/^/| /' conftest.$ac_ext >&5
7067
7068 ac_cv_type_uint64_t=no
7069 fi
7070 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7071 fi
7072 echo "$as_me:$LINENO: result: $ac_cv_type_uint64_t" >&5
7073 echo "${ECHO_T}$ac_cv_type_uint64_t" >&6
7074 if test $ac_cv_type_uint64_t = yes; then
7075   :
7076 else
7077   acx_cv_header_stdint_kind="(lacks uint64_t)"
7078 fi
7079
7080   break
7081 done
7082 if test "$acx_cv_header_stdint" = stddef.h; then
7083   acx_cv_header_stdint_kind="(lacks uintmax_t)"
7084   for i in stdint.h $inttype_headers; do
7085     unset ac_cv_type_uintptr_t
7086     unset ac_cv_type_uint32_t
7087     unset ac_cv_type_uint64_t
7088     echo $ECHO_N "looking for an incomplete stdint.h in $i, $ECHO_C" >&6
7089     echo "$as_me:$LINENO: checking for uint32_t" >&5
7090 echo $ECHO_N "checking for uint32_t... $ECHO_C" >&6
7091 if test "${ac_cv_type_uint32_t+set}" = set; then
7092   echo $ECHO_N "(cached) $ECHO_C" >&6
7093 else
7094   cat >conftest.$ac_ext <<_ACEOF
7095 /* confdefs.h.  */
7096 _ACEOF
7097 cat confdefs.h >>conftest.$ac_ext
7098 cat >>conftest.$ac_ext <<_ACEOF
7099 /* end confdefs.h.  */
7100 #include <sys/types.h>
7101 #include <$i>
7102
7103 int
7104 main ()
7105 {
7106 if ((uint32_t *) 0)
7107   return 0;
7108 if (sizeof (uint32_t))
7109   return 0;
7110   ;
7111   return 0;
7112 }
7113 _ACEOF
7114 rm -f conftest.$ac_objext
7115 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7116   (eval $ac_compile) 2>conftest.er1
7117   ac_status=$?
7118   grep -v '^ *+' conftest.er1 >conftest.err
7119   rm -f conftest.er1
7120   cat conftest.err >&5
7121   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7122   (exit $ac_status); } &&
7123          { ac_try='test -z "$ac_c_werror_flag"
7124                          || test ! -s conftest.err'
7125   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7126   (eval $ac_try) 2>&5
7127   ac_status=$?
7128   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7129   (exit $ac_status); }; } &&
7130          { ac_try='test -s conftest.$ac_objext'
7131   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7132   (eval $ac_try) 2>&5
7133   ac_status=$?
7134   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7135   (exit $ac_status); }; }; then
7136   ac_cv_type_uint32_t=yes
7137 else
7138   echo "$as_me: failed program was:" >&5
7139 sed 's/^/| /' conftest.$ac_ext >&5
7140
7141 ac_cv_type_uint32_t=no
7142 fi
7143 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7144 fi
7145 echo "$as_me:$LINENO: result: $ac_cv_type_uint32_t" >&5
7146 echo "${ECHO_T}$ac_cv_type_uint32_t" >&6
7147 if test $ac_cv_type_uint32_t = yes; then
7148   acx_cv_header_stdint=$i
7149 else
7150   continue
7151 fi
7152
7153     echo "$as_me:$LINENO: checking for uint64_t" >&5
7154 echo $ECHO_N "checking for uint64_t... $ECHO_C" >&6
7155 if test "${ac_cv_type_uint64_t+set}" = set; then
7156   echo $ECHO_N "(cached) $ECHO_C" >&6
7157 else
7158   cat >conftest.$ac_ext <<_ACEOF
7159 /* confdefs.h.  */
7160 _ACEOF
7161 cat confdefs.h >>conftest.$ac_ext
7162 cat >>conftest.$ac_ext <<_ACEOF
7163 /* end confdefs.h.  */
7164 #include <sys/types.h>
7165 #include <$i>
7166
7167 int
7168 main ()
7169 {
7170 if ((uint64_t *) 0)
7171   return 0;
7172 if (sizeof (uint64_t))
7173   return 0;
7174   ;
7175   return 0;
7176 }
7177 _ACEOF
7178 rm -f conftest.$ac_objext
7179 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7180   (eval $ac_compile) 2>conftest.er1
7181   ac_status=$?
7182   grep -v '^ *+' conftest.er1 >conftest.err
7183   rm -f conftest.er1
7184   cat conftest.err >&5
7185   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7186   (exit $ac_status); } &&
7187          { ac_try='test -z "$ac_c_werror_flag"
7188                          || test ! -s conftest.err'
7189   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7190   (eval $ac_try) 2>&5
7191   ac_status=$?
7192   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7193   (exit $ac_status); }; } &&
7194          { ac_try='test -s conftest.$ac_objext'
7195   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7196   (eval $ac_try) 2>&5
7197   ac_status=$?
7198   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7199   (exit $ac_status); }; }; then
7200   ac_cv_type_uint64_t=yes
7201 else
7202   echo "$as_me: failed program was:" >&5
7203 sed 's/^/| /' conftest.$ac_ext >&5
7204
7205 ac_cv_type_uint64_t=no
7206 fi
7207 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7208 fi
7209 echo "$as_me:$LINENO: result: $ac_cv_type_uint64_t" >&5
7210 echo "${ECHO_T}$ac_cv_type_uint64_t" >&6
7211
7212     echo "$as_me:$LINENO: checking for uintptr_t" >&5
7213 echo $ECHO_N "checking for uintptr_t... $ECHO_C" >&6
7214 if test "${ac_cv_type_uintptr_t+set}" = set; then
7215   echo $ECHO_N "(cached) $ECHO_C" >&6
7216 else
7217   cat >conftest.$ac_ext <<_ACEOF
7218 /* confdefs.h.  */
7219 _ACEOF
7220 cat confdefs.h >>conftest.$ac_ext
7221 cat >>conftest.$ac_ext <<_ACEOF
7222 /* end confdefs.h.  */
7223 #include <sys/types.h>
7224 #include <$i>
7225
7226 int
7227 main ()
7228 {
7229 if ((uintptr_t *) 0)
7230   return 0;
7231 if (sizeof (uintptr_t))
7232   return 0;
7233   ;
7234   return 0;
7235 }
7236 _ACEOF
7237 rm -f conftest.$ac_objext
7238 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7239   (eval $ac_compile) 2>conftest.er1
7240   ac_status=$?
7241   grep -v '^ *+' conftest.er1 >conftest.err
7242   rm -f conftest.er1
7243   cat conftest.err >&5
7244   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7245   (exit $ac_status); } &&
7246          { ac_try='test -z "$ac_c_werror_flag"
7247                          || test ! -s conftest.err'
7248   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7249   (eval $ac_try) 2>&5
7250   ac_status=$?
7251   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7252   (exit $ac_status); }; } &&
7253          { ac_try='test -s conftest.$ac_objext'
7254   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7255   (eval $ac_try) 2>&5
7256   ac_status=$?
7257   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7258   (exit $ac_status); }; }; then
7259   ac_cv_type_uintptr_t=yes
7260 else
7261   echo "$as_me: failed program was:" >&5
7262 sed 's/^/| /' conftest.$ac_ext >&5
7263
7264 ac_cv_type_uintptr_t=no
7265 fi
7266 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7267 fi
7268 echo "$as_me:$LINENO: result: $ac_cv_type_uintptr_t" >&5
7269 echo "${ECHO_T}$ac_cv_type_uintptr_t" >&6
7270
7271     break
7272   done
7273 fi
7274 if test "$acx_cv_header_stdint" = stddef.h; then
7275   acx_cv_header_stdint_kind="(u_intXX_t style)"
7276   for i in sys/types.h $inttype_headers; do
7277     unset ac_cv_type_u_int32_t
7278     unset ac_cv_type_u_int64_t
7279     echo $ECHO_N "looking for u_intXX_t types in $i, $ECHO_C" >&6
7280     echo "$as_me:$LINENO: checking for u_int32_t" >&5
7281 echo $ECHO_N "checking for u_int32_t... $ECHO_C" >&6
7282 if test "${ac_cv_type_u_int32_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 ((u_int32_t *) 0)
7298   return 0;
7299 if (sizeof (u_int32_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_u_int32_t=yes
7328 else
7329   echo "$as_me: failed program was:" >&5
7330 sed 's/^/| /' conftest.$ac_ext >&5
7331
7332 ac_cv_type_u_int32_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_u_int32_t" >&5
7337 echo "${ECHO_T}$ac_cv_type_u_int32_t" >&6
7338 if test $ac_cv_type_u_int32_t = yes; then
7339   acx_cv_header_stdint=$i
7340 else
7341   continue
7342 fi
7343
7344     echo "$as_me:$LINENO: checking for u_int64_t" >&5
7345 echo $ECHO_N "checking for u_int64_t... $ECHO_C" >&6
7346 if test "${ac_cv_type_u_int64_t+set}" = set; then
7347   echo $ECHO_N "(cached) $ECHO_C" >&6
7348 else
7349   cat >conftest.$ac_ext <<_ACEOF
7350 /* confdefs.h.  */
7351 _ACEOF
7352 cat confdefs.h >>conftest.$ac_ext
7353 cat >>conftest.$ac_ext <<_ACEOF
7354 /* end confdefs.h.  */
7355 #include <sys/types.h>
7356 #include <$i>
7357
7358 int
7359 main ()
7360 {
7361 if ((u_int64_t *) 0)
7362   return 0;
7363 if (sizeof (u_int64_t))
7364   return 0;
7365   ;
7366   return 0;
7367 }
7368 _ACEOF
7369 rm -f conftest.$ac_objext
7370 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7371   (eval $ac_compile) 2>conftest.er1
7372   ac_status=$?
7373   grep -v '^ *+' conftest.er1 >conftest.err
7374   rm -f conftest.er1
7375   cat conftest.err >&5
7376   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7377   (exit $ac_status); } &&
7378          { ac_try='test -z "$ac_c_werror_flag"
7379                          || test ! -s conftest.err'
7380   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7381   (eval $ac_try) 2>&5
7382   ac_status=$?
7383   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7384   (exit $ac_status); }; } &&
7385          { ac_try='test -s conftest.$ac_objext'
7386   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7387   (eval $ac_try) 2>&5
7388   ac_status=$?
7389   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7390   (exit $ac_status); }; }; then
7391   ac_cv_type_u_int64_t=yes
7392 else
7393   echo "$as_me: failed program was:" >&5
7394 sed 's/^/| /' conftest.$ac_ext >&5
7395
7396 ac_cv_type_u_int64_t=no
7397 fi
7398 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7399 fi
7400 echo "$as_me:$LINENO: result: $ac_cv_type_u_int64_t" >&5
7401 echo "${ECHO_T}$ac_cv_type_u_int64_t" >&6
7402
7403     break
7404   done
7405 fi
7406 if test "$acx_cv_header_stdint" = stddef.h; then
7407   acx_cv_header_stdint_kind="(using manual detection)"
7408 fi
7409
7410 test -z "$ac_cv_type_uintptr_t" && ac_cv_type_uintptr_t=no
7411 test -z "$ac_cv_type_uint64_t" && ac_cv_type_uint64_t=no
7412 test -z "$ac_cv_type_u_int64_t" && ac_cv_type_u_int64_t=no
7413 test -z "$ac_cv_type_int_least32_t" && ac_cv_type_int_least32_t=no
7414 test -z "$ac_cv_type_int_fast32_t" && ac_cv_type_int_fast32_t=no
7415
7416 # ----------------- Summarize what we found so far
7417
7418 echo "$as_me:$LINENO: checking what to include in gstdint.h" >&5
7419 echo $ECHO_N "checking what to include in gstdint.h... $ECHO_C" >&6
7420
7421 case `$as_basename gstdint.h ||
7422 $as_expr X/gstdint.h : '.*/\([^/][^/]*\)/*$' \| \
7423          Xgstdint.h : 'X\(//\)$' \| \
7424          Xgstdint.h : 'X\(/\)$' \| \
7425          .     : '\(.\)' 2>/dev/null ||
7426 echo X/gstdint.h |
7427     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
7428           /^X\/\(\/\/\)$/{ s//\1/; q; }
7429           /^X\/\(\/\).*/{ s//\1/; q; }
7430           s/.*/./; q'` in
7431   stdint.h) { echo "$as_me:$LINENO: WARNING: are you sure you want it there?" >&5
7432 echo "$as_me: WARNING: are you sure you want it there?" >&2;} ;;
7433   inttypes.h) { echo "$as_me:$LINENO: WARNING: are you sure you want it there?" >&5
7434 echo "$as_me: WARNING: are you sure you want it there?" >&2;} ;;
7435   *) ;;
7436 esac
7437
7438 echo "$as_me:$LINENO: result: $acx_cv_header_stdint $acx_cv_header_stdint_kind" >&5
7439 echo "${ECHO_T}$acx_cv_header_stdint $acx_cv_header_stdint_kind" >&6
7440
7441 # ----------------- done included file, check C basic types --------
7442
7443 # Lacking an uintptr_t?  Test size of void *
7444 case "$acx_cv_header_stdint:$ac_cv_type_uintptr_t" in
7445   stddef.h:* | *:no) echo "$as_me:$LINENO: checking for void *" >&5
7446 echo $ECHO_N "checking for void *... $ECHO_C" >&6
7447 if test "${ac_cv_type_void_p+set}" = set; then
7448   echo $ECHO_N "(cached) $ECHO_C" >&6
7449 else
7450   cat >conftest.$ac_ext <<_ACEOF
7451 /* confdefs.h.  */
7452 _ACEOF
7453 cat confdefs.h >>conftest.$ac_ext
7454 cat >>conftest.$ac_ext <<_ACEOF
7455 /* end confdefs.h.  */
7456 $ac_includes_default
7457 int
7458 main ()
7459 {
7460 if ((void * *) 0)
7461   return 0;
7462 if (sizeof (void *))
7463   return 0;
7464   ;
7465   return 0;
7466 }
7467 _ACEOF
7468 rm -f conftest.$ac_objext
7469 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7470   (eval $ac_compile) 2>conftest.er1
7471   ac_status=$?
7472   grep -v '^ *+' conftest.er1 >conftest.err
7473   rm -f conftest.er1
7474   cat conftest.err >&5
7475   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7476   (exit $ac_status); } &&
7477          { ac_try='test -z "$ac_c_werror_flag"
7478                          || test ! -s conftest.err'
7479   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7480   (eval $ac_try) 2>&5
7481   ac_status=$?
7482   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7483   (exit $ac_status); }; } &&
7484          { ac_try='test -s conftest.$ac_objext'
7485   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7486   (eval $ac_try) 2>&5
7487   ac_status=$?
7488   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7489   (exit $ac_status); }; }; then
7490   ac_cv_type_void_p=yes
7491 else
7492   echo "$as_me: failed program was:" >&5
7493 sed 's/^/| /' conftest.$ac_ext >&5
7494
7495 ac_cv_type_void_p=no
7496 fi
7497 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7498 fi
7499 echo "$as_me:$LINENO: result: $ac_cv_type_void_p" >&5
7500 echo "${ECHO_T}$ac_cv_type_void_p" >&6
7501
7502 echo "$as_me:$LINENO: checking size of void *" >&5
7503 echo $ECHO_N "checking size of void *... $ECHO_C" >&6
7504 if test "${ac_cv_sizeof_void_p+set}" = set; then
7505   echo $ECHO_N "(cached) $ECHO_C" >&6
7506 else
7507   if test "$ac_cv_type_void_p" = yes; then
7508   # The cast to unsigned long works around a bug in the HP C Compiler
7509   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
7510   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
7511   # This bug is HP SR number 8606223364.
7512   if test "$cross_compiling" = yes; then
7513   # Depending upon the size, compute the lo and hi bounds.
7514 cat >conftest.$ac_ext <<_ACEOF
7515 /* confdefs.h.  */
7516 _ACEOF
7517 cat confdefs.h >>conftest.$ac_ext
7518 cat >>conftest.$ac_ext <<_ACEOF
7519 /* end confdefs.h.  */
7520 $ac_includes_default
7521 int
7522 main ()
7523 {
7524 static int test_array [1 - 2 * !(((long) (sizeof (void *))) >= 0)];
7525 test_array [0] = 0
7526
7527   ;
7528   return 0;
7529 }
7530 _ACEOF
7531 rm -f conftest.$ac_objext
7532 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7533   (eval $ac_compile) 2>conftest.er1
7534   ac_status=$?
7535   grep -v '^ *+' conftest.er1 >conftest.err
7536   rm -f conftest.er1
7537   cat conftest.err >&5
7538   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7539   (exit $ac_status); } &&
7540          { ac_try='test -z "$ac_c_werror_flag"
7541                          || test ! -s conftest.err'
7542   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7543   (eval $ac_try) 2>&5
7544   ac_status=$?
7545   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7546   (exit $ac_status); }; } &&
7547          { ac_try='test -s conftest.$ac_objext'
7548   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7549   (eval $ac_try) 2>&5
7550   ac_status=$?
7551   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7552   (exit $ac_status); }; }; then
7553   ac_lo=0 ac_mid=0
7554   while :; do
7555     cat >conftest.$ac_ext <<_ACEOF
7556 /* confdefs.h.  */
7557 _ACEOF
7558 cat confdefs.h >>conftest.$ac_ext
7559 cat >>conftest.$ac_ext <<_ACEOF
7560 /* end confdefs.h.  */
7561 $ac_includes_default
7562 int
7563 main ()
7564 {
7565 static int test_array [1 - 2 * !(((long) (sizeof (void *))) <= $ac_mid)];
7566 test_array [0] = 0
7567
7568   ;
7569   return 0;
7570 }
7571 _ACEOF
7572 rm -f conftest.$ac_objext
7573 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7574   (eval $ac_compile) 2>conftest.er1
7575   ac_status=$?
7576   grep -v '^ *+' conftest.er1 >conftest.err
7577   rm -f conftest.er1
7578   cat conftest.err >&5
7579   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7580   (exit $ac_status); } &&
7581          { ac_try='test -z "$ac_c_werror_flag"
7582                          || test ! -s conftest.err'
7583   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7584   (eval $ac_try) 2>&5
7585   ac_status=$?
7586   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7587   (exit $ac_status); }; } &&
7588          { ac_try='test -s conftest.$ac_objext'
7589   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7590   (eval $ac_try) 2>&5
7591   ac_status=$?
7592   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7593   (exit $ac_status); }; }; then
7594   ac_hi=$ac_mid; break
7595 else
7596   echo "$as_me: failed program was:" >&5
7597 sed 's/^/| /' conftest.$ac_ext >&5
7598
7599 ac_lo=`expr $ac_mid + 1`
7600                     if test $ac_lo -le $ac_mid; then
7601                       ac_lo= ac_hi=
7602                       break
7603                     fi
7604                     ac_mid=`expr 2 '*' $ac_mid + 1`
7605 fi
7606 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7607   done
7608 else
7609   echo "$as_me: failed program was:" >&5
7610 sed 's/^/| /' conftest.$ac_ext >&5
7611
7612 cat >conftest.$ac_ext <<_ACEOF
7613 /* confdefs.h.  */
7614 _ACEOF
7615 cat confdefs.h >>conftest.$ac_ext
7616 cat >>conftest.$ac_ext <<_ACEOF
7617 /* end confdefs.h.  */
7618 $ac_includes_default
7619 int
7620 main ()
7621 {
7622 static int test_array [1 - 2 * !(((long) (sizeof (void *))) < 0)];
7623 test_array [0] = 0
7624
7625   ;
7626   return 0;
7627 }
7628 _ACEOF
7629 rm -f conftest.$ac_objext
7630 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7631   (eval $ac_compile) 2>conftest.er1
7632   ac_status=$?
7633   grep -v '^ *+' conftest.er1 >conftest.err
7634   rm -f conftest.er1
7635   cat conftest.err >&5
7636   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7637   (exit $ac_status); } &&
7638          { ac_try='test -z "$ac_c_werror_flag"
7639                          || test ! -s conftest.err'
7640   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7641   (eval $ac_try) 2>&5
7642   ac_status=$?
7643   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7644   (exit $ac_status); }; } &&
7645          { ac_try='test -s conftest.$ac_objext'
7646   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7647   (eval $ac_try) 2>&5
7648   ac_status=$?
7649   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7650   (exit $ac_status); }; }; then
7651   ac_hi=-1 ac_mid=-1
7652   while :; do
7653     cat >conftest.$ac_ext <<_ACEOF
7654 /* confdefs.h.  */
7655 _ACEOF
7656 cat confdefs.h >>conftest.$ac_ext
7657 cat >>conftest.$ac_ext <<_ACEOF
7658 /* end confdefs.h.  */
7659 $ac_includes_default
7660 int
7661 main ()
7662 {
7663 static int test_array [1 - 2 * !(((long) (sizeof (void *))) >= $ac_mid)];
7664 test_array [0] = 0
7665
7666   ;
7667   return 0;
7668 }
7669 _ACEOF
7670 rm -f conftest.$ac_objext
7671 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7672   (eval $ac_compile) 2>conftest.er1
7673   ac_status=$?
7674   grep -v '^ *+' conftest.er1 >conftest.err
7675   rm -f conftest.er1
7676   cat conftest.err >&5
7677   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7678   (exit $ac_status); } &&
7679          { ac_try='test -z "$ac_c_werror_flag"
7680                          || test ! -s conftest.err'
7681   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7682   (eval $ac_try) 2>&5
7683   ac_status=$?
7684   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7685   (exit $ac_status); }; } &&
7686          { ac_try='test -s conftest.$ac_objext'
7687   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7688   (eval $ac_try) 2>&5
7689   ac_status=$?
7690   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7691   (exit $ac_status); }; }; then
7692   ac_lo=$ac_mid; break
7693 else
7694   echo "$as_me: failed program was:" >&5
7695 sed 's/^/| /' conftest.$ac_ext >&5
7696
7697 ac_hi=`expr '(' $ac_mid ')' - 1`
7698                        if test $ac_mid -le $ac_hi; then
7699                          ac_lo= ac_hi=
7700                          break
7701                        fi
7702                        ac_mid=`expr 2 '*' $ac_mid`
7703 fi
7704 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7705   done
7706 else
7707   echo "$as_me: failed program was:" >&5
7708 sed 's/^/| /' conftest.$ac_ext >&5
7709
7710 ac_lo= ac_hi=
7711 fi
7712 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7713 fi
7714 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7715 # Binary search between lo and hi bounds.
7716 while test "x$ac_lo" != "x$ac_hi"; do
7717   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
7718   cat >conftest.$ac_ext <<_ACEOF
7719 /* confdefs.h.  */
7720 _ACEOF
7721 cat confdefs.h >>conftest.$ac_ext
7722 cat >>conftest.$ac_ext <<_ACEOF
7723 /* end confdefs.h.  */
7724 $ac_includes_default
7725 int
7726 main ()
7727 {
7728 static int test_array [1 - 2 * !(((long) (sizeof (void *))) <= $ac_mid)];
7729 test_array [0] = 0
7730
7731   ;
7732   return 0;
7733 }
7734 _ACEOF
7735 rm -f conftest.$ac_objext
7736 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7737   (eval $ac_compile) 2>conftest.er1
7738   ac_status=$?
7739   grep -v '^ *+' conftest.er1 >conftest.err
7740   rm -f conftest.er1
7741   cat conftest.err >&5
7742   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7743   (exit $ac_status); } &&
7744          { ac_try='test -z "$ac_c_werror_flag"
7745                          || test ! -s conftest.err'
7746   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7747   (eval $ac_try) 2>&5
7748   ac_status=$?
7749   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7750   (exit $ac_status); }; } &&
7751          { ac_try='test -s conftest.$ac_objext'
7752   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7753   (eval $ac_try) 2>&5
7754   ac_status=$?
7755   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7756   (exit $ac_status); }; }; then
7757   ac_hi=$ac_mid
7758 else
7759   echo "$as_me: failed program was:" >&5
7760 sed 's/^/| /' conftest.$ac_ext >&5
7761
7762 ac_lo=`expr '(' $ac_mid ')' + 1`
7763 fi
7764 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7765 done
7766 case $ac_lo in
7767 ?*) ac_cv_sizeof_void_p=$ac_lo;;
7768 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (void *), 77
7769 See \`config.log' for more details." >&5
7770 echo "$as_me: error: cannot compute sizeof (void *), 77
7771 See \`config.log' for more details." >&2;}
7772    { (exit 1); exit 1; }; } ;;
7773 esac
7774 else
7775   if test "$cross_compiling" = yes; then
7776   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
7777 See \`config.log' for more details." >&5
7778 echo "$as_me: error: cannot run test program while cross compiling
7779 See \`config.log' for more details." >&2;}
7780    { (exit 1); exit 1; }; }
7781 else
7782   cat >conftest.$ac_ext <<_ACEOF
7783 /* confdefs.h.  */
7784 _ACEOF
7785 cat confdefs.h >>conftest.$ac_ext
7786 cat >>conftest.$ac_ext <<_ACEOF
7787 /* end confdefs.h.  */
7788 $ac_includes_default
7789 long longval () { return (long) (sizeof (void *)); }
7790 unsigned long ulongval () { return (long) (sizeof (void *)); }
7791 #include <stdio.h>
7792 #include <stdlib.h>
7793 int
7794 main ()
7795 {
7796
7797   FILE *f = fopen ("conftest.val", "w");
7798   if (! f)
7799     exit (1);
7800   if (((long) (sizeof (void *))) < 0)
7801     {
7802       long i = longval ();
7803       if (i != ((long) (sizeof (void *))))
7804         exit (1);
7805       fprintf (f, "%ld\n", i);
7806     }
7807   else
7808     {
7809       unsigned long i = ulongval ();
7810       if (i != ((long) (sizeof (void *))))
7811         exit (1);
7812       fprintf (f, "%lu\n", i);
7813     }
7814   exit (ferror (f) || fclose (f) != 0);
7815
7816   ;
7817   return 0;
7818 }
7819 _ACEOF
7820 rm -f conftest$ac_exeext
7821 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7822   (eval $ac_link) 2>&5
7823   ac_status=$?
7824   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7825   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7826   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7827   (eval $ac_try) 2>&5
7828   ac_status=$?
7829   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7830   (exit $ac_status); }; }; then
7831   ac_cv_sizeof_void_p=`cat conftest.val`
7832 else
7833   echo "$as_me: program exited with status $ac_status" >&5
7834 echo "$as_me: failed program was:" >&5
7835 sed 's/^/| /' conftest.$ac_ext >&5
7836
7837 ( exit $ac_status )
7838 { { echo "$as_me:$LINENO: error: cannot compute sizeof (void *), 77
7839 See \`config.log' for more details." >&5
7840 echo "$as_me: error: cannot compute sizeof (void *), 77
7841 See \`config.log' for more details." >&2;}
7842    { (exit 1); exit 1; }; }
7843 fi
7844 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7845 fi
7846 fi
7847 rm -f conftest.val
7848 else
7849   ac_cv_sizeof_void_p=0
7850 fi
7851 fi
7852 echo "$as_me:$LINENO: result: $ac_cv_sizeof_void_p" >&5
7853 echo "${ECHO_T}$ac_cv_sizeof_void_p" >&6
7854 cat >>confdefs.h <<_ACEOF
7855 #define SIZEOF_VOID_P $ac_cv_sizeof_void_p
7856 _ACEOF
7857
7858  ;;
7859 esac
7860
7861 # Lacking an uint64_t?  Test size of long
7862 case "$acx_cv_header_stdint:$ac_cv_type_uint64_t:$ac_cv_type_u_int64_t" in
7863   stddef.h:*:* | *:no:no) echo "$as_me:$LINENO: checking for long" >&5
7864 echo $ECHO_N "checking for long... $ECHO_C" >&6
7865 if test "${ac_cv_type_long+set}" = set; then
7866   echo $ECHO_N "(cached) $ECHO_C" >&6
7867 else
7868   cat >conftest.$ac_ext <<_ACEOF
7869 /* confdefs.h.  */
7870 _ACEOF
7871 cat confdefs.h >>conftest.$ac_ext
7872 cat >>conftest.$ac_ext <<_ACEOF
7873 /* end confdefs.h.  */
7874 $ac_includes_default
7875 int
7876 main ()
7877 {
7878 if ((long *) 0)
7879   return 0;
7880 if (sizeof (long))
7881   return 0;
7882   ;
7883   return 0;
7884 }
7885 _ACEOF
7886 rm -f conftest.$ac_objext
7887 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7888   (eval $ac_compile) 2>conftest.er1
7889   ac_status=$?
7890   grep -v '^ *+' conftest.er1 >conftest.err
7891   rm -f conftest.er1
7892   cat conftest.err >&5
7893   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7894   (exit $ac_status); } &&
7895          { ac_try='test -z "$ac_c_werror_flag"
7896                          || test ! -s conftest.err'
7897   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7898   (eval $ac_try) 2>&5
7899   ac_status=$?
7900   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7901   (exit $ac_status); }; } &&
7902          { ac_try='test -s conftest.$ac_objext'
7903   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7904   (eval $ac_try) 2>&5
7905   ac_status=$?
7906   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7907   (exit $ac_status); }; }; then
7908   ac_cv_type_long=yes
7909 else
7910   echo "$as_me: failed program was:" >&5
7911 sed 's/^/| /' conftest.$ac_ext >&5
7912
7913 ac_cv_type_long=no
7914 fi
7915 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7916 fi
7917 echo "$as_me:$LINENO: result: $ac_cv_type_long" >&5
7918 echo "${ECHO_T}$ac_cv_type_long" >&6
7919
7920 echo "$as_me:$LINENO: checking size of long" >&5
7921 echo $ECHO_N "checking size of long... $ECHO_C" >&6
7922 if test "${ac_cv_sizeof_long+set}" = set; then
7923   echo $ECHO_N "(cached) $ECHO_C" >&6
7924 else
7925   if test "$ac_cv_type_long" = yes; then
7926   # The cast to unsigned long works around a bug in the HP C Compiler
7927   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
7928   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
7929   # This bug is HP SR number 8606223364.
7930   if test "$cross_compiling" = yes; then
7931   # Depending upon the size, compute the lo and hi bounds.
7932 cat >conftest.$ac_ext <<_ACEOF
7933 /* confdefs.h.  */
7934 _ACEOF
7935 cat confdefs.h >>conftest.$ac_ext
7936 cat >>conftest.$ac_ext <<_ACEOF
7937 /* end confdefs.h.  */
7938 $ac_includes_default
7939 int
7940 main ()
7941 {
7942 static int test_array [1 - 2 * !(((long) (sizeof (long))) >= 0)];
7943 test_array [0] = 0
7944
7945   ;
7946   return 0;
7947 }
7948 _ACEOF
7949 rm -f conftest.$ac_objext
7950 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7951   (eval $ac_compile) 2>conftest.er1
7952   ac_status=$?
7953   grep -v '^ *+' conftest.er1 >conftest.err
7954   rm -f conftest.er1
7955   cat conftest.err >&5
7956   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7957   (exit $ac_status); } &&
7958          { ac_try='test -z "$ac_c_werror_flag"
7959                          || test ! -s conftest.err'
7960   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7961   (eval $ac_try) 2>&5
7962   ac_status=$?
7963   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7964   (exit $ac_status); }; } &&
7965          { ac_try='test -s conftest.$ac_objext'
7966   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7967   (eval $ac_try) 2>&5
7968   ac_status=$?
7969   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7970   (exit $ac_status); }; }; then
7971   ac_lo=0 ac_mid=0
7972   while :; do
7973     cat >conftest.$ac_ext <<_ACEOF
7974 /* confdefs.h.  */
7975 _ACEOF
7976 cat confdefs.h >>conftest.$ac_ext
7977 cat >>conftest.$ac_ext <<_ACEOF
7978 /* end confdefs.h.  */
7979 $ac_includes_default
7980 int
7981 main ()
7982 {
7983 static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];
7984 test_array [0] = 0
7985
7986   ;
7987   return 0;
7988 }
7989 _ACEOF
7990 rm -f conftest.$ac_objext
7991 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7992   (eval $ac_compile) 2>conftest.er1
7993   ac_status=$?
7994   grep -v '^ *+' conftest.er1 >conftest.err
7995   rm -f conftest.er1
7996   cat conftest.err >&5
7997   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7998   (exit $ac_status); } &&
7999          { ac_try='test -z "$ac_c_werror_flag"
8000                          || test ! -s conftest.err'
8001   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8002   (eval $ac_try) 2>&5
8003   ac_status=$?
8004   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8005   (exit $ac_status); }; } &&
8006          { ac_try='test -s conftest.$ac_objext'
8007   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8008   (eval $ac_try) 2>&5
8009   ac_status=$?
8010   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8011   (exit $ac_status); }; }; then
8012   ac_hi=$ac_mid; break
8013 else
8014   echo "$as_me: failed program was:" >&5
8015 sed 's/^/| /' conftest.$ac_ext >&5
8016
8017 ac_lo=`expr $ac_mid + 1`
8018                     if test $ac_lo -le $ac_mid; then
8019                       ac_lo= ac_hi=
8020                       break
8021                     fi
8022                     ac_mid=`expr 2 '*' $ac_mid + 1`
8023 fi
8024 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8025   done
8026 else
8027   echo "$as_me: failed program was:" >&5
8028 sed 's/^/| /' conftest.$ac_ext >&5
8029
8030 cat >conftest.$ac_ext <<_ACEOF
8031 /* confdefs.h.  */
8032 _ACEOF
8033 cat confdefs.h >>conftest.$ac_ext
8034 cat >>conftest.$ac_ext <<_ACEOF
8035 /* end confdefs.h.  */
8036 $ac_includes_default
8037 int
8038 main ()
8039 {
8040 static int test_array [1 - 2 * !(((long) (sizeof (long))) < 0)];
8041 test_array [0] = 0
8042
8043   ;
8044   return 0;
8045 }
8046 _ACEOF
8047 rm -f conftest.$ac_objext
8048 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8049   (eval $ac_compile) 2>conftest.er1
8050   ac_status=$?
8051   grep -v '^ *+' conftest.er1 >conftest.err
8052   rm -f conftest.er1
8053   cat conftest.err >&5
8054   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8055   (exit $ac_status); } &&
8056          { ac_try='test -z "$ac_c_werror_flag"
8057                          || test ! -s conftest.err'
8058   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8059   (eval $ac_try) 2>&5
8060   ac_status=$?
8061   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8062   (exit $ac_status); }; } &&
8063          { ac_try='test -s conftest.$ac_objext'
8064   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8065   (eval $ac_try) 2>&5
8066   ac_status=$?
8067   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8068   (exit $ac_status); }; }; then
8069   ac_hi=-1 ac_mid=-1
8070   while :; do
8071     cat >conftest.$ac_ext <<_ACEOF
8072 /* confdefs.h.  */
8073 _ACEOF
8074 cat confdefs.h >>conftest.$ac_ext
8075 cat >>conftest.$ac_ext <<_ACEOF
8076 /* end confdefs.h.  */
8077 $ac_includes_default
8078 int
8079 main ()
8080 {
8081 static int test_array [1 - 2 * !(((long) (sizeof (long))) >= $ac_mid)];
8082 test_array [0] = 0
8083
8084   ;
8085   return 0;
8086 }
8087 _ACEOF
8088 rm -f conftest.$ac_objext
8089 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8090   (eval $ac_compile) 2>conftest.er1
8091   ac_status=$?
8092   grep -v '^ *+' conftest.er1 >conftest.err
8093   rm -f conftest.er1
8094   cat conftest.err >&5
8095   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8096   (exit $ac_status); } &&
8097          { ac_try='test -z "$ac_c_werror_flag"
8098                          || test ! -s conftest.err'
8099   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8100   (eval $ac_try) 2>&5
8101   ac_status=$?
8102   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8103   (exit $ac_status); }; } &&
8104          { ac_try='test -s conftest.$ac_objext'
8105   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8106   (eval $ac_try) 2>&5
8107   ac_status=$?
8108   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8109   (exit $ac_status); }; }; then
8110   ac_lo=$ac_mid; break
8111 else
8112   echo "$as_me: failed program was:" >&5
8113 sed 's/^/| /' conftest.$ac_ext >&5
8114
8115 ac_hi=`expr '(' $ac_mid ')' - 1`
8116                        if test $ac_mid -le $ac_hi; then
8117                          ac_lo= ac_hi=
8118                          break
8119                        fi
8120                        ac_mid=`expr 2 '*' $ac_mid`
8121 fi
8122 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8123   done
8124 else
8125   echo "$as_me: failed program was:" >&5
8126 sed 's/^/| /' conftest.$ac_ext >&5
8127
8128 ac_lo= ac_hi=
8129 fi
8130 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8131 fi
8132 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8133 # Binary search between lo and hi bounds.
8134 while test "x$ac_lo" != "x$ac_hi"; do
8135   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
8136   cat >conftest.$ac_ext <<_ACEOF
8137 /* confdefs.h.  */
8138 _ACEOF
8139 cat confdefs.h >>conftest.$ac_ext
8140 cat >>conftest.$ac_ext <<_ACEOF
8141 /* end confdefs.h.  */
8142 $ac_includes_default
8143 int
8144 main ()
8145 {
8146 static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];
8147 test_array [0] = 0
8148
8149   ;
8150   return 0;
8151 }
8152 _ACEOF
8153 rm -f conftest.$ac_objext
8154 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8155   (eval $ac_compile) 2>conftest.er1
8156   ac_status=$?
8157   grep -v '^ *+' conftest.er1 >conftest.err
8158   rm -f conftest.er1
8159   cat conftest.err >&5
8160   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8161   (exit $ac_status); } &&
8162          { ac_try='test -z "$ac_c_werror_flag"
8163                          || test ! -s conftest.err'
8164   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8165   (eval $ac_try) 2>&5
8166   ac_status=$?
8167   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8168   (exit $ac_status); }; } &&
8169          { ac_try='test -s conftest.$ac_objext'
8170   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8171   (eval $ac_try) 2>&5
8172   ac_status=$?
8173   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8174   (exit $ac_status); }; }; then
8175   ac_hi=$ac_mid
8176 else
8177   echo "$as_me: failed program was:" >&5
8178 sed 's/^/| /' conftest.$ac_ext >&5
8179
8180 ac_lo=`expr '(' $ac_mid ')' + 1`
8181 fi
8182 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8183 done
8184 case $ac_lo in
8185 ?*) ac_cv_sizeof_long=$ac_lo;;
8186 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77
8187 See \`config.log' for more details." >&5
8188 echo "$as_me: error: cannot compute sizeof (long), 77
8189 See \`config.log' for more details." >&2;}
8190    { (exit 1); exit 1; }; } ;;
8191 esac
8192 else
8193   if test "$cross_compiling" = yes; then
8194   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
8195 See \`config.log' for more details." >&5
8196 echo "$as_me: error: cannot run test program while cross compiling
8197 See \`config.log' for more details." >&2;}
8198    { (exit 1); exit 1; }; }
8199 else
8200   cat >conftest.$ac_ext <<_ACEOF
8201 /* confdefs.h.  */
8202 _ACEOF
8203 cat confdefs.h >>conftest.$ac_ext
8204 cat >>conftest.$ac_ext <<_ACEOF
8205 /* end confdefs.h.  */
8206 $ac_includes_default
8207 long longval () { return (long) (sizeof (long)); }
8208 unsigned long ulongval () { return (long) (sizeof (long)); }
8209 #include <stdio.h>
8210 #include <stdlib.h>
8211 int
8212 main ()
8213 {
8214
8215   FILE *f = fopen ("conftest.val", "w");
8216   if (! f)
8217     exit (1);
8218   if (((long) (sizeof (long))) < 0)
8219     {
8220       long i = longval ();
8221       if (i != ((long) (sizeof (long))))
8222         exit (1);
8223       fprintf (f, "%ld\n", i);
8224     }
8225   else
8226     {
8227       unsigned long i = ulongval ();
8228       if (i != ((long) (sizeof (long))))
8229         exit (1);
8230       fprintf (f, "%lu\n", i);
8231     }
8232   exit (ferror (f) || fclose (f) != 0);
8233
8234   ;
8235   return 0;
8236 }
8237 _ACEOF
8238 rm -f conftest$ac_exeext
8239 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8240   (eval $ac_link) 2>&5
8241   ac_status=$?
8242   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8243   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8244   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8245   (eval $ac_try) 2>&5
8246   ac_status=$?
8247   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8248   (exit $ac_status); }; }; then
8249   ac_cv_sizeof_long=`cat conftest.val`
8250 else
8251   echo "$as_me: program exited with status $ac_status" >&5
8252 echo "$as_me: failed program was:" >&5
8253 sed 's/^/| /' conftest.$ac_ext >&5
8254
8255 ( exit $ac_status )
8256 { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77
8257 See \`config.log' for more details." >&5
8258 echo "$as_me: error: cannot compute sizeof (long), 77
8259 See \`config.log' for more details." >&2;}
8260    { (exit 1); exit 1; }; }
8261 fi
8262 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8263 fi
8264 fi
8265 rm -f conftest.val
8266 else
8267   ac_cv_sizeof_long=0
8268 fi
8269 fi
8270 echo "$as_me:$LINENO: result: $ac_cv_sizeof_long" >&5
8271 echo "${ECHO_T}$ac_cv_sizeof_long" >&6
8272 cat >>confdefs.h <<_ACEOF
8273 #define SIZEOF_LONG $ac_cv_sizeof_long
8274 _ACEOF
8275
8276  ;;
8277 esac
8278
8279 if test $acx_cv_header_stdint = stddef.h; then
8280   # Lacking a good header?  Test size of everything and deduce all types.
8281   echo "$as_me:$LINENO: checking for int" >&5
8282 echo $ECHO_N "checking for int... $ECHO_C" >&6
8283 if test "${ac_cv_type_int+set}" = set; then
8284   echo $ECHO_N "(cached) $ECHO_C" >&6
8285 else
8286   cat >conftest.$ac_ext <<_ACEOF
8287 /* confdefs.h.  */
8288 _ACEOF
8289 cat confdefs.h >>conftest.$ac_ext
8290 cat >>conftest.$ac_ext <<_ACEOF
8291 /* end confdefs.h.  */
8292 $ac_includes_default
8293 int
8294 main ()
8295 {
8296 if ((int *) 0)
8297   return 0;
8298 if (sizeof (int))
8299   return 0;
8300   ;
8301   return 0;
8302 }
8303 _ACEOF
8304 rm -f conftest.$ac_objext
8305 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8306   (eval $ac_compile) 2>conftest.er1
8307   ac_status=$?
8308   grep -v '^ *+' conftest.er1 >conftest.err
8309   rm -f conftest.er1
8310   cat conftest.err >&5
8311   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8312   (exit $ac_status); } &&
8313          { ac_try='test -z "$ac_c_werror_flag"
8314                          || test ! -s conftest.err'
8315   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8316   (eval $ac_try) 2>&5
8317   ac_status=$?
8318   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8319   (exit $ac_status); }; } &&
8320          { ac_try='test -s conftest.$ac_objext'
8321   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8322   (eval $ac_try) 2>&5
8323   ac_status=$?
8324   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8325   (exit $ac_status); }; }; then
8326   ac_cv_type_int=yes
8327 else
8328   echo "$as_me: failed program was:" >&5
8329 sed 's/^/| /' conftest.$ac_ext >&5
8330
8331 ac_cv_type_int=no
8332 fi
8333 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8334 fi
8335 echo "$as_me:$LINENO: result: $ac_cv_type_int" >&5
8336 echo "${ECHO_T}$ac_cv_type_int" >&6
8337
8338 echo "$as_me:$LINENO: checking size of int" >&5
8339 echo $ECHO_N "checking size of int... $ECHO_C" >&6
8340 if test "${ac_cv_sizeof_int+set}" = set; then
8341   echo $ECHO_N "(cached) $ECHO_C" >&6
8342 else
8343   if test "$ac_cv_type_int" = yes; then
8344   # The cast to unsigned long works around a bug in the HP C Compiler
8345   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
8346   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
8347   # This bug is HP SR number 8606223364.
8348   if test "$cross_compiling" = yes; then
8349   # Depending upon the size, compute the lo and hi bounds.
8350 cat >conftest.$ac_ext <<_ACEOF
8351 /* confdefs.h.  */
8352 _ACEOF
8353 cat confdefs.h >>conftest.$ac_ext
8354 cat >>conftest.$ac_ext <<_ACEOF
8355 /* end confdefs.h.  */
8356 $ac_includes_default
8357 int
8358 main ()
8359 {
8360 static int test_array [1 - 2 * !(((long) (sizeof (int))) >= 0)];
8361 test_array [0] = 0
8362
8363   ;
8364   return 0;
8365 }
8366 _ACEOF
8367 rm -f conftest.$ac_objext
8368 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8369   (eval $ac_compile) 2>conftest.er1
8370   ac_status=$?
8371   grep -v '^ *+' conftest.er1 >conftest.err
8372   rm -f conftest.er1
8373   cat conftest.err >&5
8374   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8375   (exit $ac_status); } &&
8376          { ac_try='test -z "$ac_c_werror_flag"
8377                          || test ! -s conftest.err'
8378   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8379   (eval $ac_try) 2>&5
8380   ac_status=$?
8381   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8382   (exit $ac_status); }; } &&
8383          { ac_try='test -s conftest.$ac_objext'
8384   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8385   (eval $ac_try) 2>&5
8386   ac_status=$?
8387   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8388   (exit $ac_status); }; }; then
8389   ac_lo=0 ac_mid=0
8390   while :; do
8391     cat >conftest.$ac_ext <<_ACEOF
8392 /* confdefs.h.  */
8393 _ACEOF
8394 cat confdefs.h >>conftest.$ac_ext
8395 cat >>conftest.$ac_ext <<_ACEOF
8396 /* end confdefs.h.  */
8397 $ac_includes_default
8398 int
8399 main ()
8400 {
8401 static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)];
8402 test_array [0] = 0
8403
8404   ;
8405   return 0;
8406 }
8407 _ACEOF
8408 rm -f conftest.$ac_objext
8409 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8410   (eval $ac_compile) 2>conftest.er1
8411   ac_status=$?
8412   grep -v '^ *+' conftest.er1 >conftest.err
8413   rm -f conftest.er1
8414   cat conftest.err >&5
8415   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8416   (exit $ac_status); } &&
8417          { ac_try='test -z "$ac_c_werror_flag"
8418                          || test ! -s conftest.err'
8419   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8420   (eval $ac_try) 2>&5
8421   ac_status=$?
8422   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8423   (exit $ac_status); }; } &&
8424          { ac_try='test -s conftest.$ac_objext'
8425   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8426   (eval $ac_try) 2>&5
8427   ac_status=$?
8428   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8429   (exit $ac_status); }; }; then
8430   ac_hi=$ac_mid; break
8431 else
8432   echo "$as_me: failed program was:" >&5
8433 sed 's/^/| /' conftest.$ac_ext >&5
8434
8435 ac_lo=`expr $ac_mid + 1`
8436                     if test $ac_lo -le $ac_mid; then
8437                       ac_lo= ac_hi=
8438                       break
8439                     fi
8440                     ac_mid=`expr 2 '*' $ac_mid + 1`
8441 fi
8442 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8443   done
8444 else
8445   echo "$as_me: failed program was:" >&5
8446 sed 's/^/| /' conftest.$ac_ext >&5
8447
8448 cat >conftest.$ac_ext <<_ACEOF
8449 /* confdefs.h.  */
8450 _ACEOF
8451 cat confdefs.h >>conftest.$ac_ext
8452 cat >>conftest.$ac_ext <<_ACEOF
8453 /* end confdefs.h.  */
8454 $ac_includes_default
8455 int
8456 main ()
8457 {
8458 static int test_array [1 - 2 * !(((long) (sizeof (int))) < 0)];
8459 test_array [0] = 0
8460
8461   ;
8462   return 0;
8463 }
8464 _ACEOF
8465 rm -f conftest.$ac_objext
8466 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8467   (eval $ac_compile) 2>conftest.er1
8468   ac_status=$?
8469   grep -v '^ *+' conftest.er1 >conftest.err
8470   rm -f conftest.er1
8471   cat conftest.err >&5
8472   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8473   (exit $ac_status); } &&
8474          { ac_try='test -z "$ac_c_werror_flag"
8475                          || test ! -s conftest.err'
8476   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8477   (eval $ac_try) 2>&5
8478   ac_status=$?
8479   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8480   (exit $ac_status); }; } &&
8481          { ac_try='test -s conftest.$ac_objext'
8482   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8483   (eval $ac_try) 2>&5
8484   ac_status=$?
8485   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8486   (exit $ac_status); }; }; then
8487   ac_hi=-1 ac_mid=-1
8488   while :; do
8489     cat >conftest.$ac_ext <<_ACEOF
8490 /* confdefs.h.  */
8491 _ACEOF
8492 cat confdefs.h >>conftest.$ac_ext
8493 cat >>conftest.$ac_ext <<_ACEOF
8494 /* end confdefs.h.  */
8495 $ac_includes_default
8496 int
8497 main ()
8498 {
8499 static int test_array [1 - 2 * !(((long) (sizeof (int))) >= $ac_mid)];
8500 test_array [0] = 0
8501
8502   ;
8503   return 0;
8504 }
8505 _ACEOF
8506 rm -f conftest.$ac_objext
8507 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8508   (eval $ac_compile) 2>conftest.er1
8509   ac_status=$?
8510   grep -v '^ *+' conftest.er1 >conftest.err
8511   rm -f conftest.er1
8512   cat conftest.err >&5
8513   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8514   (exit $ac_status); } &&
8515          { ac_try='test -z "$ac_c_werror_flag"
8516                          || test ! -s conftest.err'
8517   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8518   (eval $ac_try) 2>&5
8519   ac_status=$?
8520   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8521   (exit $ac_status); }; } &&
8522          { ac_try='test -s conftest.$ac_objext'
8523   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8524   (eval $ac_try) 2>&5
8525   ac_status=$?
8526   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8527   (exit $ac_status); }; }; then
8528   ac_lo=$ac_mid; break
8529 else
8530   echo "$as_me: failed program was:" >&5
8531 sed 's/^/| /' conftest.$ac_ext >&5
8532
8533 ac_hi=`expr '(' $ac_mid ')' - 1`
8534                        if test $ac_mid -le $ac_hi; then
8535                          ac_lo= ac_hi=
8536                          break
8537                        fi
8538                        ac_mid=`expr 2 '*' $ac_mid`
8539 fi
8540 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8541   done
8542 else
8543   echo "$as_me: failed program was:" >&5
8544 sed 's/^/| /' conftest.$ac_ext >&5
8545
8546 ac_lo= ac_hi=
8547 fi
8548 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8549 fi
8550 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8551 # Binary search between lo and hi bounds.
8552 while test "x$ac_lo" != "x$ac_hi"; do
8553   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
8554   cat >conftest.$ac_ext <<_ACEOF
8555 /* confdefs.h.  */
8556 _ACEOF
8557 cat confdefs.h >>conftest.$ac_ext
8558 cat >>conftest.$ac_ext <<_ACEOF
8559 /* end confdefs.h.  */
8560 $ac_includes_default
8561 int
8562 main ()
8563 {
8564 static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)];
8565 test_array [0] = 0
8566
8567   ;
8568   return 0;
8569 }
8570 _ACEOF
8571 rm -f conftest.$ac_objext
8572 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8573   (eval $ac_compile) 2>conftest.er1
8574   ac_status=$?
8575   grep -v '^ *+' conftest.er1 >conftest.err
8576   rm -f conftest.er1
8577   cat conftest.err >&5
8578   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8579   (exit $ac_status); } &&
8580          { ac_try='test -z "$ac_c_werror_flag"
8581                          || test ! -s conftest.err'
8582   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8583   (eval $ac_try) 2>&5
8584   ac_status=$?
8585   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8586   (exit $ac_status); }; } &&
8587          { ac_try='test -s conftest.$ac_objext'
8588   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8589   (eval $ac_try) 2>&5
8590   ac_status=$?
8591   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8592   (exit $ac_status); }; }; then
8593   ac_hi=$ac_mid
8594 else
8595   echo "$as_me: failed program was:" >&5
8596 sed 's/^/| /' conftest.$ac_ext >&5
8597
8598 ac_lo=`expr '(' $ac_mid ')' + 1`
8599 fi
8600 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8601 done
8602 case $ac_lo in
8603 ?*) ac_cv_sizeof_int=$ac_lo;;
8604 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77
8605 See \`config.log' for more details." >&5
8606 echo "$as_me: error: cannot compute sizeof (int), 77
8607 See \`config.log' for more details." >&2;}
8608    { (exit 1); exit 1; }; } ;;
8609 esac
8610 else
8611   if test "$cross_compiling" = yes; then
8612   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
8613 See \`config.log' for more details." >&5
8614 echo "$as_me: error: cannot run test program while cross compiling
8615 See \`config.log' for more details." >&2;}
8616    { (exit 1); exit 1; }; }
8617 else
8618   cat >conftest.$ac_ext <<_ACEOF
8619 /* confdefs.h.  */
8620 _ACEOF
8621 cat confdefs.h >>conftest.$ac_ext
8622 cat >>conftest.$ac_ext <<_ACEOF
8623 /* end confdefs.h.  */
8624 $ac_includes_default
8625 long longval () { return (long) (sizeof (int)); }
8626 unsigned long ulongval () { return (long) (sizeof (int)); }
8627 #include <stdio.h>
8628 #include <stdlib.h>
8629 int
8630 main ()
8631 {
8632
8633   FILE *f = fopen ("conftest.val", "w");
8634   if (! f)
8635     exit (1);
8636   if (((long) (sizeof (int))) < 0)
8637     {
8638       long i = longval ();
8639       if (i != ((long) (sizeof (int))))
8640         exit (1);
8641       fprintf (f, "%ld\n", i);
8642     }
8643   else
8644     {
8645       unsigned long i = ulongval ();
8646       if (i != ((long) (sizeof (int))))
8647         exit (1);
8648       fprintf (f, "%lu\n", i);
8649     }
8650   exit (ferror (f) || fclose (f) != 0);
8651
8652   ;
8653   return 0;
8654 }
8655 _ACEOF
8656 rm -f conftest$ac_exeext
8657 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8658   (eval $ac_link) 2>&5
8659   ac_status=$?
8660   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8661   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8662   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8663   (eval $ac_try) 2>&5
8664   ac_status=$?
8665   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8666   (exit $ac_status); }; }; then
8667   ac_cv_sizeof_int=`cat conftest.val`
8668 else
8669   echo "$as_me: program exited with status $ac_status" >&5
8670 echo "$as_me: failed program was:" >&5
8671 sed 's/^/| /' conftest.$ac_ext >&5
8672
8673 ( exit $ac_status )
8674 { { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77
8675 See \`config.log' for more details." >&5
8676 echo "$as_me: error: cannot compute sizeof (int), 77
8677 See \`config.log' for more details." >&2;}
8678    { (exit 1); exit 1; }; }
8679 fi
8680 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8681 fi
8682 fi
8683 rm -f conftest.val
8684 else
8685   ac_cv_sizeof_int=0
8686 fi
8687 fi
8688 echo "$as_me:$LINENO: result: $ac_cv_sizeof_int" >&5
8689 echo "${ECHO_T}$ac_cv_sizeof_int" >&6
8690 cat >>confdefs.h <<_ACEOF
8691 #define SIZEOF_INT $ac_cv_sizeof_int
8692 _ACEOF
8693
8694
8695   echo "$as_me:$LINENO: checking for short" >&5
8696 echo $ECHO_N "checking for short... $ECHO_C" >&6
8697 if test "${ac_cv_type_short+set}" = set; then
8698   echo $ECHO_N "(cached) $ECHO_C" >&6
8699 else
8700   cat >conftest.$ac_ext <<_ACEOF
8701 /* confdefs.h.  */
8702 _ACEOF
8703 cat confdefs.h >>conftest.$ac_ext
8704 cat >>conftest.$ac_ext <<_ACEOF
8705 /* end confdefs.h.  */
8706 $ac_includes_default
8707 int
8708 main ()
8709 {
8710 if ((short *) 0)
8711   return 0;
8712 if (sizeof (short))
8713   return 0;
8714   ;
8715   return 0;
8716 }
8717 _ACEOF
8718 rm -f conftest.$ac_objext
8719 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8720   (eval $ac_compile) 2>conftest.er1
8721   ac_status=$?
8722   grep -v '^ *+' conftest.er1 >conftest.err
8723   rm -f conftest.er1
8724   cat conftest.err >&5
8725   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8726   (exit $ac_status); } &&
8727          { ac_try='test -z "$ac_c_werror_flag"
8728                          || test ! -s conftest.err'
8729   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8730   (eval $ac_try) 2>&5
8731   ac_status=$?
8732   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8733   (exit $ac_status); }; } &&
8734          { ac_try='test -s conftest.$ac_objext'
8735   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8736   (eval $ac_try) 2>&5
8737   ac_status=$?
8738   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8739   (exit $ac_status); }; }; then
8740   ac_cv_type_short=yes
8741 else
8742   echo "$as_me: failed program was:" >&5
8743 sed 's/^/| /' conftest.$ac_ext >&5
8744
8745 ac_cv_type_short=no
8746 fi
8747 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8748 fi
8749 echo "$as_me:$LINENO: result: $ac_cv_type_short" >&5
8750 echo "${ECHO_T}$ac_cv_type_short" >&6
8751
8752 echo "$as_me:$LINENO: checking size of short" >&5
8753 echo $ECHO_N "checking size of short... $ECHO_C" >&6
8754 if test "${ac_cv_sizeof_short+set}" = set; then
8755   echo $ECHO_N "(cached) $ECHO_C" >&6
8756 else
8757   if test "$ac_cv_type_short" = yes; then
8758   # The cast to unsigned long works around a bug in the HP C Compiler
8759   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
8760   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
8761   # This bug is HP SR number 8606223364.
8762   if test "$cross_compiling" = yes; then
8763   # Depending upon the size, compute the lo and hi bounds.
8764 cat >conftest.$ac_ext <<_ACEOF
8765 /* confdefs.h.  */
8766 _ACEOF
8767 cat confdefs.h >>conftest.$ac_ext
8768 cat >>conftest.$ac_ext <<_ACEOF
8769 /* end confdefs.h.  */
8770 $ac_includes_default
8771 int
8772 main ()
8773 {
8774 static int test_array [1 - 2 * !(((long) (sizeof (short))) >= 0)];
8775 test_array [0] = 0
8776
8777   ;
8778   return 0;
8779 }
8780 _ACEOF
8781 rm -f conftest.$ac_objext
8782 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8783   (eval $ac_compile) 2>conftest.er1
8784   ac_status=$?
8785   grep -v '^ *+' conftest.er1 >conftest.err
8786   rm -f conftest.er1
8787   cat conftest.err >&5
8788   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8789   (exit $ac_status); } &&
8790          { ac_try='test -z "$ac_c_werror_flag"
8791                          || test ! -s conftest.err'
8792   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8793   (eval $ac_try) 2>&5
8794   ac_status=$?
8795   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8796   (exit $ac_status); }; } &&
8797          { ac_try='test -s conftest.$ac_objext'
8798   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8799   (eval $ac_try) 2>&5
8800   ac_status=$?
8801   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8802   (exit $ac_status); }; }; then
8803   ac_lo=0 ac_mid=0
8804   while :; do
8805     cat >conftest.$ac_ext <<_ACEOF
8806 /* confdefs.h.  */
8807 _ACEOF
8808 cat confdefs.h >>conftest.$ac_ext
8809 cat >>conftest.$ac_ext <<_ACEOF
8810 /* end confdefs.h.  */
8811 $ac_includes_default
8812 int
8813 main ()
8814 {
8815 static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)];
8816 test_array [0] = 0
8817
8818   ;
8819   return 0;
8820 }
8821 _ACEOF
8822 rm -f conftest.$ac_objext
8823 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8824   (eval $ac_compile) 2>conftest.er1
8825   ac_status=$?
8826   grep -v '^ *+' conftest.er1 >conftest.err
8827   rm -f conftest.er1
8828   cat conftest.err >&5
8829   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8830   (exit $ac_status); } &&
8831          { ac_try='test -z "$ac_c_werror_flag"
8832                          || test ! -s conftest.err'
8833   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8834   (eval $ac_try) 2>&5
8835   ac_status=$?
8836   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8837   (exit $ac_status); }; } &&
8838          { ac_try='test -s conftest.$ac_objext'
8839   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8840   (eval $ac_try) 2>&5
8841   ac_status=$?
8842   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8843   (exit $ac_status); }; }; then
8844   ac_hi=$ac_mid; break
8845 else
8846   echo "$as_me: failed program was:" >&5
8847 sed 's/^/| /' conftest.$ac_ext >&5
8848
8849 ac_lo=`expr $ac_mid + 1`
8850                     if test $ac_lo -le $ac_mid; then
8851                       ac_lo= ac_hi=
8852                       break
8853                     fi
8854                     ac_mid=`expr 2 '*' $ac_mid + 1`
8855 fi
8856 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8857   done
8858 else
8859   echo "$as_me: failed program was:" >&5
8860 sed 's/^/| /' conftest.$ac_ext >&5
8861
8862 cat >conftest.$ac_ext <<_ACEOF
8863 /* confdefs.h.  */
8864 _ACEOF
8865 cat confdefs.h >>conftest.$ac_ext
8866 cat >>conftest.$ac_ext <<_ACEOF
8867 /* end confdefs.h.  */
8868 $ac_includes_default
8869 int
8870 main ()
8871 {
8872 static int test_array [1 - 2 * !(((long) (sizeof (short))) < 0)];
8873 test_array [0] = 0
8874
8875   ;
8876   return 0;
8877 }
8878 _ACEOF
8879 rm -f conftest.$ac_objext
8880 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8881   (eval $ac_compile) 2>conftest.er1
8882   ac_status=$?
8883   grep -v '^ *+' conftest.er1 >conftest.err
8884   rm -f conftest.er1
8885   cat conftest.err >&5
8886   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8887   (exit $ac_status); } &&
8888          { ac_try='test -z "$ac_c_werror_flag"
8889                          || test ! -s conftest.err'
8890   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8891   (eval $ac_try) 2>&5
8892   ac_status=$?
8893   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8894   (exit $ac_status); }; } &&
8895          { ac_try='test -s conftest.$ac_objext'
8896   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8897   (eval $ac_try) 2>&5
8898   ac_status=$?
8899   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8900   (exit $ac_status); }; }; then
8901   ac_hi=-1 ac_mid=-1
8902   while :; do
8903     cat >conftest.$ac_ext <<_ACEOF
8904 /* confdefs.h.  */
8905 _ACEOF
8906 cat confdefs.h >>conftest.$ac_ext
8907 cat >>conftest.$ac_ext <<_ACEOF
8908 /* end confdefs.h.  */
8909 $ac_includes_default
8910 int
8911 main ()
8912 {
8913 static int test_array [1 - 2 * !(((long) (sizeof (short))) >= $ac_mid)];
8914 test_array [0] = 0
8915
8916   ;
8917   return 0;
8918 }
8919 _ACEOF
8920 rm -f conftest.$ac_objext
8921 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8922   (eval $ac_compile) 2>conftest.er1
8923   ac_status=$?
8924   grep -v '^ *+' conftest.er1 >conftest.err
8925   rm -f conftest.er1
8926   cat conftest.err >&5
8927   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8928   (exit $ac_status); } &&
8929          { ac_try='test -z "$ac_c_werror_flag"
8930                          || test ! -s conftest.err'
8931   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8932   (eval $ac_try) 2>&5
8933   ac_status=$?
8934   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8935   (exit $ac_status); }; } &&
8936          { ac_try='test -s conftest.$ac_objext'
8937   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8938   (eval $ac_try) 2>&5
8939   ac_status=$?
8940   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8941   (exit $ac_status); }; }; then
8942   ac_lo=$ac_mid; break
8943 else
8944   echo "$as_me: failed program was:" >&5
8945 sed 's/^/| /' conftest.$ac_ext >&5
8946
8947 ac_hi=`expr '(' $ac_mid ')' - 1`
8948                        if test $ac_mid -le $ac_hi; then
8949                          ac_lo= ac_hi=
8950                          break
8951                        fi
8952                        ac_mid=`expr 2 '*' $ac_mid`
8953 fi
8954 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8955   done
8956 else
8957   echo "$as_me: failed program was:" >&5
8958 sed 's/^/| /' conftest.$ac_ext >&5
8959
8960 ac_lo= ac_hi=
8961 fi
8962 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8963 fi
8964 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8965 # Binary search between lo and hi bounds.
8966 while test "x$ac_lo" != "x$ac_hi"; do
8967   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
8968   cat >conftest.$ac_ext <<_ACEOF
8969 /* confdefs.h.  */
8970 _ACEOF
8971 cat confdefs.h >>conftest.$ac_ext
8972 cat >>conftest.$ac_ext <<_ACEOF
8973 /* end confdefs.h.  */
8974 $ac_includes_default
8975 int
8976 main ()
8977 {
8978 static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)];
8979 test_array [0] = 0
8980
8981   ;
8982   return 0;
8983 }
8984 _ACEOF
8985 rm -f conftest.$ac_objext
8986 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8987   (eval $ac_compile) 2>conftest.er1
8988   ac_status=$?
8989   grep -v '^ *+' conftest.er1 >conftest.err
8990   rm -f conftest.er1
8991   cat conftest.err >&5
8992   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8993   (exit $ac_status); } &&
8994          { ac_try='test -z "$ac_c_werror_flag"
8995                          || test ! -s conftest.err'
8996   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8997   (eval $ac_try) 2>&5
8998   ac_status=$?
8999   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9000   (exit $ac_status); }; } &&
9001          { ac_try='test -s conftest.$ac_objext'
9002   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9003   (eval $ac_try) 2>&5
9004   ac_status=$?
9005   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9006   (exit $ac_status); }; }; then
9007   ac_hi=$ac_mid
9008 else
9009   echo "$as_me: failed program was:" >&5
9010 sed 's/^/| /' conftest.$ac_ext >&5
9011
9012 ac_lo=`expr '(' $ac_mid ')' + 1`
9013 fi
9014 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9015 done
9016 case $ac_lo in
9017 ?*) ac_cv_sizeof_short=$ac_lo;;
9018 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77
9019 See \`config.log' for more details." >&5
9020 echo "$as_me: error: cannot compute sizeof (short), 77
9021 See \`config.log' for more details." >&2;}
9022    { (exit 1); exit 1; }; } ;;
9023 esac
9024 else
9025   if test "$cross_compiling" = yes; then
9026   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
9027 See \`config.log' for more details." >&5
9028 echo "$as_me: error: cannot run test program while cross compiling
9029 See \`config.log' for more details." >&2;}
9030    { (exit 1); exit 1; }; }
9031 else
9032   cat >conftest.$ac_ext <<_ACEOF
9033 /* confdefs.h.  */
9034 _ACEOF
9035 cat confdefs.h >>conftest.$ac_ext
9036 cat >>conftest.$ac_ext <<_ACEOF
9037 /* end confdefs.h.  */
9038 $ac_includes_default
9039 long longval () { return (long) (sizeof (short)); }
9040 unsigned long ulongval () { return (long) (sizeof (short)); }
9041 #include <stdio.h>
9042 #include <stdlib.h>
9043 int
9044 main ()
9045 {
9046
9047   FILE *f = fopen ("conftest.val", "w");
9048   if (! f)
9049     exit (1);
9050   if (((long) (sizeof (short))) < 0)
9051     {
9052       long i = longval ();
9053       if (i != ((long) (sizeof (short))))
9054         exit (1);
9055       fprintf (f, "%ld\n", i);
9056     }
9057   else
9058     {
9059       unsigned long i = ulongval ();
9060       if (i != ((long) (sizeof (short))))
9061         exit (1);
9062       fprintf (f, "%lu\n", i);
9063     }
9064   exit (ferror (f) || fclose (f) != 0);
9065
9066   ;
9067   return 0;
9068 }
9069 _ACEOF
9070 rm -f conftest$ac_exeext
9071 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9072   (eval $ac_link) 2>&5
9073   ac_status=$?
9074   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9075   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9076   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9077   (eval $ac_try) 2>&5
9078   ac_status=$?
9079   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9080   (exit $ac_status); }; }; then
9081   ac_cv_sizeof_short=`cat conftest.val`
9082 else
9083   echo "$as_me: program exited with status $ac_status" >&5
9084 echo "$as_me: failed program was:" >&5
9085 sed 's/^/| /' conftest.$ac_ext >&5
9086
9087 ( exit $ac_status )
9088 { { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77
9089 See \`config.log' for more details." >&5
9090 echo "$as_me: error: cannot compute sizeof (short), 77
9091 See \`config.log' for more details." >&2;}
9092    { (exit 1); exit 1; }; }
9093 fi
9094 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9095 fi
9096 fi
9097 rm -f conftest.val
9098 else
9099   ac_cv_sizeof_short=0
9100 fi
9101 fi
9102 echo "$as_me:$LINENO: result: $ac_cv_sizeof_short" >&5
9103 echo "${ECHO_T}$ac_cv_sizeof_short" >&6
9104 cat >>confdefs.h <<_ACEOF
9105 #define SIZEOF_SHORT $ac_cv_sizeof_short
9106 _ACEOF
9107
9108
9109   echo "$as_me:$LINENO: checking for char" >&5
9110 echo $ECHO_N "checking for char... $ECHO_C" >&6
9111 if test "${ac_cv_type_char+set}" = set; then
9112   echo $ECHO_N "(cached) $ECHO_C" >&6
9113 else
9114   cat >conftest.$ac_ext <<_ACEOF
9115 /* confdefs.h.  */
9116 _ACEOF
9117 cat confdefs.h >>conftest.$ac_ext
9118 cat >>conftest.$ac_ext <<_ACEOF
9119 /* end confdefs.h.  */
9120 $ac_includes_default
9121 int
9122 main ()
9123 {
9124 if ((char *) 0)
9125   return 0;
9126 if (sizeof (char))
9127   return 0;
9128   ;
9129   return 0;
9130 }
9131 _ACEOF
9132 rm -f conftest.$ac_objext
9133 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9134   (eval $ac_compile) 2>conftest.er1
9135   ac_status=$?
9136   grep -v '^ *+' conftest.er1 >conftest.err
9137   rm -f conftest.er1
9138   cat conftest.err >&5
9139   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9140   (exit $ac_status); } &&
9141          { ac_try='test -z "$ac_c_werror_flag"
9142                          || test ! -s conftest.err'
9143   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9144   (eval $ac_try) 2>&5
9145   ac_status=$?
9146   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9147   (exit $ac_status); }; } &&
9148          { ac_try='test -s conftest.$ac_objext'
9149   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9150   (eval $ac_try) 2>&5
9151   ac_status=$?
9152   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9153   (exit $ac_status); }; }; then
9154   ac_cv_type_char=yes
9155 else
9156   echo "$as_me: failed program was:" >&5
9157 sed 's/^/| /' conftest.$ac_ext >&5
9158
9159 ac_cv_type_char=no
9160 fi
9161 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9162 fi
9163 echo "$as_me:$LINENO: result: $ac_cv_type_char" >&5
9164 echo "${ECHO_T}$ac_cv_type_char" >&6
9165
9166 echo "$as_me:$LINENO: checking size of char" >&5
9167 echo $ECHO_N "checking size of char... $ECHO_C" >&6
9168 if test "${ac_cv_sizeof_char+set}" = set; then
9169   echo $ECHO_N "(cached) $ECHO_C" >&6
9170 else
9171   if test "$ac_cv_type_char" = yes; then
9172   # The cast to unsigned long works around a bug in the HP C Compiler
9173   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
9174   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
9175   # This bug is HP SR number 8606223364.
9176   if test "$cross_compiling" = yes; then
9177   # Depending upon the size, compute the lo and hi bounds.
9178 cat >conftest.$ac_ext <<_ACEOF
9179 /* confdefs.h.  */
9180 _ACEOF
9181 cat confdefs.h >>conftest.$ac_ext
9182 cat >>conftest.$ac_ext <<_ACEOF
9183 /* end confdefs.h.  */
9184 $ac_includes_default
9185 int
9186 main ()
9187 {
9188 static int test_array [1 - 2 * !(((long) (sizeof (char))) >= 0)];
9189 test_array [0] = 0
9190
9191   ;
9192   return 0;
9193 }
9194 _ACEOF
9195 rm -f conftest.$ac_objext
9196 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9197   (eval $ac_compile) 2>conftest.er1
9198   ac_status=$?
9199   grep -v '^ *+' conftest.er1 >conftest.err
9200   rm -f conftest.er1
9201   cat conftest.err >&5
9202   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9203   (exit $ac_status); } &&
9204          { ac_try='test -z "$ac_c_werror_flag"
9205                          || test ! -s conftest.err'
9206   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9207   (eval $ac_try) 2>&5
9208   ac_status=$?
9209   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9210   (exit $ac_status); }; } &&
9211          { ac_try='test -s conftest.$ac_objext'
9212   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9213   (eval $ac_try) 2>&5
9214   ac_status=$?
9215   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9216   (exit $ac_status); }; }; then
9217   ac_lo=0 ac_mid=0
9218   while :; do
9219     cat >conftest.$ac_ext <<_ACEOF
9220 /* confdefs.h.  */
9221 _ACEOF
9222 cat confdefs.h >>conftest.$ac_ext
9223 cat >>conftest.$ac_ext <<_ACEOF
9224 /* end confdefs.h.  */
9225 $ac_includes_default
9226 int
9227 main ()
9228 {
9229 static int test_array [1 - 2 * !(((long) (sizeof (char))) <= $ac_mid)];
9230 test_array [0] = 0
9231
9232   ;
9233   return 0;
9234 }
9235 _ACEOF
9236 rm -f conftest.$ac_objext
9237 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9238   (eval $ac_compile) 2>conftest.er1
9239   ac_status=$?
9240   grep -v '^ *+' conftest.er1 >conftest.err
9241   rm -f conftest.er1
9242   cat conftest.err >&5
9243   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9244   (exit $ac_status); } &&
9245          { ac_try='test -z "$ac_c_werror_flag"
9246                          || test ! -s conftest.err'
9247   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9248   (eval $ac_try) 2>&5
9249   ac_status=$?
9250   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9251   (exit $ac_status); }; } &&
9252          { ac_try='test -s conftest.$ac_objext'
9253   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9254   (eval $ac_try) 2>&5
9255   ac_status=$?
9256   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9257   (exit $ac_status); }; }; then
9258   ac_hi=$ac_mid; break
9259 else
9260   echo "$as_me: failed program was:" >&5
9261 sed 's/^/| /' conftest.$ac_ext >&5
9262
9263 ac_lo=`expr $ac_mid + 1`
9264                     if test $ac_lo -le $ac_mid; then
9265                       ac_lo= ac_hi=
9266                       break
9267                     fi
9268                     ac_mid=`expr 2 '*' $ac_mid + 1`
9269 fi
9270 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9271   done
9272 else
9273   echo "$as_me: failed program was:" >&5
9274 sed 's/^/| /' conftest.$ac_ext >&5
9275
9276 cat >conftest.$ac_ext <<_ACEOF
9277 /* confdefs.h.  */
9278 _ACEOF
9279 cat confdefs.h >>conftest.$ac_ext
9280 cat >>conftest.$ac_ext <<_ACEOF
9281 /* end confdefs.h.  */
9282 $ac_includes_default
9283 int
9284 main ()
9285 {
9286 static int test_array [1 - 2 * !(((long) (sizeof (char))) < 0)];
9287 test_array [0] = 0
9288
9289   ;
9290   return 0;
9291 }
9292 _ACEOF
9293 rm -f conftest.$ac_objext
9294 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9295   (eval $ac_compile) 2>conftest.er1
9296   ac_status=$?
9297   grep -v '^ *+' conftest.er1 >conftest.err
9298   rm -f conftest.er1
9299   cat conftest.err >&5
9300   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9301   (exit $ac_status); } &&
9302          { ac_try='test -z "$ac_c_werror_flag"
9303                          || test ! -s conftest.err'
9304   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9305   (eval $ac_try) 2>&5
9306   ac_status=$?
9307   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9308   (exit $ac_status); }; } &&
9309          { ac_try='test -s conftest.$ac_objext'
9310   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9311   (eval $ac_try) 2>&5
9312   ac_status=$?
9313   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9314   (exit $ac_status); }; }; then
9315   ac_hi=-1 ac_mid=-1
9316   while :; do
9317     cat >conftest.$ac_ext <<_ACEOF
9318 /* confdefs.h.  */
9319 _ACEOF
9320 cat confdefs.h >>conftest.$ac_ext
9321 cat >>conftest.$ac_ext <<_ACEOF
9322 /* end confdefs.h.  */
9323 $ac_includes_default
9324 int
9325 main ()
9326 {
9327 static int test_array [1 - 2 * !(((long) (sizeof (char))) >= $ac_mid)];
9328 test_array [0] = 0
9329
9330   ;
9331   return 0;
9332 }
9333 _ACEOF
9334 rm -f conftest.$ac_objext
9335 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9336   (eval $ac_compile) 2>conftest.er1
9337   ac_status=$?
9338   grep -v '^ *+' conftest.er1 >conftest.err
9339   rm -f conftest.er1
9340   cat conftest.err >&5
9341   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9342   (exit $ac_status); } &&
9343          { ac_try='test -z "$ac_c_werror_flag"
9344                          || test ! -s conftest.err'
9345   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9346   (eval $ac_try) 2>&5
9347   ac_status=$?
9348   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9349   (exit $ac_status); }; } &&
9350          { ac_try='test -s conftest.$ac_objext'
9351   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9352   (eval $ac_try) 2>&5
9353   ac_status=$?
9354   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9355   (exit $ac_status); }; }; then
9356   ac_lo=$ac_mid; break
9357 else
9358   echo "$as_me: failed program was:" >&5
9359 sed 's/^/| /' conftest.$ac_ext >&5
9360
9361 ac_hi=`expr '(' $ac_mid ')' - 1`
9362                        if test $ac_mid -le $ac_hi; then
9363                          ac_lo= ac_hi=
9364                          break
9365                        fi
9366                        ac_mid=`expr 2 '*' $ac_mid`
9367 fi
9368 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9369   done
9370 else
9371   echo "$as_me: failed program was:" >&5
9372 sed 's/^/| /' conftest.$ac_ext >&5
9373
9374 ac_lo= ac_hi=
9375 fi
9376 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9377 fi
9378 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9379 # Binary search between lo and hi bounds.
9380 while test "x$ac_lo" != "x$ac_hi"; do
9381   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
9382   cat >conftest.$ac_ext <<_ACEOF
9383 /* confdefs.h.  */
9384 _ACEOF
9385 cat confdefs.h >>conftest.$ac_ext
9386 cat >>conftest.$ac_ext <<_ACEOF
9387 /* end confdefs.h.  */
9388 $ac_includes_default
9389 int
9390 main ()
9391 {
9392 static int test_array [1 - 2 * !(((long) (sizeof (char))) <= $ac_mid)];
9393 test_array [0] = 0
9394
9395   ;
9396   return 0;
9397 }
9398 _ACEOF
9399 rm -f conftest.$ac_objext
9400 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9401   (eval $ac_compile) 2>conftest.er1
9402   ac_status=$?
9403   grep -v '^ *+' conftest.er1 >conftest.err
9404   rm -f conftest.er1
9405   cat conftest.err >&5
9406   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9407   (exit $ac_status); } &&
9408          { ac_try='test -z "$ac_c_werror_flag"
9409                          || test ! -s conftest.err'
9410   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9411   (eval $ac_try) 2>&5
9412   ac_status=$?
9413   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9414   (exit $ac_status); }; } &&
9415          { ac_try='test -s conftest.$ac_objext'
9416   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9417   (eval $ac_try) 2>&5
9418   ac_status=$?
9419   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9420   (exit $ac_status); }; }; then
9421   ac_hi=$ac_mid
9422 else
9423   echo "$as_me: failed program was:" >&5
9424 sed 's/^/| /' conftest.$ac_ext >&5
9425
9426 ac_lo=`expr '(' $ac_mid ')' + 1`
9427 fi
9428 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9429 done
9430 case $ac_lo in
9431 ?*) ac_cv_sizeof_char=$ac_lo;;
9432 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (char), 77
9433 See \`config.log' for more details." >&5
9434 echo "$as_me: error: cannot compute sizeof (char), 77
9435 See \`config.log' for more details." >&2;}
9436    { (exit 1); exit 1; }; } ;;
9437 esac
9438 else
9439   if test "$cross_compiling" = yes; then
9440   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
9441 See \`config.log' for more details." >&5
9442 echo "$as_me: error: cannot run test program while cross compiling
9443 See \`config.log' for more details." >&2;}
9444    { (exit 1); exit 1; }; }
9445 else
9446   cat >conftest.$ac_ext <<_ACEOF
9447 /* confdefs.h.  */
9448 _ACEOF
9449 cat confdefs.h >>conftest.$ac_ext
9450 cat >>conftest.$ac_ext <<_ACEOF
9451 /* end confdefs.h.  */
9452 $ac_includes_default
9453 long longval () { return (long) (sizeof (char)); }
9454 unsigned long ulongval () { return (long) (sizeof (char)); }
9455 #include <stdio.h>
9456 #include <stdlib.h>
9457 int
9458 main ()
9459 {
9460
9461   FILE *f = fopen ("conftest.val", "w");
9462   if (! f)
9463     exit (1);
9464   if (((long) (sizeof (char))) < 0)
9465     {
9466       long i = longval ();
9467       if (i != ((long) (sizeof (char))))
9468         exit (1);
9469       fprintf (f, "%ld\n", i);
9470     }
9471   else
9472     {
9473       unsigned long i = ulongval ();
9474       if (i != ((long) (sizeof (char))))
9475         exit (1);
9476       fprintf (f, "%lu\n", i);
9477     }
9478   exit (ferror (f) || fclose (f) != 0);
9479
9480   ;
9481   return 0;
9482 }
9483 _ACEOF
9484 rm -f conftest$ac_exeext
9485 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9486   (eval $ac_link) 2>&5
9487   ac_status=$?
9488   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9489   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9490   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9491   (eval $ac_try) 2>&5
9492   ac_status=$?
9493   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9494   (exit $ac_status); }; }; then
9495   ac_cv_sizeof_char=`cat conftest.val`
9496 else
9497   echo "$as_me: program exited with status $ac_status" >&5
9498 echo "$as_me: failed program was:" >&5
9499 sed 's/^/| /' conftest.$ac_ext >&5
9500
9501 ( exit $ac_status )
9502 { { echo "$as_me:$LINENO: error: cannot compute sizeof (char), 77
9503 See \`config.log' for more details." >&5
9504 echo "$as_me: error: cannot compute sizeof (char), 77
9505 See \`config.log' for more details." >&2;}
9506    { (exit 1); exit 1; }; }
9507 fi
9508 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9509 fi
9510 fi
9511 rm -f conftest.val
9512 else
9513   ac_cv_sizeof_char=0
9514 fi
9515 fi
9516 echo "$as_me:$LINENO: result: $ac_cv_sizeof_char" >&5
9517 echo "${ECHO_T}$ac_cv_sizeof_char" >&6
9518 cat >>confdefs.h <<_ACEOF
9519 #define SIZEOF_CHAR $ac_cv_sizeof_char
9520 _ACEOF
9521
9522
9523
9524   echo "$as_me:$LINENO: checking for type equivalent to int8_t" >&5
9525 echo $ECHO_N "checking for type equivalent to int8_t... $ECHO_C" >&6
9526   case "$ac_cv_sizeof_char" in
9527     1) acx_cv_type_int8_t=char ;;
9528     *) { { echo "$as_me:$LINENO: error: no 8-bit type" >&5
9529 echo "$as_me: error: no 8-bit type" >&2;}
9530    { (exit please report a bug); exit please report a bug; }; }
9531   esac
9532   echo "$as_me:$LINENO: result: $acx_cv_type_int8_t" >&5
9533 echo "${ECHO_T}$acx_cv_type_int8_t" >&6
9534
9535   echo "$as_me:$LINENO: checking for type equivalent to int16_t" >&5
9536 echo $ECHO_N "checking for type equivalent to int16_t... $ECHO_C" >&6
9537   case "$ac_cv_sizeof_int:$ac_cv_sizeof_short" in
9538     2:*) acx_cv_type_int16_t=int ;;
9539     *:2) acx_cv_type_int16_t=short ;;
9540     *) { { echo "$as_me:$LINENO: error: no 16-bit type" >&5
9541 echo "$as_me: error: no 16-bit type" >&2;}
9542    { (exit please report a bug); exit please report a bug; }; }
9543   esac
9544   echo "$as_me:$LINENO: result: $acx_cv_type_int16_t" >&5
9545 echo "${ECHO_T}$acx_cv_type_int16_t" >&6
9546
9547   echo "$as_me:$LINENO: checking for type equivalent to int32_t" >&5
9548 echo $ECHO_N "checking for type equivalent to int32_t... $ECHO_C" >&6
9549   case "$ac_cv_sizeof_int:$ac_cv_sizeof_long" in
9550     4:*) acx_cv_type_int32_t=int ;;
9551     *:4) acx_cv_type_int32_t=long ;;
9552     *) { { echo "$as_me:$LINENO: error: no 32-bit type" >&5
9553 echo "$as_me: error: no 32-bit type" >&2;}
9554    { (exit please report a bug); exit please report a bug; }; }
9555   esac
9556   echo "$as_me:$LINENO: result: $acx_cv_type_int32_t" >&5
9557 echo "${ECHO_T}$acx_cv_type_int32_t" >&6
9558 fi
9559
9560 # These tests are here to make the output prettier
9561
9562 if test "$ac_cv_type_uint64_t" != yes && test "$ac_cv_type_u_int64_t" != yes; then
9563   case "$ac_cv_sizeof_long" in
9564     8) acx_cv_type_int64_t=long ;;
9565   esac
9566   echo "$as_me:$LINENO: checking for type equivalent to int64_t" >&5
9567 echo $ECHO_N "checking for type equivalent to int64_t... $ECHO_C" >&6
9568   echo "$as_me:$LINENO: result: ${acx_cv_type_int64_t-'using preprocessor symbols'}" >&5
9569 echo "${ECHO_T}${acx_cv_type_int64_t-'using preprocessor symbols'}" >&6
9570 fi
9571
9572 # Now we can use the above types
9573
9574 if test "$ac_cv_type_uintptr_t" != yes; then
9575   echo "$as_me:$LINENO: checking for type equivalent to intptr_t" >&5
9576 echo $ECHO_N "checking for type equivalent to intptr_t... $ECHO_C" >&6
9577   case $ac_cv_sizeof_void_p in
9578     2) acx_cv_type_intptr_t=int16_t ;;
9579     4) acx_cv_type_intptr_t=int32_t ;;
9580     8) acx_cv_type_intptr_t=int64_t ;;
9581     *) { { echo "$as_me:$LINENO: error: no equivalent for intptr_t" >&5
9582 echo "$as_me: error: no equivalent for intptr_t" >&2;}
9583    { (exit please report a bug); exit please report a bug; }; }
9584   esac
9585   echo "$as_me:$LINENO: result: $acx_cv_type_intptr_t" >&5
9586 echo "${ECHO_T}$acx_cv_type_intptr_t" >&6
9587 fi
9588
9589 # ----------------- done all checks, emit header -------------
9590           ac_config_commands="$ac_config_commands gstdint.h"
9591
9592
9593
9594
9595 echo "$as_me:$LINENO: checking for struct stat.st_blksize" >&5
9596 echo $ECHO_N "checking for struct stat.st_blksize... $ECHO_C" >&6
9597 if test "${ac_cv_member_struct_stat_st_blksize+set}" = set; then
9598   echo $ECHO_N "(cached) $ECHO_C" >&6
9599 else
9600   cat >conftest.$ac_ext <<_ACEOF
9601 /* confdefs.h.  */
9602 _ACEOF
9603 cat confdefs.h >>conftest.$ac_ext
9604 cat >>conftest.$ac_ext <<_ACEOF
9605 /* end confdefs.h.  */
9606 $ac_includes_default
9607 int
9608 main ()
9609 {
9610 static struct stat ac_aggr;
9611 if (ac_aggr.st_blksize)
9612 return 0;
9613   ;
9614   return 0;
9615 }
9616 _ACEOF
9617 rm -f conftest.$ac_objext
9618 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9619   (eval $ac_compile) 2>conftest.er1
9620   ac_status=$?
9621   grep -v '^ *+' conftest.er1 >conftest.err
9622   rm -f conftest.er1
9623   cat conftest.err >&5
9624   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9625   (exit $ac_status); } &&
9626          { ac_try='test -z "$ac_c_werror_flag"
9627                          || test ! -s conftest.err'
9628   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9629   (eval $ac_try) 2>&5
9630   ac_status=$?
9631   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9632   (exit $ac_status); }; } &&
9633          { ac_try='test -s conftest.$ac_objext'
9634   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9635   (eval $ac_try) 2>&5
9636   ac_status=$?
9637   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9638   (exit $ac_status); }; }; then
9639   ac_cv_member_struct_stat_st_blksize=yes
9640 else
9641   echo "$as_me: failed program was:" >&5
9642 sed 's/^/| /' conftest.$ac_ext >&5
9643
9644 cat >conftest.$ac_ext <<_ACEOF
9645 /* confdefs.h.  */
9646 _ACEOF
9647 cat confdefs.h >>conftest.$ac_ext
9648 cat >>conftest.$ac_ext <<_ACEOF
9649 /* end confdefs.h.  */
9650 $ac_includes_default
9651 int
9652 main ()
9653 {
9654 static struct stat ac_aggr;
9655 if (sizeof ac_aggr.st_blksize)
9656 return 0;
9657   ;
9658   return 0;
9659 }
9660 _ACEOF
9661 rm -f conftest.$ac_objext
9662 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9663   (eval $ac_compile) 2>conftest.er1
9664   ac_status=$?
9665   grep -v '^ *+' conftest.er1 >conftest.err
9666   rm -f conftest.er1
9667   cat conftest.err >&5
9668   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9669   (exit $ac_status); } &&
9670          { ac_try='test -z "$ac_c_werror_flag"
9671                          || test ! -s conftest.err'
9672   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9673   (eval $ac_try) 2>&5
9674   ac_status=$?
9675   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9676   (exit $ac_status); }; } &&
9677          { ac_try='test -s conftest.$ac_objext'
9678   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9679   (eval $ac_try) 2>&5
9680   ac_status=$?
9681   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9682   (exit $ac_status); }; }; then
9683   ac_cv_member_struct_stat_st_blksize=yes
9684 else
9685   echo "$as_me: failed program was:" >&5
9686 sed 's/^/| /' conftest.$ac_ext >&5
9687
9688 ac_cv_member_struct_stat_st_blksize=no
9689 fi
9690 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9691 fi
9692 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9693 fi
9694 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blksize" >&5
9695 echo "${ECHO_T}$ac_cv_member_struct_stat_st_blksize" >&6
9696 if test $ac_cv_member_struct_stat_st_blksize = yes; then
9697
9698 cat >>confdefs.h <<_ACEOF
9699 #define HAVE_STRUCT_STAT_ST_BLKSIZE 1
9700 _ACEOF
9701
9702
9703 fi
9704
9705 echo "$as_me:$LINENO: checking for struct stat.st_blocks" >&5
9706 echo $ECHO_N "checking for struct stat.st_blocks... $ECHO_C" >&6
9707 if test "${ac_cv_member_struct_stat_st_blocks+set}" = set; then
9708   echo $ECHO_N "(cached) $ECHO_C" >&6
9709 else
9710   cat >conftest.$ac_ext <<_ACEOF
9711 /* confdefs.h.  */
9712 _ACEOF
9713 cat confdefs.h >>conftest.$ac_ext
9714 cat >>conftest.$ac_ext <<_ACEOF
9715 /* end confdefs.h.  */
9716 $ac_includes_default
9717 int
9718 main ()
9719 {
9720 static struct stat ac_aggr;
9721 if (ac_aggr.st_blocks)
9722 return 0;
9723   ;
9724   return 0;
9725 }
9726 _ACEOF
9727 rm -f conftest.$ac_objext
9728 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9729   (eval $ac_compile) 2>conftest.er1
9730   ac_status=$?
9731   grep -v '^ *+' conftest.er1 >conftest.err
9732   rm -f conftest.er1
9733   cat conftest.err >&5
9734   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9735   (exit $ac_status); } &&
9736          { ac_try='test -z "$ac_c_werror_flag"
9737                          || test ! -s conftest.err'
9738   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9739   (eval $ac_try) 2>&5
9740   ac_status=$?
9741   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9742   (exit $ac_status); }; } &&
9743          { ac_try='test -s conftest.$ac_objext'
9744   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9745   (eval $ac_try) 2>&5
9746   ac_status=$?
9747   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9748   (exit $ac_status); }; }; then
9749   ac_cv_member_struct_stat_st_blocks=yes
9750 else
9751   echo "$as_me: failed program was:" >&5
9752 sed 's/^/| /' conftest.$ac_ext >&5
9753
9754 cat >conftest.$ac_ext <<_ACEOF
9755 /* confdefs.h.  */
9756 _ACEOF
9757 cat confdefs.h >>conftest.$ac_ext
9758 cat >>conftest.$ac_ext <<_ACEOF
9759 /* end confdefs.h.  */
9760 $ac_includes_default
9761 int
9762 main ()
9763 {
9764 static struct stat ac_aggr;
9765 if (sizeof ac_aggr.st_blocks)
9766 return 0;
9767   ;
9768   return 0;
9769 }
9770 _ACEOF
9771 rm -f conftest.$ac_objext
9772 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9773   (eval $ac_compile) 2>conftest.er1
9774   ac_status=$?
9775   grep -v '^ *+' conftest.er1 >conftest.err
9776   rm -f conftest.er1
9777   cat conftest.err >&5
9778   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9779   (exit $ac_status); } &&
9780          { ac_try='test -z "$ac_c_werror_flag"
9781                          || test ! -s conftest.err'
9782   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9783   (eval $ac_try) 2>&5
9784   ac_status=$?
9785   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9786   (exit $ac_status); }; } &&
9787          { ac_try='test -s conftest.$ac_objext'
9788   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9789   (eval $ac_try) 2>&5
9790   ac_status=$?
9791   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9792   (exit $ac_status); }; }; then
9793   ac_cv_member_struct_stat_st_blocks=yes
9794 else
9795   echo "$as_me: failed program was:" >&5
9796 sed 's/^/| /' conftest.$ac_ext >&5
9797
9798 ac_cv_member_struct_stat_st_blocks=no
9799 fi
9800 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9801 fi
9802 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9803 fi
9804 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blocks" >&5
9805 echo "${ECHO_T}$ac_cv_member_struct_stat_st_blocks" >&6
9806 if test $ac_cv_member_struct_stat_st_blocks = yes; then
9807
9808 cat >>confdefs.h <<_ACEOF
9809 #define HAVE_STRUCT_STAT_ST_BLOCKS 1
9810 _ACEOF
9811
9812
9813 fi
9814
9815 echo "$as_me:$LINENO: checking for struct stat.st_rdev" >&5
9816 echo $ECHO_N "checking for struct stat.st_rdev... $ECHO_C" >&6
9817 if test "${ac_cv_member_struct_stat_st_rdev+set}" = set; then
9818   echo $ECHO_N "(cached) $ECHO_C" >&6
9819 else
9820   cat >conftest.$ac_ext <<_ACEOF
9821 /* confdefs.h.  */
9822 _ACEOF
9823 cat confdefs.h >>conftest.$ac_ext
9824 cat >>conftest.$ac_ext <<_ACEOF
9825 /* end confdefs.h.  */
9826 $ac_includes_default
9827 int
9828 main ()
9829 {
9830 static struct stat ac_aggr;
9831 if (ac_aggr.st_rdev)
9832 return 0;
9833   ;
9834   return 0;
9835 }
9836 _ACEOF
9837 rm -f conftest.$ac_objext
9838 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9839   (eval $ac_compile) 2>conftest.er1
9840   ac_status=$?
9841   grep -v '^ *+' conftest.er1 >conftest.err
9842   rm -f conftest.er1
9843   cat conftest.err >&5
9844   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9845   (exit $ac_status); } &&
9846          { ac_try='test -z "$ac_c_werror_flag"
9847                          || test ! -s conftest.err'
9848   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9849   (eval $ac_try) 2>&5
9850   ac_status=$?
9851   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9852   (exit $ac_status); }; } &&
9853          { ac_try='test -s conftest.$ac_objext'
9854   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9855   (eval $ac_try) 2>&5
9856   ac_status=$?
9857   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9858   (exit $ac_status); }; }; then
9859   ac_cv_member_struct_stat_st_rdev=yes
9860 else
9861   echo "$as_me: failed program was:" >&5
9862 sed 's/^/| /' conftest.$ac_ext >&5
9863
9864 cat >conftest.$ac_ext <<_ACEOF
9865 /* confdefs.h.  */
9866 _ACEOF
9867 cat confdefs.h >>conftest.$ac_ext
9868 cat >>conftest.$ac_ext <<_ACEOF
9869 /* end confdefs.h.  */
9870 $ac_includes_default
9871 int
9872 main ()
9873 {
9874 static struct stat ac_aggr;
9875 if (sizeof ac_aggr.st_rdev)
9876 return 0;
9877   ;
9878   return 0;
9879 }
9880 _ACEOF
9881 rm -f conftest.$ac_objext
9882 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9883   (eval $ac_compile) 2>conftest.er1
9884   ac_status=$?
9885   grep -v '^ *+' conftest.er1 >conftest.err
9886   rm -f conftest.er1
9887   cat conftest.err >&5
9888   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9889   (exit $ac_status); } &&
9890          { ac_try='test -z "$ac_c_werror_flag"
9891                          || test ! -s conftest.err'
9892   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9893   (eval $ac_try) 2>&5
9894   ac_status=$?
9895   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9896   (exit $ac_status); }; } &&
9897          { ac_try='test -s conftest.$ac_objext'
9898   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9899   (eval $ac_try) 2>&5
9900   ac_status=$?
9901   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9902   (exit $ac_status); }; }; then
9903   ac_cv_member_struct_stat_st_rdev=yes
9904 else
9905   echo "$as_me: failed program was:" >&5
9906 sed 's/^/| /' conftest.$ac_ext >&5
9907
9908 ac_cv_member_struct_stat_st_rdev=no
9909 fi
9910 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9911 fi
9912 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9913 fi
9914 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_rdev" >&5
9915 echo "${ECHO_T}$ac_cv_member_struct_stat_st_rdev" >&6
9916 if test $ac_cv_member_struct_stat_st_rdev = yes; then
9917
9918 cat >>confdefs.h <<_ACEOF
9919 #define HAVE_STRUCT_STAT_ST_RDEV 1
9920 _ACEOF
9921
9922
9923 fi
9924
9925
9926 # Check for library functions.
9927
9928
9929
9930
9931
9932
9933
9934
9935 for ac_func in getrusage times mkstemp strtof strtold snprintf ftruncate chsize
9936 do
9937 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9938 echo "$as_me:$LINENO: checking for $ac_func" >&5
9939 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9940 if eval "test \"\${$as_ac_var+set}\" = set"; then
9941   echo $ECHO_N "(cached) $ECHO_C" >&6
9942 else
9943   if test x$gcc_no_link = xyes; then
9944   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9945 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9946    { (exit 1); exit 1; }; }
9947 fi
9948 cat >conftest.$ac_ext <<_ACEOF
9949 /* confdefs.h.  */
9950 _ACEOF
9951 cat confdefs.h >>conftest.$ac_ext
9952 cat >>conftest.$ac_ext <<_ACEOF
9953 /* end confdefs.h.  */
9954 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9955    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9956 #define $ac_func innocuous_$ac_func
9957
9958 /* System header to define __stub macros and hopefully few prototypes,
9959     which can conflict with char $ac_func (); below.
9960     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9961     <limits.h> exists even on freestanding compilers.  */
9962
9963 #ifdef __STDC__
9964 # include <limits.h>
9965 #else
9966 # include <assert.h>
9967 #endif
9968
9969 #undef $ac_func
9970
9971 /* Override any gcc2 internal prototype to avoid an error.  */
9972 #ifdef __cplusplus
9973 extern "C"
9974 {
9975 #endif
9976 /* We use char because int might match the return type of a gcc2
9977    builtin and then its argument prototype would still apply.  */
9978 char $ac_func ();
9979 /* The GNU C library defines this for functions which it implements
9980     to always fail with ENOSYS.  Some functions are actually named
9981     something starting with __ and the normal name is an alias.  */
9982 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9983 choke me
9984 #else
9985 char (*f) () = $ac_func;
9986 #endif
9987 #ifdef __cplusplus
9988 }
9989 #endif
9990
9991 int
9992 main ()
9993 {
9994 return f != $ac_func;
9995   ;
9996   return 0;
9997 }
9998 _ACEOF
9999 rm -f conftest.$ac_objext conftest$ac_exeext
10000 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10001   (eval $ac_link) 2>conftest.er1
10002   ac_status=$?
10003   grep -v '^ *+' conftest.er1 >conftest.err
10004   rm -f conftest.er1
10005   cat conftest.err >&5
10006   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10007   (exit $ac_status); } &&
10008          { ac_try='test -z "$ac_c_werror_flag"
10009                          || test ! -s conftest.err'
10010   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10011   (eval $ac_try) 2>&5
10012   ac_status=$?
10013   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10014   (exit $ac_status); }; } &&
10015          { ac_try='test -s conftest$ac_exeext'
10016   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10017   (eval $ac_try) 2>&5
10018   ac_status=$?
10019   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10020   (exit $ac_status); }; }; then
10021   eval "$as_ac_var=yes"
10022 else
10023   echo "$as_me: failed program was:" >&5
10024 sed 's/^/| /' conftest.$ac_ext >&5
10025
10026 eval "$as_ac_var=no"
10027 fi
10028 rm -f conftest.err conftest.$ac_objext \
10029       conftest$ac_exeext conftest.$ac_ext
10030 fi
10031 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10032 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10033 if test `eval echo '${'$as_ac_var'}'` = yes; then
10034   cat >>confdefs.h <<_ACEOF
10035 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10036 _ACEOF
10037
10038 fi
10039 done
10040
10041
10042
10043
10044
10045
10046
10047
10048
10049 for ac_func in chdir strerror getlogin gethostname kill link symlink perror
10050 do
10051 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10052 echo "$as_me:$LINENO: checking for $ac_func" >&5
10053 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10054 if eval "test \"\${$as_ac_var+set}\" = set"; then
10055   echo $ECHO_N "(cached) $ECHO_C" >&6
10056 else
10057   if test x$gcc_no_link = xyes; then
10058   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10059 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10060    { (exit 1); exit 1; }; }
10061 fi
10062 cat >conftest.$ac_ext <<_ACEOF
10063 /* confdefs.h.  */
10064 _ACEOF
10065 cat confdefs.h >>conftest.$ac_ext
10066 cat >>conftest.$ac_ext <<_ACEOF
10067 /* end confdefs.h.  */
10068 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10069    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10070 #define $ac_func innocuous_$ac_func
10071
10072 /* System header to define __stub macros and hopefully few prototypes,
10073     which can conflict with char $ac_func (); below.
10074     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10075     <limits.h> exists even on freestanding compilers.  */
10076
10077 #ifdef __STDC__
10078 # include <limits.h>
10079 #else
10080 # include <assert.h>
10081 #endif
10082
10083 #undef $ac_func
10084
10085 /* Override any gcc2 internal prototype to avoid an error.  */
10086 #ifdef __cplusplus
10087 extern "C"
10088 {
10089 #endif
10090 /* We use char because int might match the return type of a gcc2
10091    builtin and then its argument prototype would still apply.  */
10092 char $ac_func ();
10093 /* The GNU C library defines this for functions which it implements
10094     to always fail with ENOSYS.  Some functions are actually named
10095     something starting with __ and the normal name is an alias.  */
10096 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10097 choke me
10098 #else
10099 char (*f) () = $ac_func;
10100 #endif
10101 #ifdef __cplusplus
10102 }
10103 #endif
10104
10105 int
10106 main ()
10107 {
10108 return f != $ac_func;
10109   ;
10110   return 0;
10111 }
10112 _ACEOF
10113 rm -f conftest.$ac_objext conftest$ac_exeext
10114 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10115   (eval $ac_link) 2>conftest.er1
10116   ac_status=$?
10117   grep -v '^ *+' conftest.er1 >conftest.err
10118   rm -f conftest.er1
10119   cat conftest.err >&5
10120   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10121   (exit $ac_status); } &&
10122          { ac_try='test -z "$ac_c_werror_flag"
10123                          || test ! -s conftest.err'
10124   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10125   (eval $ac_try) 2>&5
10126   ac_status=$?
10127   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10128   (exit $ac_status); }; } &&
10129          { ac_try='test -s conftest$ac_exeext'
10130   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10131   (eval $ac_try) 2>&5
10132   ac_status=$?
10133   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10134   (exit $ac_status); }; }; then
10135   eval "$as_ac_var=yes"
10136 else
10137   echo "$as_me: failed program was:" >&5
10138 sed 's/^/| /' conftest.$ac_ext >&5
10139
10140 eval "$as_ac_var=no"
10141 fi
10142 rm -f conftest.err conftest.$ac_objext \
10143       conftest$ac_exeext conftest.$ac_ext
10144 fi
10145 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10146 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10147 if test `eval echo '${'$as_ac_var'}'` = yes; then
10148   cat >>confdefs.h <<_ACEOF
10149 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10150 _ACEOF
10151
10152 fi
10153 done
10154
10155
10156
10157
10158
10159
10160
10161
10162
10163
10164
10165 for ac_func in sleep time ttyname signal alarm ctime clock access fork execl
10166 do
10167 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10168 echo "$as_me:$LINENO: checking for $ac_func" >&5
10169 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10170 if eval "test \"\${$as_ac_var+set}\" = set"; then
10171   echo $ECHO_N "(cached) $ECHO_C" >&6
10172 else
10173   if test x$gcc_no_link = xyes; then
10174   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10175 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10176    { (exit 1); exit 1; }; }
10177 fi
10178 cat >conftest.$ac_ext <<_ACEOF
10179 /* confdefs.h.  */
10180 _ACEOF
10181 cat confdefs.h >>conftest.$ac_ext
10182 cat >>conftest.$ac_ext <<_ACEOF
10183 /* end confdefs.h.  */
10184 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10185    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10186 #define $ac_func innocuous_$ac_func
10187
10188 /* System header to define __stub macros and hopefully few prototypes,
10189     which can conflict with char $ac_func (); below.
10190     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10191     <limits.h> exists even on freestanding compilers.  */
10192
10193 #ifdef __STDC__
10194 # include <limits.h>
10195 #else
10196 # include <assert.h>
10197 #endif
10198
10199 #undef $ac_func
10200
10201 /* Override any gcc2 internal prototype to avoid an error.  */
10202 #ifdef __cplusplus
10203 extern "C"
10204 {
10205 #endif
10206 /* We use char because int might match the return type of a gcc2
10207    builtin and then its argument prototype would still apply.  */
10208 char $ac_func ();
10209 /* The GNU C library defines this for functions which it implements
10210     to always fail with ENOSYS.  Some functions are actually named
10211     something starting with __ and the normal name is an alias.  */
10212 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10213 choke me
10214 #else
10215 char (*f) () = $ac_func;
10216 #endif
10217 #ifdef __cplusplus
10218 }
10219 #endif
10220
10221 int
10222 main ()
10223 {
10224 return f != $ac_func;
10225   ;
10226   return 0;
10227 }
10228 _ACEOF
10229 rm -f conftest.$ac_objext conftest$ac_exeext
10230 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10231   (eval $ac_link) 2>conftest.er1
10232   ac_status=$?
10233   grep -v '^ *+' conftest.er1 >conftest.err
10234   rm -f conftest.er1
10235   cat conftest.err >&5
10236   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10237   (exit $ac_status); } &&
10238          { ac_try='test -z "$ac_c_werror_flag"
10239                          || test ! -s conftest.err'
10240   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10241   (eval $ac_try) 2>&5
10242   ac_status=$?
10243   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10244   (exit $ac_status); }; } &&
10245          { ac_try='test -s conftest$ac_exeext'
10246   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10247   (eval $ac_try) 2>&5
10248   ac_status=$?
10249   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10250   (exit $ac_status); }; }; then
10251   eval "$as_ac_var=yes"
10252 else
10253   echo "$as_me: failed program was:" >&5
10254 sed 's/^/| /' conftest.$ac_ext >&5
10255
10256 eval "$as_ac_var=no"
10257 fi
10258 rm -f conftest.err conftest.$ac_objext \
10259       conftest$ac_exeext conftest.$ac_ext
10260 fi
10261 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10262 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10263 if test `eval echo '${'$as_ac_var'}'` = yes; then
10264   cat >>confdefs.h <<_ACEOF
10265 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10266 _ACEOF
10267
10268 fi
10269 done
10270
10271
10272
10273 for ac_func in wait setmode
10274 do
10275 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10276 echo "$as_me:$LINENO: checking for $ac_func" >&5
10277 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10278 if eval "test \"\${$as_ac_var+set}\" = set"; then
10279   echo $ECHO_N "(cached) $ECHO_C" >&6
10280 else
10281   if test x$gcc_no_link = xyes; then
10282   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10283 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10284    { (exit 1); exit 1; }; }
10285 fi
10286 cat >conftest.$ac_ext <<_ACEOF
10287 /* confdefs.h.  */
10288 _ACEOF
10289 cat confdefs.h >>conftest.$ac_ext
10290 cat >>conftest.$ac_ext <<_ACEOF
10291 /* end confdefs.h.  */
10292 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10293    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10294 #define $ac_func innocuous_$ac_func
10295
10296 /* System header to define __stub macros and hopefully few prototypes,
10297     which can conflict with char $ac_func (); below.
10298     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10299     <limits.h> exists even on freestanding compilers.  */
10300
10301 #ifdef __STDC__
10302 # include <limits.h>
10303 #else
10304 # include <assert.h>
10305 #endif
10306
10307 #undef $ac_func
10308
10309 /* Override any gcc2 internal prototype to avoid an error.  */
10310 #ifdef __cplusplus
10311 extern "C"
10312 {
10313 #endif
10314 /* We use char because int might match the return type of a gcc2
10315    builtin and then its argument prototype would still apply.  */
10316 char $ac_func ();
10317 /* The GNU C library defines this for functions which it implements
10318     to always fail with ENOSYS.  Some functions are actually named
10319     something starting with __ and the normal name is an alias.  */
10320 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10321 choke me
10322 #else
10323 char (*f) () = $ac_func;
10324 #endif
10325 #ifdef __cplusplus
10326 }
10327 #endif
10328
10329 int
10330 main ()
10331 {
10332 return f != $ac_func;
10333   ;
10334   return 0;
10335 }
10336 _ACEOF
10337 rm -f conftest.$ac_objext conftest$ac_exeext
10338 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10339   (eval $ac_link) 2>conftest.er1
10340   ac_status=$?
10341   grep -v '^ *+' conftest.er1 >conftest.err
10342   rm -f conftest.er1
10343   cat conftest.err >&5
10344   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10345   (exit $ac_status); } &&
10346          { ac_try='test -z "$ac_c_werror_flag"
10347                          || test ! -s conftest.err'
10348   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10349   (eval $ac_try) 2>&5
10350   ac_status=$?
10351   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10352   (exit $ac_status); }; } &&
10353          { ac_try='test -s conftest$ac_exeext'
10354   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10355   (eval $ac_try) 2>&5
10356   ac_status=$?
10357   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10358   (exit $ac_status); }; }; then
10359   eval "$as_ac_var=yes"
10360 else
10361   echo "$as_me: failed program was:" >&5
10362 sed 's/^/| /' conftest.$ac_ext >&5
10363
10364 eval "$as_ac_var=no"
10365 fi
10366 rm -f conftest.err conftest.$ac_objext \
10367       conftest$ac_exeext conftest.$ac_ext
10368 fi
10369 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10370 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10371 if test `eval echo '${'$as_ac_var'}'` = yes; then
10372   cat >>confdefs.h <<_ACEOF
10373 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10374 _ACEOF
10375
10376 fi
10377 done
10378
10379
10380 # Check for types
10381 echo "$as_me:$LINENO: checking for intptr_t" >&5
10382 echo $ECHO_N "checking for intptr_t... $ECHO_C" >&6
10383 if test "${ac_cv_type_intptr_t+set}" = set; then
10384   echo $ECHO_N "(cached) $ECHO_C" >&6
10385 else
10386   cat >conftest.$ac_ext <<_ACEOF
10387 /* confdefs.h.  */
10388 _ACEOF
10389 cat confdefs.h >>conftest.$ac_ext
10390 cat >>conftest.$ac_ext <<_ACEOF
10391 /* end confdefs.h.  */
10392 $ac_includes_default
10393 int
10394 main ()
10395 {
10396 if ((intptr_t *) 0)
10397   return 0;
10398 if (sizeof (intptr_t))
10399   return 0;
10400   ;
10401   return 0;
10402 }
10403 _ACEOF
10404 rm -f conftest.$ac_objext
10405 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10406   (eval $ac_compile) 2>conftest.er1
10407   ac_status=$?
10408   grep -v '^ *+' conftest.er1 >conftest.err
10409   rm -f conftest.er1
10410   cat conftest.err >&5
10411   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10412   (exit $ac_status); } &&
10413          { ac_try='test -z "$ac_c_werror_flag"
10414                          || test ! -s conftest.err'
10415   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10416   (eval $ac_try) 2>&5
10417   ac_status=$?
10418   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10419   (exit $ac_status); }; } &&
10420          { ac_try='test -s conftest.$ac_objext'
10421   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10422   (eval $ac_try) 2>&5
10423   ac_status=$?
10424   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10425   (exit $ac_status); }; }; then
10426   ac_cv_type_intptr_t=yes
10427 else
10428   echo "$as_me: failed program was:" >&5
10429 sed 's/^/| /' conftest.$ac_ext >&5
10430
10431 ac_cv_type_intptr_t=no
10432 fi
10433 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10434 fi
10435 echo "$as_me:$LINENO: result: $ac_cv_type_intptr_t" >&5
10436 echo "${ECHO_T}$ac_cv_type_intptr_t" >&6
10437 if test $ac_cv_type_intptr_t = yes; then
10438
10439 cat >>confdefs.h <<_ACEOF
10440 #define HAVE_INTPTR_T 1
10441 _ACEOF
10442
10443
10444 fi
10445
10446
10447 # Check libc for getgid, getpid, getuid
10448 echo "$as_me:$LINENO: checking for getgid in -lc" >&5
10449 echo $ECHO_N "checking for getgid in -lc... $ECHO_C" >&6
10450 if test "${ac_cv_lib_c_getgid+set}" = set; then
10451   echo $ECHO_N "(cached) $ECHO_C" >&6
10452 else
10453   ac_check_lib_save_LIBS=$LIBS
10454 LIBS="-lc  $LIBS"
10455 if test x$gcc_no_link = xyes; then
10456   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10457 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10458    { (exit 1); exit 1; }; }
10459 fi
10460 cat >conftest.$ac_ext <<_ACEOF
10461 /* confdefs.h.  */
10462 _ACEOF
10463 cat confdefs.h >>conftest.$ac_ext
10464 cat >>conftest.$ac_ext <<_ACEOF
10465 /* end confdefs.h.  */
10466
10467 /* Override any gcc2 internal prototype to avoid an error.  */
10468 #ifdef __cplusplus
10469 extern "C"
10470 #endif
10471 /* We use char because int might match the return type of a gcc2
10472    builtin and then its argument prototype would still apply.  */
10473 char getgid ();
10474 int
10475 main ()
10476 {
10477 getgid ();
10478   ;
10479   return 0;
10480 }
10481 _ACEOF
10482 rm -f conftest.$ac_objext conftest$ac_exeext
10483 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10484   (eval $ac_link) 2>conftest.er1
10485   ac_status=$?
10486   grep -v '^ *+' conftest.er1 >conftest.err
10487   rm -f conftest.er1
10488   cat conftest.err >&5
10489   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10490   (exit $ac_status); } &&
10491          { ac_try='test -z "$ac_c_werror_flag"
10492                          || test ! -s conftest.err'
10493   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10494   (eval $ac_try) 2>&5
10495   ac_status=$?
10496   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10497   (exit $ac_status); }; } &&
10498          { ac_try='test -s conftest$ac_exeext'
10499   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10500   (eval $ac_try) 2>&5
10501   ac_status=$?
10502   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10503   (exit $ac_status); }; }; then
10504   ac_cv_lib_c_getgid=yes
10505 else
10506   echo "$as_me: failed program was:" >&5
10507 sed 's/^/| /' conftest.$ac_ext >&5
10508
10509 ac_cv_lib_c_getgid=no
10510 fi
10511 rm -f conftest.err conftest.$ac_objext \
10512       conftest$ac_exeext conftest.$ac_ext
10513 LIBS=$ac_check_lib_save_LIBS
10514 fi
10515 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getgid" >&5
10516 echo "${ECHO_T}$ac_cv_lib_c_getgid" >&6
10517 if test $ac_cv_lib_c_getgid = yes; then
10518
10519 cat >>confdefs.h <<\_ACEOF
10520 #define HAVE_GETGID 1
10521 _ACEOF
10522
10523 fi
10524
10525 echo "$as_me:$LINENO: checking for getpid in -lc" >&5
10526 echo $ECHO_N "checking for getpid in -lc... $ECHO_C" >&6
10527 if test "${ac_cv_lib_c_getpid+set}" = set; then
10528   echo $ECHO_N "(cached) $ECHO_C" >&6
10529 else
10530   ac_check_lib_save_LIBS=$LIBS
10531 LIBS="-lc  $LIBS"
10532 if test x$gcc_no_link = xyes; then
10533   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10534 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10535    { (exit 1); exit 1; }; }
10536 fi
10537 cat >conftest.$ac_ext <<_ACEOF
10538 /* confdefs.h.  */
10539 _ACEOF
10540 cat confdefs.h >>conftest.$ac_ext
10541 cat >>conftest.$ac_ext <<_ACEOF
10542 /* end confdefs.h.  */
10543
10544 /* Override any gcc2 internal prototype to avoid an error.  */
10545 #ifdef __cplusplus
10546 extern "C"
10547 #endif
10548 /* We use char because int might match the return type of a gcc2
10549    builtin and then its argument prototype would still apply.  */
10550 char getpid ();
10551 int
10552 main ()
10553 {
10554 getpid ();
10555   ;
10556   return 0;
10557 }
10558 _ACEOF
10559 rm -f conftest.$ac_objext conftest$ac_exeext
10560 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10561   (eval $ac_link) 2>conftest.er1
10562   ac_status=$?
10563   grep -v '^ *+' conftest.er1 >conftest.err
10564   rm -f conftest.er1
10565   cat conftest.err >&5
10566   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10567   (exit $ac_status); } &&
10568          { ac_try='test -z "$ac_c_werror_flag"
10569                          || test ! -s conftest.err'
10570   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10571   (eval $ac_try) 2>&5
10572   ac_status=$?
10573   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10574   (exit $ac_status); }; } &&
10575          { ac_try='test -s conftest$ac_exeext'
10576   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10577   (eval $ac_try) 2>&5
10578   ac_status=$?
10579   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10580   (exit $ac_status); }; }; then
10581   ac_cv_lib_c_getpid=yes
10582 else
10583   echo "$as_me: failed program was:" >&5
10584 sed 's/^/| /' conftest.$ac_ext >&5
10585
10586 ac_cv_lib_c_getpid=no
10587 fi
10588 rm -f conftest.err conftest.$ac_objext \
10589       conftest$ac_exeext conftest.$ac_ext
10590 LIBS=$ac_check_lib_save_LIBS
10591 fi
10592 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getpid" >&5
10593 echo "${ECHO_T}$ac_cv_lib_c_getpid" >&6
10594 if test $ac_cv_lib_c_getpid = yes; then
10595
10596 cat >>confdefs.h <<\_ACEOF
10597 #define HAVE_GETPID 1
10598 _ACEOF
10599
10600 fi
10601
10602 echo "$as_me:$LINENO: checking for getuid in -lc" >&5
10603 echo $ECHO_N "checking for getuid in -lc... $ECHO_C" >&6
10604 if test "${ac_cv_lib_c_getuid+set}" = set; then
10605   echo $ECHO_N "(cached) $ECHO_C" >&6
10606 else
10607   ac_check_lib_save_LIBS=$LIBS
10608 LIBS="-lc  $LIBS"
10609 if test x$gcc_no_link = xyes; then
10610   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10611 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10612    { (exit 1); exit 1; }; }
10613 fi
10614 cat >conftest.$ac_ext <<_ACEOF
10615 /* confdefs.h.  */
10616 _ACEOF
10617 cat confdefs.h >>conftest.$ac_ext
10618 cat >>conftest.$ac_ext <<_ACEOF
10619 /* end confdefs.h.  */
10620
10621 /* Override any gcc2 internal prototype to avoid an error.  */
10622 #ifdef __cplusplus
10623 extern "C"
10624 #endif
10625 /* We use char because int might match the return type of a gcc2
10626    builtin and then its argument prototype would still apply.  */
10627 char getuid ();
10628 int
10629 main ()
10630 {
10631 getuid ();
10632   ;
10633   return 0;
10634 }
10635 _ACEOF
10636 rm -f conftest.$ac_objext conftest$ac_exeext
10637 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10638   (eval $ac_link) 2>conftest.er1
10639   ac_status=$?
10640   grep -v '^ *+' conftest.er1 >conftest.err
10641   rm -f conftest.er1
10642   cat conftest.err >&5
10643   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10644   (exit $ac_status); } &&
10645          { ac_try='test -z "$ac_c_werror_flag"
10646                          || test ! -s conftest.err'
10647   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10648   (eval $ac_try) 2>&5
10649   ac_status=$?
10650   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10651   (exit $ac_status); }; } &&
10652          { ac_try='test -s conftest$ac_exeext'
10653   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10654   (eval $ac_try) 2>&5
10655   ac_status=$?
10656   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10657   (exit $ac_status); }; }; then
10658   ac_cv_lib_c_getuid=yes
10659 else
10660   echo "$as_me: failed program was:" >&5
10661 sed 's/^/| /' conftest.$ac_ext >&5
10662
10663 ac_cv_lib_c_getuid=no
10664 fi
10665 rm -f conftest.err conftest.$ac_objext \
10666       conftest$ac_exeext conftest.$ac_ext
10667 LIBS=$ac_check_lib_save_LIBS
10668 fi
10669 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getuid" >&5
10670 echo "${ECHO_T}$ac_cv_lib_c_getuid" >&6
10671 if test $ac_cv_lib_c_getuid = yes; then
10672
10673 cat >>confdefs.h <<\_ACEOF
10674 #define HAVE_GETUID 1
10675 _ACEOF
10676
10677 fi
10678
10679
10680 # Check for C99 (and other IEEE) math functions
10681 # ??? This list seems awful long. Is there a better way to test for these?
10682 echo "$as_me:$LINENO: checking for acosf in -lm" >&5
10683 echo $ECHO_N "checking for acosf in -lm... $ECHO_C" >&6
10684 if test "${ac_cv_lib_m_acosf+set}" = set; then
10685   echo $ECHO_N "(cached) $ECHO_C" >&6
10686 else
10687   ac_check_lib_save_LIBS=$LIBS
10688 LIBS="-lm  $LIBS"
10689 if test x$gcc_no_link = xyes; then
10690   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10691 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10692    { (exit 1); exit 1; }; }
10693 fi
10694 cat >conftest.$ac_ext <<_ACEOF
10695 /* confdefs.h.  */
10696 _ACEOF
10697 cat confdefs.h >>conftest.$ac_ext
10698 cat >>conftest.$ac_ext <<_ACEOF
10699 /* end confdefs.h.  */
10700
10701 /* Override any gcc2 internal prototype to avoid an error.  */
10702 #ifdef __cplusplus
10703 extern "C"
10704 #endif
10705 /* We use char because int might match the return type of a gcc2
10706    builtin and then its argument prototype would still apply.  */
10707 char acosf ();
10708 int
10709 main ()
10710 {
10711 acosf ();
10712   ;
10713   return 0;
10714 }
10715 _ACEOF
10716 rm -f conftest.$ac_objext conftest$ac_exeext
10717 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10718   (eval $ac_link) 2>conftest.er1
10719   ac_status=$?
10720   grep -v '^ *+' conftest.er1 >conftest.err
10721   rm -f conftest.er1
10722   cat conftest.err >&5
10723   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10724   (exit $ac_status); } &&
10725          { ac_try='test -z "$ac_c_werror_flag"
10726                          || test ! -s conftest.err'
10727   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10728   (eval $ac_try) 2>&5
10729   ac_status=$?
10730   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10731   (exit $ac_status); }; } &&
10732          { ac_try='test -s conftest$ac_exeext'
10733   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10734   (eval $ac_try) 2>&5
10735   ac_status=$?
10736   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10737   (exit $ac_status); }; }; then
10738   ac_cv_lib_m_acosf=yes
10739 else
10740   echo "$as_me: failed program was:" >&5
10741 sed 's/^/| /' conftest.$ac_ext >&5
10742
10743 ac_cv_lib_m_acosf=no
10744 fi
10745 rm -f conftest.err conftest.$ac_objext \
10746       conftest$ac_exeext conftest.$ac_ext
10747 LIBS=$ac_check_lib_save_LIBS
10748 fi
10749 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosf" >&5
10750 echo "${ECHO_T}$ac_cv_lib_m_acosf" >&6
10751 if test $ac_cv_lib_m_acosf = yes; then
10752
10753 cat >>confdefs.h <<\_ACEOF
10754 #define HAVE_ACOSF 1
10755 _ACEOF
10756
10757 fi
10758
10759 echo "$as_me:$LINENO: checking for acos in -lm" >&5
10760 echo $ECHO_N "checking for acos in -lm... $ECHO_C" >&6
10761 if test "${ac_cv_lib_m_acos+set}" = set; then
10762   echo $ECHO_N "(cached) $ECHO_C" >&6
10763 else
10764   ac_check_lib_save_LIBS=$LIBS
10765 LIBS="-lm  $LIBS"
10766 if test x$gcc_no_link = xyes; then
10767   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10768 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10769    { (exit 1); exit 1; }; }
10770 fi
10771 cat >conftest.$ac_ext <<_ACEOF
10772 /* confdefs.h.  */
10773 _ACEOF
10774 cat confdefs.h >>conftest.$ac_ext
10775 cat >>conftest.$ac_ext <<_ACEOF
10776 /* end confdefs.h.  */
10777
10778 /* Override any gcc2 internal prototype to avoid an error.  */
10779 #ifdef __cplusplus
10780 extern "C"
10781 #endif
10782 /* We use char because int might match the return type of a gcc2
10783    builtin and then its argument prototype would still apply.  */
10784 char acos ();
10785 int
10786 main ()
10787 {
10788 acos ();
10789   ;
10790   return 0;
10791 }
10792 _ACEOF
10793 rm -f conftest.$ac_objext conftest$ac_exeext
10794 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10795   (eval $ac_link) 2>conftest.er1
10796   ac_status=$?
10797   grep -v '^ *+' conftest.er1 >conftest.err
10798   rm -f conftest.er1
10799   cat conftest.err >&5
10800   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10801   (exit $ac_status); } &&
10802          { ac_try='test -z "$ac_c_werror_flag"
10803                          || test ! -s conftest.err'
10804   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10805   (eval $ac_try) 2>&5
10806   ac_status=$?
10807   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10808   (exit $ac_status); }; } &&
10809          { ac_try='test -s conftest$ac_exeext'
10810   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10811   (eval $ac_try) 2>&5
10812   ac_status=$?
10813   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10814   (exit $ac_status); }; }; then
10815   ac_cv_lib_m_acos=yes
10816 else
10817   echo "$as_me: failed program was:" >&5
10818 sed 's/^/| /' conftest.$ac_ext >&5
10819
10820 ac_cv_lib_m_acos=no
10821 fi
10822 rm -f conftest.err conftest.$ac_objext \
10823       conftest$ac_exeext conftest.$ac_ext
10824 LIBS=$ac_check_lib_save_LIBS
10825 fi
10826 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acos" >&5
10827 echo "${ECHO_T}$ac_cv_lib_m_acos" >&6
10828 if test $ac_cv_lib_m_acos = yes; then
10829
10830 cat >>confdefs.h <<\_ACEOF
10831 #define HAVE_ACOS 1
10832 _ACEOF
10833
10834 fi
10835
10836 echo "$as_me:$LINENO: checking for acosl in -lm" >&5
10837 echo $ECHO_N "checking for acosl in -lm... $ECHO_C" >&6
10838 if test "${ac_cv_lib_m_acosl+set}" = set; then
10839   echo $ECHO_N "(cached) $ECHO_C" >&6
10840 else
10841   ac_check_lib_save_LIBS=$LIBS
10842 LIBS="-lm  $LIBS"
10843 if test x$gcc_no_link = xyes; then
10844   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10845 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10846    { (exit 1); exit 1; }; }
10847 fi
10848 cat >conftest.$ac_ext <<_ACEOF
10849 /* confdefs.h.  */
10850 _ACEOF
10851 cat confdefs.h >>conftest.$ac_ext
10852 cat >>conftest.$ac_ext <<_ACEOF
10853 /* end confdefs.h.  */
10854
10855 /* Override any gcc2 internal prototype to avoid an error.  */
10856 #ifdef __cplusplus
10857 extern "C"
10858 #endif
10859 /* We use char because int might match the return type of a gcc2
10860    builtin and then its argument prototype would still apply.  */
10861 char acosl ();
10862 int
10863 main ()
10864 {
10865 acosl ();
10866   ;
10867   return 0;
10868 }
10869 _ACEOF
10870 rm -f conftest.$ac_objext conftest$ac_exeext
10871 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10872   (eval $ac_link) 2>conftest.er1
10873   ac_status=$?
10874   grep -v '^ *+' conftest.er1 >conftest.err
10875   rm -f conftest.er1
10876   cat conftest.err >&5
10877   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10878   (exit $ac_status); } &&
10879          { ac_try='test -z "$ac_c_werror_flag"
10880                          || test ! -s conftest.err'
10881   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10882   (eval $ac_try) 2>&5
10883   ac_status=$?
10884   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10885   (exit $ac_status); }; } &&
10886          { ac_try='test -s conftest$ac_exeext'
10887   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10888   (eval $ac_try) 2>&5
10889   ac_status=$?
10890   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10891   (exit $ac_status); }; }; then
10892   ac_cv_lib_m_acosl=yes
10893 else
10894   echo "$as_me: failed program was:" >&5
10895 sed 's/^/| /' conftest.$ac_ext >&5
10896
10897 ac_cv_lib_m_acosl=no
10898 fi
10899 rm -f conftest.err conftest.$ac_objext \
10900       conftest$ac_exeext conftest.$ac_ext
10901 LIBS=$ac_check_lib_save_LIBS
10902 fi
10903 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosl" >&5
10904 echo "${ECHO_T}$ac_cv_lib_m_acosl" >&6
10905 if test $ac_cv_lib_m_acosl = yes; then
10906
10907 cat >>confdefs.h <<\_ACEOF
10908 #define HAVE_ACOSL 1
10909 _ACEOF
10910
10911 fi
10912
10913 echo "$as_me:$LINENO: checking for acoshf in -lm" >&5
10914 echo $ECHO_N "checking for acoshf in -lm... $ECHO_C" >&6
10915 if test "${ac_cv_lib_m_acoshf+set}" = set; then
10916   echo $ECHO_N "(cached) $ECHO_C" >&6
10917 else
10918   ac_check_lib_save_LIBS=$LIBS
10919 LIBS="-lm  $LIBS"
10920 if test x$gcc_no_link = xyes; then
10921   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10922 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10923    { (exit 1); exit 1; }; }
10924 fi
10925 cat >conftest.$ac_ext <<_ACEOF
10926 /* confdefs.h.  */
10927 _ACEOF
10928 cat confdefs.h >>conftest.$ac_ext
10929 cat >>conftest.$ac_ext <<_ACEOF
10930 /* end confdefs.h.  */
10931
10932 /* Override any gcc2 internal prototype to avoid an error.  */
10933 #ifdef __cplusplus
10934 extern "C"
10935 #endif
10936 /* We use char because int might match the return type of a gcc2
10937    builtin and then its argument prototype would still apply.  */
10938 char acoshf ();
10939 int
10940 main ()
10941 {
10942 acoshf ();
10943   ;
10944   return 0;
10945 }
10946 _ACEOF
10947 rm -f conftest.$ac_objext conftest$ac_exeext
10948 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10949   (eval $ac_link) 2>conftest.er1
10950   ac_status=$?
10951   grep -v '^ *+' conftest.er1 >conftest.err
10952   rm -f conftest.er1
10953   cat conftest.err >&5
10954   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10955   (exit $ac_status); } &&
10956          { ac_try='test -z "$ac_c_werror_flag"
10957                          || test ! -s conftest.err'
10958   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10959   (eval $ac_try) 2>&5
10960   ac_status=$?
10961   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10962   (exit $ac_status); }; } &&
10963          { ac_try='test -s conftest$ac_exeext'
10964   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10965   (eval $ac_try) 2>&5
10966   ac_status=$?
10967   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10968   (exit $ac_status); }; }; then
10969   ac_cv_lib_m_acoshf=yes
10970 else
10971   echo "$as_me: failed program was:" >&5
10972 sed 's/^/| /' conftest.$ac_ext >&5
10973
10974 ac_cv_lib_m_acoshf=no
10975 fi
10976 rm -f conftest.err conftest.$ac_objext \
10977       conftest$ac_exeext conftest.$ac_ext
10978 LIBS=$ac_check_lib_save_LIBS
10979 fi
10980 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acoshf" >&5
10981 echo "${ECHO_T}$ac_cv_lib_m_acoshf" >&6
10982 if test $ac_cv_lib_m_acoshf = yes; then
10983
10984 cat >>confdefs.h <<\_ACEOF
10985 #define HAVE_ACOSHF 1
10986 _ACEOF
10987
10988 fi
10989
10990 echo "$as_me:$LINENO: checking for acosh in -lm" >&5
10991 echo $ECHO_N "checking for acosh in -lm... $ECHO_C" >&6
10992 if test "${ac_cv_lib_m_acosh+set}" = set; then
10993   echo $ECHO_N "(cached) $ECHO_C" >&6
10994 else
10995   ac_check_lib_save_LIBS=$LIBS
10996 LIBS="-lm  $LIBS"
10997 if test x$gcc_no_link = xyes; then
10998   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10999 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11000    { (exit 1); exit 1; }; }
11001 fi
11002 cat >conftest.$ac_ext <<_ACEOF
11003 /* confdefs.h.  */
11004 _ACEOF
11005 cat confdefs.h >>conftest.$ac_ext
11006 cat >>conftest.$ac_ext <<_ACEOF
11007 /* end confdefs.h.  */
11008
11009 /* Override any gcc2 internal prototype to avoid an error.  */
11010 #ifdef __cplusplus
11011 extern "C"
11012 #endif
11013 /* We use char because int might match the return type of a gcc2
11014    builtin and then its argument prototype would still apply.  */
11015 char acosh ();
11016 int
11017 main ()
11018 {
11019 acosh ();
11020   ;
11021   return 0;
11022 }
11023 _ACEOF
11024 rm -f conftest.$ac_objext conftest$ac_exeext
11025 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11026   (eval $ac_link) 2>conftest.er1
11027   ac_status=$?
11028   grep -v '^ *+' conftest.er1 >conftest.err
11029   rm -f conftest.er1
11030   cat conftest.err >&5
11031   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11032   (exit $ac_status); } &&
11033          { ac_try='test -z "$ac_c_werror_flag"
11034                          || test ! -s conftest.err'
11035   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11036   (eval $ac_try) 2>&5
11037   ac_status=$?
11038   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11039   (exit $ac_status); }; } &&
11040          { ac_try='test -s conftest$ac_exeext'
11041   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11042   (eval $ac_try) 2>&5
11043   ac_status=$?
11044   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11045   (exit $ac_status); }; }; then
11046   ac_cv_lib_m_acosh=yes
11047 else
11048   echo "$as_me: failed program was:" >&5
11049 sed 's/^/| /' conftest.$ac_ext >&5
11050
11051 ac_cv_lib_m_acosh=no
11052 fi
11053 rm -f conftest.err conftest.$ac_objext \
11054       conftest$ac_exeext conftest.$ac_ext
11055 LIBS=$ac_check_lib_save_LIBS
11056 fi
11057 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosh" >&5
11058 echo "${ECHO_T}$ac_cv_lib_m_acosh" >&6
11059 if test $ac_cv_lib_m_acosh = yes; then
11060
11061 cat >>confdefs.h <<\_ACEOF
11062 #define HAVE_ACOSH 1
11063 _ACEOF
11064
11065 fi
11066
11067 echo "$as_me:$LINENO: checking for acoshl in -lm" >&5
11068 echo $ECHO_N "checking for acoshl in -lm... $ECHO_C" >&6
11069 if test "${ac_cv_lib_m_acoshl+set}" = set; then
11070   echo $ECHO_N "(cached) $ECHO_C" >&6
11071 else
11072   ac_check_lib_save_LIBS=$LIBS
11073 LIBS="-lm  $LIBS"
11074 if test x$gcc_no_link = xyes; then
11075   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11076 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11077    { (exit 1); exit 1; }; }
11078 fi
11079 cat >conftest.$ac_ext <<_ACEOF
11080 /* confdefs.h.  */
11081 _ACEOF
11082 cat confdefs.h >>conftest.$ac_ext
11083 cat >>conftest.$ac_ext <<_ACEOF
11084 /* end confdefs.h.  */
11085
11086 /* Override any gcc2 internal prototype to avoid an error.  */
11087 #ifdef __cplusplus
11088 extern "C"
11089 #endif
11090 /* We use char because int might match the return type of a gcc2
11091    builtin and then its argument prototype would still apply.  */
11092 char acoshl ();
11093 int
11094 main ()
11095 {
11096 acoshl ();
11097   ;
11098   return 0;
11099 }
11100 _ACEOF
11101 rm -f conftest.$ac_objext conftest$ac_exeext
11102 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11103   (eval $ac_link) 2>conftest.er1
11104   ac_status=$?
11105   grep -v '^ *+' conftest.er1 >conftest.err
11106   rm -f conftest.er1
11107   cat conftest.err >&5
11108   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11109   (exit $ac_status); } &&
11110          { ac_try='test -z "$ac_c_werror_flag"
11111                          || test ! -s conftest.err'
11112   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11113   (eval $ac_try) 2>&5
11114   ac_status=$?
11115   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11116   (exit $ac_status); }; } &&
11117          { ac_try='test -s conftest$ac_exeext'
11118   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11119   (eval $ac_try) 2>&5
11120   ac_status=$?
11121   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11122   (exit $ac_status); }; }; then
11123   ac_cv_lib_m_acoshl=yes
11124 else
11125   echo "$as_me: failed program was:" >&5
11126 sed 's/^/| /' conftest.$ac_ext >&5
11127
11128 ac_cv_lib_m_acoshl=no
11129 fi
11130 rm -f conftest.err conftest.$ac_objext \
11131       conftest$ac_exeext conftest.$ac_ext
11132 LIBS=$ac_check_lib_save_LIBS
11133 fi
11134 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acoshl" >&5
11135 echo "${ECHO_T}$ac_cv_lib_m_acoshl" >&6
11136 if test $ac_cv_lib_m_acoshl = yes; then
11137
11138 cat >>confdefs.h <<\_ACEOF
11139 #define HAVE_ACOSHL 1
11140 _ACEOF
11141
11142 fi
11143
11144 echo "$as_me:$LINENO: checking for asinf in -lm" >&5
11145 echo $ECHO_N "checking for asinf in -lm... $ECHO_C" >&6
11146 if test "${ac_cv_lib_m_asinf+set}" = set; then
11147   echo $ECHO_N "(cached) $ECHO_C" >&6
11148 else
11149   ac_check_lib_save_LIBS=$LIBS
11150 LIBS="-lm  $LIBS"
11151 if test x$gcc_no_link = xyes; then
11152   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11153 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11154    { (exit 1); exit 1; }; }
11155 fi
11156 cat >conftest.$ac_ext <<_ACEOF
11157 /* confdefs.h.  */
11158 _ACEOF
11159 cat confdefs.h >>conftest.$ac_ext
11160 cat >>conftest.$ac_ext <<_ACEOF
11161 /* end confdefs.h.  */
11162
11163 /* Override any gcc2 internal prototype to avoid an error.  */
11164 #ifdef __cplusplus
11165 extern "C"
11166 #endif
11167 /* We use char because int might match the return type of a gcc2
11168    builtin and then its argument prototype would still apply.  */
11169 char asinf ();
11170 int
11171 main ()
11172 {
11173 asinf ();
11174   ;
11175   return 0;
11176 }
11177 _ACEOF
11178 rm -f conftest.$ac_objext conftest$ac_exeext
11179 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11180   (eval $ac_link) 2>conftest.er1
11181   ac_status=$?
11182   grep -v '^ *+' conftest.er1 >conftest.err
11183   rm -f conftest.er1
11184   cat conftest.err >&5
11185   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11186   (exit $ac_status); } &&
11187          { ac_try='test -z "$ac_c_werror_flag"
11188                          || test ! -s conftest.err'
11189   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11190   (eval $ac_try) 2>&5
11191   ac_status=$?
11192   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11193   (exit $ac_status); }; } &&
11194          { ac_try='test -s conftest$ac_exeext'
11195   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11196   (eval $ac_try) 2>&5
11197   ac_status=$?
11198   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11199   (exit $ac_status); }; }; then
11200   ac_cv_lib_m_asinf=yes
11201 else
11202   echo "$as_me: failed program was:" >&5
11203 sed 's/^/| /' conftest.$ac_ext >&5
11204
11205 ac_cv_lib_m_asinf=no
11206 fi
11207 rm -f conftest.err conftest.$ac_objext \
11208       conftest$ac_exeext conftest.$ac_ext
11209 LIBS=$ac_check_lib_save_LIBS
11210 fi
11211 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinf" >&5
11212 echo "${ECHO_T}$ac_cv_lib_m_asinf" >&6
11213 if test $ac_cv_lib_m_asinf = yes; then
11214
11215 cat >>confdefs.h <<\_ACEOF
11216 #define HAVE_ASINF 1
11217 _ACEOF
11218
11219 fi
11220
11221 echo "$as_me:$LINENO: checking for asin in -lm" >&5
11222 echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
11223 if test "${ac_cv_lib_m_asin+set}" = set; then
11224   echo $ECHO_N "(cached) $ECHO_C" >&6
11225 else
11226   ac_check_lib_save_LIBS=$LIBS
11227 LIBS="-lm  $LIBS"
11228 if test x$gcc_no_link = xyes; then
11229   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11230 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11231    { (exit 1); exit 1; }; }
11232 fi
11233 cat >conftest.$ac_ext <<_ACEOF
11234 /* confdefs.h.  */
11235 _ACEOF
11236 cat confdefs.h >>conftest.$ac_ext
11237 cat >>conftest.$ac_ext <<_ACEOF
11238 /* end confdefs.h.  */
11239
11240 /* Override any gcc2 internal prototype to avoid an error.  */
11241 #ifdef __cplusplus
11242 extern "C"
11243 #endif
11244 /* We use char because int might match the return type of a gcc2
11245    builtin and then its argument prototype would still apply.  */
11246 char asin ();
11247 int
11248 main ()
11249 {
11250 asin ();
11251   ;
11252   return 0;
11253 }
11254 _ACEOF
11255 rm -f conftest.$ac_objext conftest$ac_exeext
11256 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11257   (eval $ac_link) 2>conftest.er1
11258   ac_status=$?
11259   grep -v '^ *+' conftest.er1 >conftest.err
11260   rm -f conftest.er1
11261   cat conftest.err >&5
11262   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11263   (exit $ac_status); } &&
11264          { ac_try='test -z "$ac_c_werror_flag"
11265                          || test ! -s conftest.err'
11266   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11267   (eval $ac_try) 2>&5
11268   ac_status=$?
11269   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11270   (exit $ac_status); }; } &&
11271          { ac_try='test -s conftest$ac_exeext'
11272   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11273   (eval $ac_try) 2>&5
11274   ac_status=$?
11275   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11276   (exit $ac_status); }; }; then
11277   ac_cv_lib_m_asin=yes
11278 else
11279   echo "$as_me: failed program was:" >&5
11280 sed 's/^/| /' conftest.$ac_ext >&5
11281
11282 ac_cv_lib_m_asin=no
11283 fi
11284 rm -f conftest.err conftest.$ac_objext \
11285       conftest$ac_exeext conftest.$ac_ext
11286 LIBS=$ac_check_lib_save_LIBS
11287 fi
11288 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
11289 echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
11290 if test $ac_cv_lib_m_asin = yes; then
11291
11292 cat >>confdefs.h <<\_ACEOF
11293 #define HAVE_ASIN 1
11294 _ACEOF
11295
11296 fi
11297
11298 echo "$as_me:$LINENO: checking for asinl in -lm" >&5
11299 echo $ECHO_N "checking for asinl in -lm... $ECHO_C" >&6
11300 if test "${ac_cv_lib_m_asinl+set}" = set; then
11301   echo $ECHO_N "(cached) $ECHO_C" >&6
11302 else
11303   ac_check_lib_save_LIBS=$LIBS
11304 LIBS="-lm  $LIBS"
11305 if test x$gcc_no_link = xyes; then
11306   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11307 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11308    { (exit 1); exit 1; }; }
11309 fi
11310 cat >conftest.$ac_ext <<_ACEOF
11311 /* confdefs.h.  */
11312 _ACEOF
11313 cat confdefs.h >>conftest.$ac_ext
11314 cat >>conftest.$ac_ext <<_ACEOF
11315 /* end confdefs.h.  */
11316
11317 /* Override any gcc2 internal prototype to avoid an error.  */
11318 #ifdef __cplusplus
11319 extern "C"
11320 #endif
11321 /* We use char because int might match the return type of a gcc2
11322    builtin and then its argument prototype would still apply.  */
11323 char asinl ();
11324 int
11325 main ()
11326 {
11327 asinl ();
11328   ;
11329   return 0;
11330 }
11331 _ACEOF
11332 rm -f conftest.$ac_objext conftest$ac_exeext
11333 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11334   (eval $ac_link) 2>conftest.er1
11335   ac_status=$?
11336   grep -v '^ *+' conftest.er1 >conftest.err
11337   rm -f conftest.er1
11338   cat conftest.err >&5
11339   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11340   (exit $ac_status); } &&
11341          { ac_try='test -z "$ac_c_werror_flag"
11342                          || test ! -s conftest.err'
11343   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11344   (eval $ac_try) 2>&5
11345   ac_status=$?
11346   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11347   (exit $ac_status); }; } &&
11348          { ac_try='test -s conftest$ac_exeext'
11349   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11350   (eval $ac_try) 2>&5
11351   ac_status=$?
11352   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11353   (exit $ac_status); }; }; then
11354   ac_cv_lib_m_asinl=yes
11355 else
11356   echo "$as_me: failed program was:" >&5
11357 sed 's/^/| /' conftest.$ac_ext >&5
11358
11359 ac_cv_lib_m_asinl=no
11360 fi
11361 rm -f conftest.err conftest.$ac_objext \
11362       conftest$ac_exeext conftest.$ac_ext
11363 LIBS=$ac_check_lib_save_LIBS
11364 fi
11365 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinl" >&5
11366 echo "${ECHO_T}$ac_cv_lib_m_asinl" >&6
11367 if test $ac_cv_lib_m_asinl = yes; then
11368
11369 cat >>confdefs.h <<\_ACEOF
11370 #define HAVE_ASINL 1
11371 _ACEOF
11372
11373 fi
11374
11375 echo "$as_me:$LINENO: checking for asinhf in -lm" >&5
11376 echo $ECHO_N "checking for asinhf in -lm... $ECHO_C" >&6
11377 if test "${ac_cv_lib_m_asinhf+set}" = set; then
11378   echo $ECHO_N "(cached) $ECHO_C" >&6
11379 else
11380   ac_check_lib_save_LIBS=$LIBS
11381 LIBS="-lm  $LIBS"
11382 if test x$gcc_no_link = xyes; then
11383   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11384 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11385    { (exit 1); exit 1; }; }
11386 fi
11387 cat >conftest.$ac_ext <<_ACEOF
11388 /* confdefs.h.  */
11389 _ACEOF
11390 cat confdefs.h >>conftest.$ac_ext
11391 cat >>conftest.$ac_ext <<_ACEOF
11392 /* end confdefs.h.  */
11393
11394 /* Override any gcc2 internal prototype to avoid an error.  */
11395 #ifdef __cplusplus
11396 extern "C"
11397 #endif
11398 /* We use char because int might match the return type of a gcc2
11399    builtin and then its argument prototype would still apply.  */
11400 char asinhf ();
11401 int
11402 main ()
11403 {
11404 asinhf ();
11405   ;
11406   return 0;
11407 }
11408 _ACEOF
11409 rm -f conftest.$ac_objext conftest$ac_exeext
11410 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11411   (eval $ac_link) 2>conftest.er1
11412   ac_status=$?
11413   grep -v '^ *+' conftest.er1 >conftest.err
11414   rm -f conftest.er1
11415   cat conftest.err >&5
11416   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11417   (exit $ac_status); } &&
11418          { ac_try='test -z "$ac_c_werror_flag"
11419                          || test ! -s conftest.err'
11420   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11421   (eval $ac_try) 2>&5
11422   ac_status=$?
11423   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11424   (exit $ac_status); }; } &&
11425          { ac_try='test -s conftest$ac_exeext'
11426   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11427   (eval $ac_try) 2>&5
11428   ac_status=$?
11429   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11430   (exit $ac_status); }; }; then
11431   ac_cv_lib_m_asinhf=yes
11432 else
11433   echo "$as_me: failed program was:" >&5
11434 sed 's/^/| /' conftest.$ac_ext >&5
11435
11436 ac_cv_lib_m_asinhf=no
11437 fi
11438 rm -f conftest.err conftest.$ac_objext \
11439       conftest$ac_exeext conftest.$ac_ext
11440 LIBS=$ac_check_lib_save_LIBS
11441 fi
11442 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinhf" >&5
11443 echo "${ECHO_T}$ac_cv_lib_m_asinhf" >&6
11444 if test $ac_cv_lib_m_asinhf = yes; then
11445
11446 cat >>confdefs.h <<\_ACEOF
11447 #define HAVE_ASINHF 1
11448 _ACEOF
11449
11450 fi
11451
11452 echo "$as_me:$LINENO: checking for asinh in -lm" >&5
11453 echo $ECHO_N "checking for asinh in -lm... $ECHO_C" >&6
11454 if test "${ac_cv_lib_m_asinh+set}" = set; then
11455   echo $ECHO_N "(cached) $ECHO_C" >&6
11456 else
11457   ac_check_lib_save_LIBS=$LIBS
11458 LIBS="-lm  $LIBS"
11459 if test x$gcc_no_link = xyes; then
11460   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11461 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11462    { (exit 1); exit 1; }; }
11463 fi
11464 cat >conftest.$ac_ext <<_ACEOF
11465 /* confdefs.h.  */
11466 _ACEOF
11467 cat confdefs.h >>conftest.$ac_ext
11468 cat >>conftest.$ac_ext <<_ACEOF
11469 /* end confdefs.h.  */
11470
11471 /* Override any gcc2 internal prototype to avoid an error.  */
11472 #ifdef __cplusplus
11473 extern "C"
11474 #endif
11475 /* We use char because int might match the return type of a gcc2
11476    builtin and then its argument prototype would still apply.  */
11477 char asinh ();
11478 int
11479 main ()
11480 {
11481 asinh ();
11482   ;
11483   return 0;
11484 }
11485 _ACEOF
11486 rm -f conftest.$ac_objext conftest$ac_exeext
11487 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11488   (eval $ac_link) 2>conftest.er1
11489   ac_status=$?
11490   grep -v '^ *+' conftest.er1 >conftest.err
11491   rm -f conftest.er1
11492   cat conftest.err >&5
11493   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11494   (exit $ac_status); } &&
11495          { ac_try='test -z "$ac_c_werror_flag"
11496                          || test ! -s conftest.err'
11497   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11498   (eval $ac_try) 2>&5
11499   ac_status=$?
11500   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11501   (exit $ac_status); }; } &&
11502          { ac_try='test -s conftest$ac_exeext'
11503   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11504   (eval $ac_try) 2>&5
11505   ac_status=$?
11506   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11507   (exit $ac_status); }; }; then
11508   ac_cv_lib_m_asinh=yes
11509 else
11510   echo "$as_me: failed program was:" >&5
11511 sed 's/^/| /' conftest.$ac_ext >&5
11512
11513 ac_cv_lib_m_asinh=no
11514 fi
11515 rm -f conftest.err conftest.$ac_objext \
11516       conftest$ac_exeext conftest.$ac_ext
11517 LIBS=$ac_check_lib_save_LIBS
11518 fi
11519 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinh" >&5
11520 echo "${ECHO_T}$ac_cv_lib_m_asinh" >&6
11521 if test $ac_cv_lib_m_asinh = yes; then
11522
11523 cat >>confdefs.h <<\_ACEOF
11524 #define HAVE_ASINH 1
11525 _ACEOF
11526
11527 fi
11528
11529 echo "$as_me:$LINENO: checking for asinhl in -lm" >&5
11530 echo $ECHO_N "checking for asinhl in -lm... $ECHO_C" >&6
11531 if test "${ac_cv_lib_m_asinhl+set}" = set; then
11532   echo $ECHO_N "(cached) $ECHO_C" >&6
11533 else
11534   ac_check_lib_save_LIBS=$LIBS
11535 LIBS="-lm  $LIBS"
11536 if test x$gcc_no_link = xyes; then
11537   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11538 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11539    { (exit 1); exit 1; }; }
11540 fi
11541 cat >conftest.$ac_ext <<_ACEOF
11542 /* confdefs.h.  */
11543 _ACEOF
11544 cat confdefs.h >>conftest.$ac_ext
11545 cat >>conftest.$ac_ext <<_ACEOF
11546 /* end confdefs.h.  */
11547
11548 /* Override any gcc2 internal prototype to avoid an error.  */
11549 #ifdef __cplusplus
11550 extern "C"
11551 #endif
11552 /* We use char because int might match the return type of a gcc2
11553    builtin and then its argument prototype would still apply.  */
11554 char asinhl ();
11555 int
11556 main ()
11557 {
11558 asinhl ();
11559   ;
11560   return 0;
11561 }
11562 _ACEOF
11563 rm -f conftest.$ac_objext conftest$ac_exeext
11564 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11565   (eval $ac_link) 2>conftest.er1
11566   ac_status=$?
11567   grep -v '^ *+' conftest.er1 >conftest.err
11568   rm -f conftest.er1
11569   cat conftest.err >&5
11570   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11571   (exit $ac_status); } &&
11572          { ac_try='test -z "$ac_c_werror_flag"
11573                          || test ! -s conftest.err'
11574   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11575   (eval $ac_try) 2>&5
11576   ac_status=$?
11577   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11578   (exit $ac_status); }; } &&
11579          { ac_try='test -s conftest$ac_exeext'
11580   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11581   (eval $ac_try) 2>&5
11582   ac_status=$?
11583   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11584   (exit $ac_status); }; }; then
11585   ac_cv_lib_m_asinhl=yes
11586 else
11587   echo "$as_me: failed program was:" >&5
11588 sed 's/^/| /' conftest.$ac_ext >&5
11589
11590 ac_cv_lib_m_asinhl=no
11591 fi
11592 rm -f conftest.err conftest.$ac_objext \
11593       conftest$ac_exeext conftest.$ac_ext
11594 LIBS=$ac_check_lib_save_LIBS
11595 fi
11596 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinhl" >&5
11597 echo "${ECHO_T}$ac_cv_lib_m_asinhl" >&6
11598 if test $ac_cv_lib_m_asinhl = yes; then
11599
11600 cat >>confdefs.h <<\_ACEOF
11601 #define HAVE_ASINHL 1
11602 _ACEOF
11603
11604 fi
11605
11606 echo "$as_me:$LINENO: checking for atan2f in -lm" >&5
11607 echo $ECHO_N "checking for atan2f in -lm... $ECHO_C" >&6
11608 if test "${ac_cv_lib_m_atan2f+set}" = set; then
11609   echo $ECHO_N "(cached) $ECHO_C" >&6
11610 else
11611   ac_check_lib_save_LIBS=$LIBS
11612 LIBS="-lm  $LIBS"
11613 if test x$gcc_no_link = xyes; then
11614   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11615 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11616    { (exit 1); exit 1; }; }
11617 fi
11618 cat >conftest.$ac_ext <<_ACEOF
11619 /* confdefs.h.  */
11620 _ACEOF
11621 cat confdefs.h >>conftest.$ac_ext
11622 cat >>conftest.$ac_ext <<_ACEOF
11623 /* end confdefs.h.  */
11624
11625 /* Override any gcc2 internal prototype to avoid an error.  */
11626 #ifdef __cplusplus
11627 extern "C"
11628 #endif
11629 /* We use char because int might match the return type of a gcc2
11630    builtin and then its argument prototype would still apply.  */
11631 char atan2f ();
11632 int
11633 main ()
11634 {
11635 atan2f ();
11636   ;
11637   return 0;
11638 }
11639 _ACEOF
11640 rm -f conftest.$ac_objext conftest$ac_exeext
11641 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11642   (eval $ac_link) 2>conftest.er1
11643   ac_status=$?
11644   grep -v '^ *+' conftest.er1 >conftest.err
11645   rm -f conftest.er1
11646   cat conftest.err >&5
11647   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11648   (exit $ac_status); } &&
11649          { ac_try='test -z "$ac_c_werror_flag"
11650                          || test ! -s conftest.err'
11651   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11652   (eval $ac_try) 2>&5
11653   ac_status=$?
11654   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11655   (exit $ac_status); }; } &&
11656          { ac_try='test -s conftest$ac_exeext'
11657   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11658   (eval $ac_try) 2>&5
11659   ac_status=$?
11660   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11661   (exit $ac_status); }; }; then
11662   ac_cv_lib_m_atan2f=yes
11663 else
11664   echo "$as_me: failed program was:" >&5
11665 sed 's/^/| /' conftest.$ac_ext >&5
11666
11667 ac_cv_lib_m_atan2f=no
11668 fi
11669 rm -f conftest.err conftest.$ac_objext \
11670       conftest$ac_exeext conftest.$ac_ext
11671 LIBS=$ac_check_lib_save_LIBS
11672 fi
11673 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2f" >&5
11674 echo "${ECHO_T}$ac_cv_lib_m_atan2f" >&6
11675 if test $ac_cv_lib_m_atan2f = yes; then
11676
11677 cat >>confdefs.h <<\_ACEOF
11678 #define HAVE_ATAN2F 1
11679 _ACEOF
11680
11681 fi
11682
11683 echo "$as_me:$LINENO: checking for atan2 in -lm" >&5
11684 echo $ECHO_N "checking for atan2 in -lm... $ECHO_C" >&6
11685 if test "${ac_cv_lib_m_atan2+set}" = set; then
11686   echo $ECHO_N "(cached) $ECHO_C" >&6
11687 else
11688   ac_check_lib_save_LIBS=$LIBS
11689 LIBS="-lm  $LIBS"
11690 if test x$gcc_no_link = xyes; then
11691   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11692 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11693    { (exit 1); exit 1; }; }
11694 fi
11695 cat >conftest.$ac_ext <<_ACEOF
11696 /* confdefs.h.  */
11697 _ACEOF
11698 cat confdefs.h >>conftest.$ac_ext
11699 cat >>conftest.$ac_ext <<_ACEOF
11700 /* end confdefs.h.  */
11701
11702 /* Override any gcc2 internal prototype to avoid an error.  */
11703 #ifdef __cplusplus
11704 extern "C"
11705 #endif
11706 /* We use char because int might match the return type of a gcc2
11707    builtin and then its argument prototype would still apply.  */
11708 char atan2 ();
11709 int
11710 main ()
11711 {
11712 atan2 ();
11713   ;
11714   return 0;
11715 }
11716 _ACEOF
11717 rm -f conftest.$ac_objext conftest$ac_exeext
11718 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11719   (eval $ac_link) 2>conftest.er1
11720   ac_status=$?
11721   grep -v '^ *+' conftest.er1 >conftest.err
11722   rm -f conftest.er1
11723   cat conftest.err >&5
11724   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11725   (exit $ac_status); } &&
11726          { ac_try='test -z "$ac_c_werror_flag"
11727                          || test ! -s conftest.err'
11728   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11729   (eval $ac_try) 2>&5
11730   ac_status=$?
11731   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11732   (exit $ac_status); }; } &&
11733          { ac_try='test -s conftest$ac_exeext'
11734   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11735   (eval $ac_try) 2>&5
11736   ac_status=$?
11737   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11738   (exit $ac_status); }; }; then
11739   ac_cv_lib_m_atan2=yes
11740 else
11741   echo "$as_me: failed program was:" >&5
11742 sed 's/^/| /' conftest.$ac_ext >&5
11743
11744 ac_cv_lib_m_atan2=no
11745 fi
11746 rm -f conftest.err conftest.$ac_objext \
11747       conftest$ac_exeext conftest.$ac_ext
11748 LIBS=$ac_check_lib_save_LIBS
11749 fi
11750 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2" >&5
11751 echo "${ECHO_T}$ac_cv_lib_m_atan2" >&6
11752 if test $ac_cv_lib_m_atan2 = yes; then
11753
11754 cat >>confdefs.h <<\_ACEOF
11755 #define HAVE_ATAN2 1
11756 _ACEOF
11757
11758 fi
11759
11760 echo "$as_me:$LINENO: checking for atan2l in -lm" >&5
11761 echo $ECHO_N "checking for atan2l in -lm... $ECHO_C" >&6
11762 if test "${ac_cv_lib_m_atan2l+set}" = set; then
11763   echo $ECHO_N "(cached) $ECHO_C" >&6
11764 else
11765   ac_check_lib_save_LIBS=$LIBS
11766 LIBS="-lm  $LIBS"
11767 if test x$gcc_no_link = xyes; then
11768   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11769 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11770    { (exit 1); exit 1; }; }
11771 fi
11772 cat >conftest.$ac_ext <<_ACEOF
11773 /* confdefs.h.  */
11774 _ACEOF
11775 cat confdefs.h >>conftest.$ac_ext
11776 cat >>conftest.$ac_ext <<_ACEOF
11777 /* end confdefs.h.  */
11778
11779 /* Override any gcc2 internal prototype to avoid an error.  */
11780 #ifdef __cplusplus
11781 extern "C"
11782 #endif
11783 /* We use char because int might match the return type of a gcc2
11784    builtin and then its argument prototype would still apply.  */
11785 char atan2l ();
11786 int
11787 main ()
11788 {
11789 atan2l ();
11790   ;
11791   return 0;
11792 }
11793 _ACEOF
11794 rm -f conftest.$ac_objext conftest$ac_exeext
11795 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11796   (eval $ac_link) 2>conftest.er1
11797   ac_status=$?
11798   grep -v '^ *+' conftest.er1 >conftest.err
11799   rm -f conftest.er1
11800   cat conftest.err >&5
11801   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11802   (exit $ac_status); } &&
11803          { ac_try='test -z "$ac_c_werror_flag"
11804                          || test ! -s conftest.err'
11805   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11806   (eval $ac_try) 2>&5
11807   ac_status=$?
11808   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11809   (exit $ac_status); }; } &&
11810          { ac_try='test -s conftest$ac_exeext'
11811   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11812   (eval $ac_try) 2>&5
11813   ac_status=$?
11814   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11815   (exit $ac_status); }; }; then
11816   ac_cv_lib_m_atan2l=yes
11817 else
11818   echo "$as_me: failed program was:" >&5
11819 sed 's/^/| /' conftest.$ac_ext >&5
11820
11821 ac_cv_lib_m_atan2l=no
11822 fi
11823 rm -f conftest.err conftest.$ac_objext \
11824       conftest$ac_exeext conftest.$ac_ext
11825 LIBS=$ac_check_lib_save_LIBS
11826 fi
11827 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2l" >&5
11828 echo "${ECHO_T}$ac_cv_lib_m_atan2l" >&6
11829 if test $ac_cv_lib_m_atan2l = yes; then
11830
11831 cat >>confdefs.h <<\_ACEOF
11832 #define HAVE_ATAN2L 1
11833 _ACEOF
11834
11835 fi
11836
11837 echo "$as_me:$LINENO: checking for atanf in -lm" >&5
11838 echo $ECHO_N "checking for atanf in -lm... $ECHO_C" >&6
11839 if test "${ac_cv_lib_m_atanf+set}" = set; then
11840   echo $ECHO_N "(cached) $ECHO_C" >&6
11841 else
11842   ac_check_lib_save_LIBS=$LIBS
11843 LIBS="-lm  $LIBS"
11844 if test x$gcc_no_link = xyes; then
11845   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11846 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11847    { (exit 1); exit 1; }; }
11848 fi
11849 cat >conftest.$ac_ext <<_ACEOF
11850 /* confdefs.h.  */
11851 _ACEOF
11852 cat confdefs.h >>conftest.$ac_ext
11853 cat >>conftest.$ac_ext <<_ACEOF
11854 /* end confdefs.h.  */
11855
11856 /* Override any gcc2 internal prototype to avoid an error.  */
11857 #ifdef __cplusplus
11858 extern "C"
11859 #endif
11860 /* We use char because int might match the return type of a gcc2
11861    builtin and then its argument prototype would still apply.  */
11862 char atanf ();
11863 int
11864 main ()
11865 {
11866 atanf ();
11867   ;
11868   return 0;
11869 }
11870 _ACEOF
11871 rm -f conftest.$ac_objext conftest$ac_exeext
11872 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11873   (eval $ac_link) 2>conftest.er1
11874   ac_status=$?
11875   grep -v '^ *+' conftest.er1 >conftest.err
11876   rm -f conftest.er1
11877   cat conftest.err >&5
11878   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11879   (exit $ac_status); } &&
11880          { ac_try='test -z "$ac_c_werror_flag"
11881                          || test ! -s conftest.err'
11882   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11883   (eval $ac_try) 2>&5
11884   ac_status=$?
11885   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11886   (exit $ac_status); }; } &&
11887          { ac_try='test -s conftest$ac_exeext'
11888   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11889   (eval $ac_try) 2>&5
11890   ac_status=$?
11891   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11892   (exit $ac_status); }; }; then
11893   ac_cv_lib_m_atanf=yes
11894 else
11895   echo "$as_me: failed program was:" >&5
11896 sed 's/^/| /' conftest.$ac_ext >&5
11897
11898 ac_cv_lib_m_atanf=no
11899 fi
11900 rm -f conftest.err conftest.$ac_objext \
11901       conftest$ac_exeext conftest.$ac_ext
11902 LIBS=$ac_check_lib_save_LIBS
11903 fi
11904 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanf" >&5
11905 echo "${ECHO_T}$ac_cv_lib_m_atanf" >&6
11906 if test $ac_cv_lib_m_atanf = yes; then
11907
11908 cat >>confdefs.h <<\_ACEOF
11909 #define HAVE_ATANF 1
11910 _ACEOF
11911
11912 fi
11913
11914 echo "$as_me:$LINENO: checking for atan in -lm" >&5
11915 echo $ECHO_N "checking for atan in -lm... $ECHO_C" >&6
11916 if test "${ac_cv_lib_m_atan+set}" = set; then
11917   echo $ECHO_N "(cached) $ECHO_C" >&6
11918 else
11919   ac_check_lib_save_LIBS=$LIBS
11920 LIBS="-lm  $LIBS"
11921 if test x$gcc_no_link = xyes; then
11922   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11923 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11924    { (exit 1); exit 1; }; }
11925 fi
11926 cat >conftest.$ac_ext <<_ACEOF
11927 /* confdefs.h.  */
11928 _ACEOF
11929 cat confdefs.h >>conftest.$ac_ext
11930 cat >>conftest.$ac_ext <<_ACEOF
11931 /* end confdefs.h.  */
11932
11933 /* Override any gcc2 internal prototype to avoid an error.  */
11934 #ifdef __cplusplus
11935 extern "C"
11936 #endif
11937 /* We use char because int might match the return type of a gcc2
11938    builtin and then its argument prototype would still apply.  */
11939 char atan ();
11940 int
11941 main ()
11942 {
11943 atan ();
11944   ;
11945   return 0;
11946 }
11947 _ACEOF
11948 rm -f conftest.$ac_objext conftest$ac_exeext
11949 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11950   (eval $ac_link) 2>conftest.er1
11951   ac_status=$?
11952   grep -v '^ *+' conftest.er1 >conftest.err
11953   rm -f conftest.er1
11954   cat conftest.err >&5
11955   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11956   (exit $ac_status); } &&
11957          { ac_try='test -z "$ac_c_werror_flag"
11958                          || test ! -s conftest.err'
11959   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11960   (eval $ac_try) 2>&5
11961   ac_status=$?
11962   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11963   (exit $ac_status); }; } &&
11964          { ac_try='test -s conftest$ac_exeext'
11965   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11966   (eval $ac_try) 2>&5
11967   ac_status=$?
11968   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11969   (exit $ac_status); }; }; then
11970   ac_cv_lib_m_atan=yes
11971 else
11972   echo "$as_me: failed program was:" >&5
11973 sed 's/^/| /' conftest.$ac_ext >&5
11974
11975 ac_cv_lib_m_atan=no
11976 fi
11977 rm -f conftest.err conftest.$ac_objext \
11978       conftest$ac_exeext conftest.$ac_ext
11979 LIBS=$ac_check_lib_save_LIBS
11980 fi
11981 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan" >&5
11982 echo "${ECHO_T}$ac_cv_lib_m_atan" >&6
11983 if test $ac_cv_lib_m_atan = yes; then
11984
11985 cat >>confdefs.h <<\_ACEOF
11986 #define HAVE_ATAN 1
11987 _ACEOF
11988
11989 fi
11990
11991 echo "$as_me:$LINENO: checking for atanl in -lm" >&5
11992 echo $ECHO_N "checking for atanl in -lm... $ECHO_C" >&6
11993 if test "${ac_cv_lib_m_atanl+set}" = set; then
11994   echo $ECHO_N "(cached) $ECHO_C" >&6
11995 else
11996   ac_check_lib_save_LIBS=$LIBS
11997 LIBS="-lm  $LIBS"
11998 if test x$gcc_no_link = xyes; then
11999   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12000 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12001    { (exit 1); exit 1; }; }
12002 fi
12003 cat >conftest.$ac_ext <<_ACEOF
12004 /* confdefs.h.  */
12005 _ACEOF
12006 cat confdefs.h >>conftest.$ac_ext
12007 cat >>conftest.$ac_ext <<_ACEOF
12008 /* end confdefs.h.  */
12009
12010 /* Override any gcc2 internal prototype to avoid an error.  */
12011 #ifdef __cplusplus
12012 extern "C"
12013 #endif
12014 /* We use char because int might match the return type of a gcc2
12015    builtin and then its argument prototype would still apply.  */
12016 char atanl ();
12017 int
12018 main ()
12019 {
12020 atanl ();
12021   ;
12022   return 0;
12023 }
12024 _ACEOF
12025 rm -f conftest.$ac_objext conftest$ac_exeext
12026 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12027   (eval $ac_link) 2>conftest.er1
12028   ac_status=$?
12029   grep -v '^ *+' conftest.er1 >conftest.err
12030   rm -f conftest.er1
12031   cat conftest.err >&5
12032   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12033   (exit $ac_status); } &&
12034          { ac_try='test -z "$ac_c_werror_flag"
12035                          || test ! -s conftest.err'
12036   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12037   (eval $ac_try) 2>&5
12038   ac_status=$?
12039   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12040   (exit $ac_status); }; } &&
12041          { ac_try='test -s conftest$ac_exeext'
12042   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12043   (eval $ac_try) 2>&5
12044   ac_status=$?
12045   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12046   (exit $ac_status); }; }; then
12047   ac_cv_lib_m_atanl=yes
12048 else
12049   echo "$as_me: failed program was:" >&5
12050 sed 's/^/| /' conftest.$ac_ext >&5
12051
12052 ac_cv_lib_m_atanl=no
12053 fi
12054 rm -f conftest.err conftest.$ac_objext \
12055       conftest$ac_exeext conftest.$ac_ext
12056 LIBS=$ac_check_lib_save_LIBS
12057 fi
12058 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanl" >&5
12059 echo "${ECHO_T}$ac_cv_lib_m_atanl" >&6
12060 if test $ac_cv_lib_m_atanl = yes; then
12061
12062 cat >>confdefs.h <<\_ACEOF
12063 #define HAVE_ATANL 1
12064 _ACEOF
12065
12066 fi
12067
12068 echo "$as_me:$LINENO: checking for atanhf in -lm" >&5
12069 echo $ECHO_N "checking for atanhf in -lm... $ECHO_C" >&6
12070 if test "${ac_cv_lib_m_atanhf+set}" = set; then
12071   echo $ECHO_N "(cached) $ECHO_C" >&6
12072 else
12073   ac_check_lib_save_LIBS=$LIBS
12074 LIBS="-lm  $LIBS"
12075 if test x$gcc_no_link = xyes; then
12076   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12077 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12078    { (exit 1); exit 1; }; }
12079 fi
12080 cat >conftest.$ac_ext <<_ACEOF
12081 /* confdefs.h.  */
12082 _ACEOF
12083 cat confdefs.h >>conftest.$ac_ext
12084 cat >>conftest.$ac_ext <<_ACEOF
12085 /* end confdefs.h.  */
12086
12087 /* Override any gcc2 internal prototype to avoid an error.  */
12088 #ifdef __cplusplus
12089 extern "C"
12090 #endif
12091 /* We use char because int might match the return type of a gcc2
12092    builtin and then its argument prototype would still apply.  */
12093 char atanhf ();
12094 int
12095 main ()
12096 {
12097 atanhf ();
12098   ;
12099   return 0;
12100 }
12101 _ACEOF
12102 rm -f conftest.$ac_objext conftest$ac_exeext
12103 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12104   (eval $ac_link) 2>conftest.er1
12105   ac_status=$?
12106   grep -v '^ *+' conftest.er1 >conftest.err
12107   rm -f conftest.er1
12108   cat conftest.err >&5
12109   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12110   (exit $ac_status); } &&
12111          { ac_try='test -z "$ac_c_werror_flag"
12112                          || test ! -s conftest.err'
12113   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12114   (eval $ac_try) 2>&5
12115   ac_status=$?
12116   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12117   (exit $ac_status); }; } &&
12118          { ac_try='test -s conftest$ac_exeext'
12119   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12120   (eval $ac_try) 2>&5
12121   ac_status=$?
12122   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12123   (exit $ac_status); }; }; then
12124   ac_cv_lib_m_atanhf=yes
12125 else
12126   echo "$as_me: failed program was:" >&5
12127 sed 's/^/| /' conftest.$ac_ext >&5
12128
12129 ac_cv_lib_m_atanhf=no
12130 fi
12131 rm -f conftest.err conftest.$ac_objext \
12132       conftest$ac_exeext conftest.$ac_ext
12133 LIBS=$ac_check_lib_save_LIBS
12134 fi
12135 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanhf" >&5
12136 echo "${ECHO_T}$ac_cv_lib_m_atanhf" >&6
12137 if test $ac_cv_lib_m_atanhf = yes; then
12138
12139 cat >>confdefs.h <<\_ACEOF
12140 #define HAVE_ATANHF 1
12141 _ACEOF
12142
12143 fi
12144
12145 echo "$as_me:$LINENO: checking for atanh in -lm" >&5
12146 echo $ECHO_N "checking for atanh in -lm... $ECHO_C" >&6
12147 if test "${ac_cv_lib_m_atanh+set}" = set; then
12148   echo $ECHO_N "(cached) $ECHO_C" >&6
12149 else
12150   ac_check_lib_save_LIBS=$LIBS
12151 LIBS="-lm  $LIBS"
12152 if test x$gcc_no_link = xyes; then
12153   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12154 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12155    { (exit 1); exit 1; }; }
12156 fi
12157 cat >conftest.$ac_ext <<_ACEOF
12158 /* confdefs.h.  */
12159 _ACEOF
12160 cat confdefs.h >>conftest.$ac_ext
12161 cat >>conftest.$ac_ext <<_ACEOF
12162 /* end confdefs.h.  */
12163
12164 /* Override any gcc2 internal prototype to avoid an error.  */
12165 #ifdef __cplusplus
12166 extern "C"
12167 #endif
12168 /* We use char because int might match the return type of a gcc2
12169    builtin and then its argument prototype would still apply.  */
12170 char atanh ();
12171 int
12172 main ()
12173 {
12174 atanh ();
12175   ;
12176   return 0;
12177 }
12178 _ACEOF
12179 rm -f conftest.$ac_objext conftest$ac_exeext
12180 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12181   (eval $ac_link) 2>conftest.er1
12182   ac_status=$?
12183   grep -v '^ *+' conftest.er1 >conftest.err
12184   rm -f conftest.er1
12185   cat conftest.err >&5
12186   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12187   (exit $ac_status); } &&
12188          { ac_try='test -z "$ac_c_werror_flag"
12189                          || test ! -s conftest.err'
12190   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12191   (eval $ac_try) 2>&5
12192   ac_status=$?
12193   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12194   (exit $ac_status); }; } &&
12195          { ac_try='test -s conftest$ac_exeext'
12196   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12197   (eval $ac_try) 2>&5
12198   ac_status=$?
12199   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12200   (exit $ac_status); }; }; then
12201   ac_cv_lib_m_atanh=yes
12202 else
12203   echo "$as_me: failed program was:" >&5
12204 sed 's/^/| /' conftest.$ac_ext >&5
12205
12206 ac_cv_lib_m_atanh=no
12207 fi
12208 rm -f conftest.err conftest.$ac_objext \
12209       conftest$ac_exeext conftest.$ac_ext
12210 LIBS=$ac_check_lib_save_LIBS
12211 fi
12212 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanh" >&5
12213 echo "${ECHO_T}$ac_cv_lib_m_atanh" >&6
12214 if test $ac_cv_lib_m_atanh = yes; then
12215
12216 cat >>confdefs.h <<\_ACEOF
12217 #define HAVE_ATANH 1
12218 _ACEOF
12219
12220 fi
12221
12222 echo "$as_me:$LINENO: checking for atanhl in -lm" >&5
12223 echo $ECHO_N "checking for atanhl in -lm... $ECHO_C" >&6
12224 if test "${ac_cv_lib_m_atanhl+set}" = set; then
12225   echo $ECHO_N "(cached) $ECHO_C" >&6
12226 else
12227   ac_check_lib_save_LIBS=$LIBS
12228 LIBS="-lm  $LIBS"
12229 if test x$gcc_no_link = xyes; then
12230   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12231 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12232    { (exit 1); exit 1; }; }
12233 fi
12234 cat >conftest.$ac_ext <<_ACEOF
12235 /* confdefs.h.  */
12236 _ACEOF
12237 cat confdefs.h >>conftest.$ac_ext
12238 cat >>conftest.$ac_ext <<_ACEOF
12239 /* end confdefs.h.  */
12240
12241 /* Override any gcc2 internal prototype to avoid an error.  */
12242 #ifdef __cplusplus
12243 extern "C"
12244 #endif
12245 /* We use char because int might match the return type of a gcc2
12246    builtin and then its argument prototype would still apply.  */
12247 char atanhl ();
12248 int
12249 main ()
12250 {
12251 atanhl ();
12252   ;
12253   return 0;
12254 }
12255 _ACEOF
12256 rm -f conftest.$ac_objext conftest$ac_exeext
12257 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12258   (eval $ac_link) 2>conftest.er1
12259   ac_status=$?
12260   grep -v '^ *+' conftest.er1 >conftest.err
12261   rm -f conftest.er1
12262   cat conftest.err >&5
12263   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12264   (exit $ac_status); } &&
12265          { ac_try='test -z "$ac_c_werror_flag"
12266                          || test ! -s conftest.err'
12267   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12268   (eval $ac_try) 2>&5
12269   ac_status=$?
12270   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12271   (exit $ac_status); }; } &&
12272          { ac_try='test -s conftest$ac_exeext'
12273   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12274   (eval $ac_try) 2>&5
12275   ac_status=$?
12276   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12277   (exit $ac_status); }; }; then
12278   ac_cv_lib_m_atanhl=yes
12279 else
12280   echo "$as_me: failed program was:" >&5
12281 sed 's/^/| /' conftest.$ac_ext >&5
12282
12283 ac_cv_lib_m_atanhl=no
12284 fi
12285 rm -f conftest.err conftest.$ac_objext \
12286       conftest$ac_exeext conftest.$ac_ext
12287 LIBS=$ac_check_lib_save_LIBS
12288 fi
12289 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanhl" >&5
12290 echo "${ECHO_T}$ac_cv_lib_m_atanhl" >&6
12291 if test $ac_cv_lib_m_atanhl = yes; then
12292
12293 cat >>confdefs.h <<\_ACEOF
12294 #define HAVE_ATANHL 1
12295 _ACEOF
12296
12297 fi
12298
12299 echo "$as_me:$LINENO: checking for cargf in -lm" >&5
12300 echo $ECHO_N "checking for cargf in -lm... $ECHO_C" >&6
12301 if test "${ac_cv_lib_m_cargf+set}" = set; then
12302   echo $ECHO_N "(cached) $ECHO_C" >&6
12303 else
12304   ac_check_lib_save_LIBS=$LIBS
12305 LIBS="-lm  $LIBS"
12306 if test x$gcc_no_link = xyes; then
12307   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12308 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12309    { (exit 1); exit 1; }; }
12310 fi
12311 cat >conftest.$ac_ext <<_ACEOF
12312 /* confdefs.h.  */
12313 _ACEOF
12314 cat confdefs.h >>conftest.$ac_ext
12315 cat >>conftest.$ac_ext <<_ACEOF
12316 /* end confdefs.h.  */
12317
12318 /* Override any gcc2 internal prototype to avoid an error.  */
12319 #ifdef __cplusplus
12320 extern "C"
12321 #endif
12322 /* We use char because int might match the return type of a gcc2
12323    builtin and then its argument prototype would still apply.  */
12324 char cargf ();
12325 int
12326 main ()
12327 {
12328 cargf ();
12329   ;
12330   return 0;
12331 }
12332 _ACEOF
12333 rm -f conftest.$ac_objext conftest$ac_exeext
12334 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12335   (eval $ac_link) 2>conftest.er1
12336   ac_status=$?
12337   grep -v '^ *+' conftest.er1 >conftest.err
12338   rm -f conftest.er1
12339   cat conftest.err >&5
12340   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12341   (exit $ac_status); } &&
12342          { ac_try='test -z "$ac_c_werror_flag"
12343                          || test ! -s conftest.err'
12344   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12345   (eval $ac_try) 2>&5
12346   ac_status=$?
12347   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12348   (exit $ac_status); }; } &&
12349          { ac_try='test -s conftest$ac_exeext'
12350   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12351   (eval $ac_try) 2>&5
12352   ac_status=$?
12353   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12354   (exit $ac_status); }; }; then
12355   ac_cv_lib_m_cargf=yes
12356 else
12357   echo "$as_me: failed program was:" >&5
12358 sed 's/^/| /' conftest.$ac_ext >&5
12359
12360 ac_cv_lib_m_cargf=no
12361 fi
12362 rm -f conftest.err conftest.$ac_objext \
12363       conftest$ac_exeext conftest.$ac_ext
12364 LIBS=$ac_check_lib_save_LIBS
12365 fi
12366 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cargf" >&5
12367 echo "${ECHO_T}$ac_cv_lib_m_cargf" >&6
12368 if test $ac_cv_lib_m_cargf = yes; then
12369
12370 cat >>confdefs.h <<\_ACEOF
12371 #define HAVE_CARGF 1
12372 _ACEOF
12373
12374 fi
12375
12376 echo "$as_me:$LINENO: checking for carg in -lm" >&5
12377 echo $ECHO_N "checking for carg in -lm... $ECHO_C" >&6
12378 if test "${ac_cv_lib_m_carg+set}" = set; then
12379   echo $ECHO_N "(cached) $ECHO_C" >&6
12380 else
12381   ac_check_lib_save_LIBS=$LIBS
12382 LIBS="-lm  $LIBS"
12383 if test x$gcc_no_link = xyes; then
12384   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12385 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12386    { (exit 1); exit 1; }; }
12387 fi
12388 cat >conftest.$ac_ext <<_ACEOF
12389 /* confdefs.h.  */
12390 _ACEOF
12391 cat confdefs.h >>conftest.$ac_ext
12392 cat >>conftest.$ac_ext <<_ACEOF
12393 /* end confdefs.h.  */
12394
12395 /* Override any gcc2 internal prototype to avoid an error.  */
12396 #ifdef __cplusplus
12397 extern "C"
12398 #endif
12399 /* We use char because int might match the return type of a gcc2
12400    builtin and then its argument prototype would still apply.  */
12401 char carg ();
12402 int
12403 main ()
12404 {
12405 carg ();
12406   ;
12407   return 0;
12408 }
12409 _ACEOF
12410 rm -f conftest.$ac_objext conftest$ac_exeext
12411 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12412   (eval $ac_link) 2>conftest.er1
12413   ac_status=$?
12414   grep -v '^ *+' conftest.er1 >conftest.err
12415   rm -f conftest.er1
12416   cat conftest.err >&5
12417   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12418   (exit $ac_status); } &&
12419          { ac_try='test -z "$ac_c_werror_flag"
12420                          || test ! -s conftest.err'
12421   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12422   (eval $ac_try) 2>&5
12423   ac_status=$?
12424   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12425   (exit $ac_status); }; } &&
12426          { ac_try='test -s conftest$ac_exeext'
12427   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12428   (eval $ac_try) 2>&5
12429   ac_status=$?
12430   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12431   (exit $ac_status); }; }; then
12432   ac_cv_lib_m_carg=yes
12433 else
12434   echo "$as_me: failed program was:" >&5
12435 sed 's/^/| /' conftest.$ac_ext >&5
12436
12437 ac_cv_lib_m_carg=no
12438 fi
12439 rm -f conftest.err conftest.$ac_objext \
12440       conftest$ac_exeext conftest.$ac_ext
12441 LIBS=$ac_check_lib_save_LIBS
12442 fi
12443 echo "$as_me:$LINENO: result: $ac_cv_lib_m_carg" >&5
12444 echo "${ECHO_T}$ac_cv_lib_m_carg" >&6
12445 if test $ac_cv_lib_m_carg = yes; then
12446
12447 cat >>confdefs.h <<\_ACEOF
12448 #define HAVE_CARG 1
12449 _ACEOF
12450
12451 fi
12452
12453 echo "$as_me:$LINENO: checking for cargl in -lm" >&5
12454 echo $ECHO_N "checking for cargl in -lm... $ECHO_C" >&6
12455 if test "${ac_cv_lib_m_cargl+set}" = set; then
12456   echo $ECHO_N "(cached) $ECHO_C" >&6
12457 else
12458   ac_check_lib_save_LIBS=$LIBS
12459 LIBS="-lm  $LIBS"
12460 if test x$gcc_no_link = xyes; then
12461   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12462 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12463    { (exit 1); exit 1; }; }
12464 fi
12465 cat >conftest.$ac_ext <<_ACEOF
12466 /* confdefs.h.  */
12467 _ACEOF
12468 cat confdefs.h >>conftest.$ac_ext
12469 cat >>conftest.$ac_ext <<_ACEOF
12470 /* end confdefs.h.  */
12471
12472 /* Override any gcc2 internal prototype to avoid an error.  */
12473 #ifdef __cplusplus
12474 extern "C"
12475 #endif
12476 /* We use char because int might match the return type of a gcc2
12477    builtin and then its argument prototype would still apply.  */
12478 char cargl ();
12479 int
12480 main ()
12481 {
12482 cargl ();
12483   ;
12484   return 0;
12485 }
12486 _ACEOF
12487 rm -f conftest.$ac_objext conftest$ac_exeext
12488 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12489   (eval $ac_link) 2>conftest.er1
12490   ac_status=$?
12491   grep -v '^ *+' conftest.er1 >conftest.err
12492   rm -f conftest.er1
12493   cat conftest.err >&5
12494   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12495   (exit $ac_status); } &&
12496          { ac_try='test -z "$ac_c_werror_flag"
12497                          || test ! -s conftest.err'
12498   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12499   (eval $ac_try) 2>&5
12500   ac_status=$?
12501   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12502   (exit $ac_status); }; } &&
12503          { ac_try='test -s conftest$ac_exeext'
12504   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12505   (eval $ac_try) 2>&5
12506   ac_status=$?
12507   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12508   (exit $ac_status); }; }; then
12509   ac_cv_lib_m_cargl=yes
12510 else
12511   echo "$as_me: failed program was:" >&5
12512 sed 's/^/| /' conftest.$ac_ext >&5
12513
12514 ac_cv_lib_m_cargl=no
12515 fi
12516 rm -f conftest.err conftest.$ac_objext \
12517       conftest$ac_exeext conftest.$ac_ext
12518 LIBS=$ac_check_lib_save_LIBS
12519 fi
12520 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cargl" >&5
12521 echo "${ECHO_T}$ac_cv_lib_m_cargl" >&6
12522 if test $ac_cv_lib_m_cargl = yes; then
12523
12524 cat >>confdefs.h <<\_ACEOF
12525 #define HAVE_CARGL 1
12526 _ACEOF
12527
12528 fi
12529
12530 echo "$as_me:$LINENO: checking for ceilf in -lm" >&5
12531 echo $ECHO_N "checking for ceilf in -lm... $ECHO_C" >&6
12532 if test "${ac_cv_lib_m_ceilf+set}" = set; then
12533   echo $ECHO_N "(cached) $ECHO_C" >&6
12534 else
12535   ac_check_lib_save_LIBS=$LIBS
12536 LIBS="-lm  $LIBS"
12537 if test x$gcc_no_link = xyes; then
12538   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12539 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12540    { (exit 1); exit 1; }; }
12541 fi
12542 cat >conftest.$ac_ext <<_ACEOF
12543 /* confdefs.h.  */
12544 _ACEOF
12545 cat confdefs.h >>conftest.$ac_ext
12546 cat >>conftest.$ac_ext <<_ACEOF
12547 /* end confdefs.h.  */
12548
12549 /* Override any gcc2 internal prototype to avoid an error.  */
12550 #ifdef __cplusplus
12551 extern "C"
12552 #endif
12553 /* We use char because int might match the return type of a gcc2
12554    builtin and then its argument prototype would still apply.  */
12555 char ceilf ();
12556 int
12557 main ()
12558 {
12559 ceilf ();
12560   ;
12561   return 0;
12562 }
12563 _ACEOF
12564 rm -f conftest.$ac_objext conftest$ac_exeext
12565 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12566   (eval $ac_link) 2>conftest.er1
12567   ac_status=$?
12568   grep -v '^ *+' conftest.er1 >conftest.err
12569   rm -f conftest.er1
12570   cat conftest.err >&5
12571   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12572   (exit $ac_status); } &&
12573          { ac_try='test -z "$ac_c_werror_flag"
12574                          || test ! -s conftest.err'
12575   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12576   (eval $ac_try) 2>&5
12577   ac_status=$?
12578   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12579   (exit $ac_status); }; } &&
12580          { ac_try='test -s conftest$ac_exeext'
12581   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12582   (eval $ac_try) 2>&5
12583   ac_status=$?
12584   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12585   (exit $ac_status); }; }; then
12586   ac_cv_lib_m_ceilf=yes
12587 else
12588   echo "$as_me: failed program was:" >&5
12589 sed 's/^/| /' conftest.$ac_ext >&5
12590
12591 ac_cv_lib_m_ceilf=no
12592 fi
12593 rm -f conftest.err conftest.$ac_objext \
12594       conftest$ac_exeext conftest.$ac_ext
12595 LIBS=$ac_check_lib_save_LIBS
12596 fi
12597 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceilf" >&5
12598 echo "${ECHO_T}$ac_cv_lib_m_ceilf" >&6
12599 if test $ac_cv_lib_m_ceilf = yes; then
12600
12601 cat >>confdefs.h <<\_ACEOF
12602 #define HAVE_CEILF 1
12603 _ACEOF
12604
12605 fi
12606
12607 echo "$as_me:$LINENO: checking for ceil in -lm" >&5
12608 echo $ECHO_N "checking for ceil in -lm... $ECHO_C" >&6
12609 if test "${ac_cv_lib_m_ceil+set}" = set; then
12610   echo $ECHO_N "(cached) $ECHO_C" >&6
12611 else
12612   ac_check_lib_save_LIBS=$LIBS
12613 LIBS="-lm  $LIBS"
12614 if test x$gcc_no_link = xyes; then
12615   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12616 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12617    { (exit 1); exit 1; }; }
12618 fi
12619 cat >conftest.$ac_ext <<_ACEOF
12620 /* confdefs.h.  */
12621 _ACEOF
12622 cat confdefs.h >>conftest.$ac_ext
12623 cat >>conftest.$ac_ext <<_ACEOF
12624 /* end confdefs.h.  */
12625
12626 /* Override any gcc2 internal prototype to avoid an error.  */
12627 #ifdef __cplusplus
12628 extern "C"
12629 #endif
12630 /* We use char because int might match the return type of a gcc2
12631    builtin and then its argument prototype would still apply.  */
12632 char ceil ();
12633 int
12634 main ()
12635 {
12636 ceil ();
12637   ;
12638   return 0;
12639 }
12640 _ACEOF
12641 rm -f conftest.$ac_objext conftest$ac_exeext
12642 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12643   (eval $ac_link) 2>conftest.er1
12644   ac_status=$?
12645   grep -v '^ *+' conftest.er1 >conftest.err
12646   rm -f conftest.er1
12647   cat conftest.err >&5
12648   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12649   (exit $ac_status); } &&
12650          { ac_try='test -z "$ac_c_werror_flag"
12651                          || test ! -s conftest.err'
12652   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12653   (eval $ac_try) 2>&5
12654   ac_status=$?
12655   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12656   (exit $ac_status); }; } &&
12657          { ac_try='test -s conftest$ac_exeext'
12658   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12659   (eval $ac_try) 2>&5
12660   ac_status=$?
12661   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12662   (exit $ac_status); }; }; then
12663   ac_cv_lib_m_ceil=yes
12664 else
12665   echo "$as_me: failed program was:" >&5
12666 sed 's/^/| /' conftest.$ac_ext >&5
12667
12668 ac_cv_lib_m_ceil=no
12669 fi
12670 rm -f conftest.err conftest.$ac_objext \
12671       conftest$ac_exeext conftest.$ac_ext
12672 LIBS=$ac_check_lib_save_LIBS
12673 fi
12674 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceil" >&5
12675 echo "${ECHO_T}$ac_cv_lib_m_ceil" >&6
12676 if test $ac_cv_lib_m_ceil = yes; then
12677
12678 cat >>confdefs.h <<\_ACEOF
12679 #define HAVE_CEIL 1
12680 _ACEOF
12681
12682 fi
12683
12684 echo "$as_me:$LINENO: checking for ceill in -lm" >&5
12685 echo $ECHO_N "checking for ceill in -lm... $ECHO_C" >&6
12686 if test "${ac_cv_lib_m_ceill+set}" = set; then
12687   echo $ECHO_N "(cached) $ECHO_C" >&6
12688 else
12689   ac_check_lib_save_LIBS=$LIBS
12690 LIBS="-lm  $LIBS"
12691 if test x$gcc_no_link = xyes; then
12692   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12693 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12694    { (exit 1); exit 1; }; }
12695 fi
12696 cat >conftest.$ac_ext <<_ACEOF
12697 /* confdefs.h.  */
12698 _ACEOF
12699 cat confdefs.h >>conftest.$ac_ext
12700 cat >>conftest.$ac_ext <<_ACEOF
12701 /* end confdefs.h.  */
12702
12703 /* Override any gcc2 internal prototype to avoid an error.  */
12704 #ifdef __cplusplus
12705 extern "C"
12706 #endif
12707 /* We use char because int might match the return type of a gcc2
12708    builtin and then its argument prototype would still apply.  */
12709 char ceill ();
12710 int
12711 main ()
12712 {
12713 ceill ();
12714   ;
12715   return 0;
12716 }
12717 _ACEOF
12718 rm -f conftest.$ac_objext conftest$ac_exeext
12719 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12720   (eval $ac_link) 2>conftest.er1
12721   ac_status=$?
12722   grep -v '^ *+' conftest.er1 >conftest.err
12723   rm -f conftest.er1
12724   cat conftest.err >&5
12725   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12726   (exit $ac_status); } &&
12727          { ac_try='test -z "$ac_c_werror_flag"
12728                          || test ! -s conftest.err'
12729   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12730   (eval $ac_try) 2>&5
12731   ac_status=$?
12732   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12733   (exit $ac_status); }; } &&
12734          { ac_try='test -s conftest$ac_exeext'
12735   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12736   (eval $ac_try) 2>&5
12737   ac_status=$?
12738   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12739   (exit $ac_status); }; }; then
12740   ac_cv_lib_m_ceill=yes
12741 else
12742   echo "$as_me: failed program was:" >&5
12743 sed 's/^/| /' conftest.$ac_ext >&5
12744
12745 ac_cv_lib_m_ceill=no
12746 fi
12747 rm -f conftest.err conftest.$ac_objext \
12748       conftest$ac_exeext conftest.$ac_ext
12749 LIBS=$ac_check_lib_save_LIBS
12750 fi
12751 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceill" >&5
12752 echo "${ECHO_T}$ac_cv_lib_m_ceill" >&6
12753 if test $ac_cv_lib_m_ceill = yes; then
12754
12755 cat >>confdefs.h <<\_ACEOF
12756 #define HAVE_CEILL 1
12757 _ACEOF
12758
12759 fi
12760
12761 echo "$as_me:$LINENO: checking for copysignf in -lm" >&5
12762 echo $ECHO_N "checking for copysignf in -lm... $ECHO_C" >&6
12763 if test "${ac_cv_lib_m_copysignf+set}" = set; then
12764   echo $ECHO_N "(cached) $ECHO_C" >&6
12765 else
12766   ac_check_lib_save_LIBS=$LIBS
12767 LIBS="-lm  $LIBS"
12768 if test x$gcc_no_link = xyes; then
12769   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12770 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12771    { (exit 1); exit 1; }; }
12772 fi
12773 cat >conftest.$ac_ext <<_ACEOF
12774 /* confdefs.h.  */
12775 _ACEOF
12776 cat confdefs.h >>conftest.$ac_ext
12777 cat >>conftest.$ac_ext <<_ACEOF
12778 /* end confdefs.h.  */
12779
12780 /* Override any gcc2 internal prototype to avoid an error.  */
12781 #ifdef __cplusplus
12782 extern "C"
12783 #endif
12784 /* We use char because int might match the return type of a gcc2
12785    builtin and then its argument prototype would still apply.  */
12786 char copysignf ();
12787 int
12788 main ()
12789 {
12790 copysignf ();
12791   ;
12792   return 0;
12793 }
12794 _ACEOF
12795 rm -f conftest.$ac_objext conftest$ac_exeext
12796 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12797   (eval $ac_link) 2>conftest.er1
12798   ac_status=$?
12799   grep -v '^ *+' conftest.er1 >conftest.err
12800   rm -f conftest.er1
12801   cat conftest.err >&5
12802   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12803   (exit $ac_status); } &&
12804          { ac_try='test -z "$ac_c_werror_flag"
12805                          || test ! -s conftest.err'
12806   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12807   (eval $ac_try) 2>&5
12808   ac_status=$?
12809   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12810   (exit $ac_status); }; } &&
12811          { ac_try='test -s conftest$ac_exeext'
12812   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12813   (eval $ac_try) 2>&5
12814   ac_status=$?
12815   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12816   (exit $ac_status); }; }; then
12817   ac_cv_lib_m_copysignf=yes
12818 else
12819   echo "$as_me: failed program was:" >&5
12820 sed 's/^/| /' conftest.$ac_ext >&5
12821
12822 ac_cv_lib_m_copysignf=no
12823 fi
12824 rm -f conftest.err conftest.$ac_objext \
12825       conftest$ac_exeext conftest.$ac_ext
12826 LIBS=$ac_check_lib_save_LIBS
12827 fi
12828 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysignf" >&5
12829 echo "${ECHO_T}$ac_cv_lib_m_copysignf" >&6
12830 if test $ac_cv_lib_m_copysignf = yes; then
12831
12832 cat >>confdefs.h <<\_ACEOF
12833 #define HAVE_COPYSIGNF 1
12834 _ACEOF
12835
12836 fi
12837
12838 echo "$as_me:$LINENO: checking for copysign in -lm" >&5
12839 echo $ECHO_N "checking for copysign in -lm... $ECHO_C" >&6
12840 if test "${ac_cv_lib_m_copysign+set}" = set; then
12841   echo $ECHO_N "(cached) $ECHO_C" >&6
12842 else
12843   ac_check_lib_save_LIBS=$LIBS
12844 LIBS="-lm  $LIBS"
12845 if test x$gcc_no_link = xyes; then
12846   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12847 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12848    { (exit 1); exit 1; }; }
12849 fi
12850 cat >conftest.$ac_ext <<_ACEOF
12851 /* confdefs.h.  */
12852 _ACEOF
12853 cat confdefs.h >>conftest.$ac_ext
12854 cat >>conftest.$ac_ext <<_ACEOF
12855 /* end confdefs.h.  */
12856
12857 /* Override any gcc2 internal prototype to avoid an error.  */
12858 #ifdef __cplusplus
12859 extern "C"
12860 #endif
12861 /* We use char because int might match the return type of a gcc2
12862    builtin and then its argument prototype would still apply.  */
12863 char copysign ();
12864 int
12865 main ()
12866 {
12867 copysign ();
12868   ;
12869   return 0;
12870 }
12871 _ACEOF
12872 rm -f conftest.$ac_objext conftest$ac_exeext
12873 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12874   (eval $ac_link) 2>conftest.er1
12875   ac_status=$?
12876   grep -v '^ *+' conftest.er1 >conftest.err
12877   rm -f conftest.er1
12878   cat conftest.err >&5
12879   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12880   (exit $ac_status); } &&
12881          { ac_try='test -z "$ac_c_werror_flag"
12882                          || test ! -s conftest.err'
12883   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12884   (eval $ac_try) 2>&5
12885   ac_status=$?
12886   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12887   (exit $ac_status); }; } &&
12888          { ac_try='test -s conftest$ac_exeext'
12889   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12890   (eval $ac_try) 2>&5
12891   ac_status=$?
12892   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12893   (exit $ac_status); }; }; then
12894   ac_cv_lib_m_copysign=yes
12895 else
12896   echo "$as_me: failed program was:" >&5
12897 sed 's/^/| /' conftest.$ac_ext >&5
12898
12899 ac_cv_lib_m_copysign=no
12900 fi
12901 rm -f conftest.err conftest.$ac_objext \
12902       conftest$ac_exeext conftest.$ac_ext
12903 LIBS=$ac_check_lib_save_LIBS
12904 fi
12905 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysign" >&5
12906 echo "${ECHO_T}$ac_cv_lib_m_copysign" >&6
12907 if test $ac_cv_lib_m_copysign = yes; then
12908
12909 cat >>confdefs.h <<\_ACEOF
12910 #define HAVE_COPYSIGN 1
12911 _ACEOF
12912
12913 fi
12914
12915 echo "$as_me:$LINENO: checking for copysignl in -lm" >&5
12916 echo $ECHO_N "checking for copysignl in -lm... $ECHO_C" >&6
12917 if test "${ac_cv_lib_m_copysignl+set}" = set; then
12918   echo $ECHO_N "(cached) $ECHO_C" >&6
12919 else
12920   ac_check_lib_save_LIBS=$LIBS
12921 LIBS="-lm  $LIBS"
12922 if test x$gcc_no_link = xyes; then
12923   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12924 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12925    { (exit 1); exit 1; }; }
12926 fi
12927 cat >conftest.$ac_ext <<_ACEOF
12928 /* confdefs.h.  */
12929 _ACEOF
12930 cat confdefs.h >>conftest.$ac_ext
12931 cat >>conftest.$ac_ext <<_ACEOF
12932 /* end confdefs.h.  */
12933
12934 /* Override any gcc2 internal prototype to avoid an error.  */
12935 #ifdef __cplusplus
12936 extern "C"
12937 #endif
12938 /* We use char because int might match the return type of a gcc2
12939    builtin and then its argument prototype would still apply.  */
12940 char copysignl ();
12941 int
12942 main ()
12943 {
12944 copysignl ();
12945   ;
12946   return 0;
12947 }
12948 _ACEOF
12949 rm -f conftest.$ac_objext conftest$ac_exeext
12950 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12951   (eval $ac_link) 2>conftest.er1
12952   ac_status=$?
12953   grep -v '^ *+' conftest.er1 >conftest.err
12954   rm -f conftest.er1
12955   cat conftest.err >&5
12956   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12957   (exit $ac_status); } &&
12958          { ac_try='test -z "$ac_c_werror_flag"
12959                          || test ! -s conftest.err'
12960   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12961   (eval $ac_try) 2>&5
12962   ac_status=$?
12963   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12964   (exit $ac_status); }; } &&
12965          { ac_try='test -s conftest$ac_exeext'
12966   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12967   (eval $ac_try) 2>&5
12968   ac_status=$?
12969   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12970   (exit $ac_status); }; }; then
12971   ac_cv_lib_m_copysignl=yes
12972 else
12973   echo "$as_me: failed program was:" >&5
12974 sed 's/^/| /' conftest.$ac_ext >&5
12975
12976 ac_cv_lib_m_copysignl=no
12977 fi
12978 rm -f conftest.err conftest.$ac_objext \
12979       conftest$ac_exeext conftest.$ac_ext
12980 LIBS=$ac_check_lib_save_LIBS
12981 fi
12982 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysignl" >&5
12983 echo "${ECHO_T}$ac_cv_lib_m_copysignl" >&6
12984 if test $ac_cv_lib_m_copysignl = yes; then
12985
12986 cat >>confdefs.h <<\_ACEOF
12987 #define HAVE_COPYSIGNL 1
12988 _ACEOF
12989
12990 fi
12991
12992 echo "$as_me:$LINENO: checking for cosf in -lm" >&5
12993 echo $ECHO_N "checking for cosf in -lm... $ECHO_C" >&6
12994 if test "${ac_cv_lib_m_cosf+set}" = set; then
12995   echo $ECHO_N "(cached) $ECHO_C" >&6
12996 else
12997   ac_check_lib_save_LIBS=$LIBS
12998 LIBS="-lm  $LIBS"
12999 if test x$gcc_no_link = xyes; then
13000   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13001 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13002    { (exit 1); exit 1; }; }
13003 fi
13004 cat >conftest.$ac_ext <<_ACEOF
13005 /* confdefs.h.  */
13006 _ACEOF
13007 cat confdefs.h >>conftest.$ac_ext
13008 cat >>conftest.$ac_ext <<_ACEOF
13009 /* end confdefs.h.  */
13010
13011 /* Override any gcc2 internal prototype to avoid an error.  */
13012 #ifdef __cplusplus
13013 extern "C"
13014 #endif
13015 /* We use char because int might match the return type of a gcc2
13016    builtin and then its argument prototype would still apply.  */
13017 char cosf ();
13018 int
13019 main ()
13020 {
13021 cosf ();
13022   ;
13023   return 0;
13024 }
13025 _ACEOF
13026 rm -f conftest.$ac_objext conftest$ac_exeext
13027 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13028   (eval $ac_link) 2>conftest.er1
13029   ac_status=$?
13030   grep -v '^ *+' conftest.er1 >conftest.err
13031   rm -f conftest.er1
13032   cat conftest.err >&5
13033   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13034   (exit $ac_status); } &&
13035          { ac_try='test -z "$ac_c_werror_flag"
13036                          || test ! -s conftest.err'
13037   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13038   (eval $ac_try) 2>&5
13039   ac_status=$?
13040   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13041   (exit $ac_status); }; } &&
13042          { ac_try='test -s conftest$ac_exeext'
13043   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13044   (eval $ac_try) 2>&5
13045   ac_status=$?
13046   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13047   (exit $ac_status); }; }; then
13048   ac_cv_lib_m_cosf=yes
13049 else
13050   echo "$as_me: failed program was:" >&5
13051 sed 's/^/| /' conftest.$ac_ext >&5
13052
13053 ac_cv_lib_m_cosf=no
13054 fi
13055 rm -f conftest.err conftest.$ac_objext \
13056       conftest$ac_exeext conftest.$ac_ext
13057 LIBS=$ac_check_lib_save_LIBS
13058 fi
13059 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosf" >&5
13060 echo "${ECHO_T}$ac_cv_lib_m_cosf" >&6
13061 if test $ac_cv_lib_m_cosf = yes; then
13062
13063 cat >>confdefs.h <<\_ACEOF
13064 #define HAVE_COSF 1
13065 _ACEOF
13066
13067 fi
13068
13069 echo "$as_me:$LINENO: checking for cos in -lm" >&5
13070 echo $ECHO_N "checking for cos in -lm... $ECHO_C" >&6
13071 if test "${ac_cv_lib_m_cos+set}" = set; then
13072   echo $ECHO_N "(cached) $ECHO_C" >&6
13073 else
13074   ac_check_lib_save_LIBS=$LIBS
13075 LIBS="-lm  $LIBS"
13076 if test x$gcc_no_link = xyes; then
13077   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13078 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13079    { (exit 1); exit 1; }; }
13080 fi
13081 cat >conftest.$ac_ext <<_ACEOF
13082 /* confdefs.h.  */
13083 _ACEOF
13084 cat confdefs.h >>conftest.$ac_ext
13085 cat >>conftest.$ac_ext <<_ACEOF
13086 /* end confdefs.h.  */
13087
13088 /* Override any gcc2 internal prototype to avoid an error.  */
13089 #ifdef __cplusplus
13090 extern "C"
13091 #endif
13092 /* We use char because int might match the return type of a gcc2
13093    builtin and then its argument prototype would still apply.  */
13094 char cos ();
13095 int
13096 main ()
13097 {
13098 cos ();
13099   ;
13100   return 0;
13101 }
13102 _ACEOF
13103 rm -f conftest.$ac_objext conftest$ac_exeext
13104 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13105   (eval $ac_link) 2>conftest.er1
13106   ac_status=$?
13107   grep -v '^ *+' conftest.er1 >conftest.err
13108   rm -f conftest.er1
13109   cat conftest.err >&5
13110   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13111   (exit $ac_status); } &&
13112          { ac_try='test -z "$ac_c_werror_flag"
13113                          || test ! -s conftest.err'
13114   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13115   (eval $ac_try) 2>&5
13116   ac_status=$?
13117   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13118   (exit $ac_status); }; } &&
13119          { ac_try='test -s conftest$ac_exeext'
13120   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13121   (eval $ac_try) 2>&5
13122   ac_status=$?
13123   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13124   (exit $ac_status); }; }; then
13125   ac_cv_lib_m_cos=yes
13126 else
13127   echo "$as_me: failed program was:" >&5
13128 sed 's/^/| /' conftest.$ac_ext >&5
13129
13130 ac_cv_lib_m_cos=no
13131 fi
13132 rm -f conftest.err conftest.$ac_objext \
13133       conftest$ac_exeext conftest.$ac_ext
13134 LIBS=$ac_check_lib_save_LIBS
13135 fi
13136 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cos" >&5
13137 echo "${ECHO_T}$ac_cv_lib_m_cos" >&6
13138 if test $ac_cv_lib_m_cos = yes; then
13139
13140 cat >>confdefs.h <<\_ACEOF
13141 #define HAVE_COS 1
13142 _ACEOF
13143
13144 fi
13145
13146 echo "$as_me:$LINENO: checking for cosl in -lm" >&5
13147 echo $ECHO_N "checking for cosl in -lm... $ECHO_C" >&6
13148 if test "${ac_cv_lib_m_cosl+set}" = set; then
13149   echo $ECHO_N "(cached) $ECHO_C" >&6
13150 else
13151   ac_check_lib_save_LIBS=$LIBS
13152 LIBS="-lm  $LIBS"
13153 if test x$gcc_no_link = xyes; then
13154   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13155 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13156    { (exit 1); exit 1; }; }
13157 fi
13158 cat >conftest.$ac_ext <<_ACEOF
13159 /* confdefs.h.  */
13160 _ACEOF
13161 cat confdefs.h >>conftest.$ac_ext
13162 cat >>conftest.$ac_ext <<_ACEOF
13163 /* end confdefs.h.  */
13164
13165 /* Override any gcc2 internal prototype to avoid an error.  */
13166 #ifdef __cplusplus
13167 extern "C"
13168 #endif
13169 /* We use char because int might match the return type of a gcc2
13170    builtin and then its argument prototype would still apply.  */
13171 char cosl ();
13172 int
13173 main ()
13174 {
13175 cosl ();
13176   ;
13177   return 0;
13178 }
13179 _ACEOF
13180 rm -f conftest.$ac_objext conftest$ac_exeext
13181 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13182   (eval $ac_link) 2>conftest.er1
13183   ac_status=$?
13184   grep -v '^ *+' conftest.er1 >conftest.err
13185   rm -f conftest.er1
13186   cat conftest.err >&5
13187   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13188   (exit $ac_status); } &&
13189          { ac_try='test -z "$ac_c_werror_flag"
13190                          || test ! -s conftest.err'
13191   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13192   (eval $ac_try) 2>&5
13193   ac_status=$?
13194   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13195   (exit $ac_status); }; } &&
13196          { ac_try='test -s conftest$ac_exeext'
13197   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13198   (eval $ac_try) 2>&5
13199   ac_status=$?
13200   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13201   (exit $ac_status); }; }; then
13202   ac_cv_lib_m_cosl=yes
13203 else
13204   echo "$as_me: failed program was:" >&5
13205 sed 's/^/| /' conftest.$ac_ext >&5
13206
13207 ac_cv_lib_m_cosl=no
13208 fi
13209 rm -f conftest.err conftest.$ac_objext \
13210       conftest$ac_exeext conftest.$ac_ext
13211 LIBS=$ac_check_lib_save_LIBS
13212 fi
13213 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosl" >&5
13214 echo "${ECHO_T}$ac_cv_lib_m_cosl" >&6
13215 if test $ac_cv_lib_m_cosl = yes; then
13216
13217 cat >>confdefs.h <<\_ACEOF
13218 #define HAVE_COSL 1
13219 _ACEOF
13220
13221 fi
13222
13223 echo "$as_me:$LINENO: checking for ccosf in -lm" >&5
13224 echo $ECHO_N "checking for ccosf in -lm... $ECHO_C" >&6
13225 if test "${ac_cv_lib_m_ccosf+set}" = set; then
13226   echo $ECHO_N "(cached) $ECHO_C" >&6
13227 else
13228   ac_check_lib_save_LIBS=$LIBS
13229 LIBS="-lm  $LIBS"
13230 if test x$gcc_no_link = xyes; then
13231   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13232 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13233    { (exit 1); exit 1; }; }
13234 fi
13235 cat >conftest.$ac_ext <<_ACEOF
13236 /* confdefs.h.  */
13237 _ACEOF
13238 cat confdefs.h >>conftest.$ac_ext
13239 cat >>conftest.$ac_ext <<_ACEOF
13240 /* end confdefs.h.  */
13241
13242 /* Override any gcc2 internal prototype to avoid an error.  */
13243 #ifdef __cplusplus
13244 extern "C"
13245 #endif
13246 /* We use char because int might match the return type of a gcc2
13247    builtin and then its argument prototype would still apply.  */
13248 char ccosf ();
13249 int
13250 main ()
13251 {
13252 ccosf ();
13253   ;
13254   return 0;
13255 }
13256 _ACEOF
13257 rm -f conftest.$ac_objext conftest$ac_exeext
13258 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13259   (eval $ac_link) 2>conftest.er1
13260   ac_status=$?
13261   grep -v '^ *+' conftest.er1 >conftest.err
13262   rm -f conftest.er1
13263   cat conftest.err >&5
13264   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13265   (exit $ac_status); } &&
13266          { ac_try='test -z "$ac_c_werror_flag"
13267                          || test ! -s conftest.err'
13268   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13269   (eval $ac_try) 2>&5
13270   ac_status=$?
13271   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13272   (exit $ac_status); }; } &&
13273          { ac_try='test -s conftest$ac_exeext'
13274   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13275   (eval $ac_try) 2>&5
13276   ac_status=$?
13277   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13278   (exit $ac_status); }; }; then
13279   ac_cv_lib_m_ccosf=yes
13280 else
13281   echo "$as_me: failed program was:" >&5
13282 sed 's/^/| /' conftest.$ac_ext >&5
13283
13284 ac_cv_lib_m_ccosf=no
13285 fi
13286 rm -f conftest.err conftest.$ac_objext \
13287       conftest$ac_exeext conftest.$ac_ext
13288 LIBS=$ac_check_lib_save_LIBS
13289 fi
13290 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosf" >&5
13291 echo "${ECHO_T}$ac_cv_lib_m_ccosf" >&6
13292 if test $ac_cv_lib_m_ccosf = yes; then
13293
13294 cat >>confdefs.h <<\_ACEOF
13295 #define HAVE_CCOSF 1
13296 _ACEOF
13297
13298 fi
13299
13300 echo "$as_me:$LINENO: checking for ccos in -lm" >&5
13301 echo $ECHO_N "checking for ccos in -lm... $ECHO_C" >&6
13302 if test "${ac_cv_lib_m_ccos+set}" = set; then
13303   echo $ECHO_N "(cached) $ECHO_C" >&6
13304 else
13305   ac_check_lib_save_LIBS=$LIBS
13306 LIBS="-lm  $LIBS"
13307 if test x$gcc_no_link = xyes; then
13308   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13309 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13310    { (exit 1); exit 1; }; }
13311 fi
13312 cat >conftest.$ac_ext <<_ACEOF
13313 /* confdefs.h.  */
13314 _ACEOF
13315 cat confdefs.h >>conftest.$ac_ext
13316 cat >>conftest.$ac_ext <<_ACEOF
13317 /* end confdefs.h.  */
13318
13319 /* Override any gcc2 internal prototype to avoid an error.  */
13320 #ifdef __cplusplus
13321 extern "C"
13322 #endif
13323 /* We use char because int might match the return type of a gcc2
13324    builtin and then its argument prototype would still apply.  */
13325 char ccos ();
13326 int
13327 main ()
13328 {
13329 ccos ();
13330   ;
13331   return 0;
13332 }
13333 _ACEOF
13334 rm -f conftest.$ac_objext conftest$ac_exeext
13335 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13336   (eval $ac_link) 2>conftest.er1
13337   ac_status=$?
13338   grep -v '^ *+' conftest.er1 >conftest.err
13339   rm -f conftest.er1
13340   cat conftest.err >&5
13341   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13342   (exit $ac_status); } &&
13343          { ac_try='test -z "$ac_c_werror_flag"
13344                          || test ! -s conftest.err'
13345   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13346   (eval $ac_try) 2>&5
13347   ac_status=$?
13348   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13349   (exit $ac_status); }; } &&
13350          { ac_try='test -s conftest$ac_exeext'
13351   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13352   (eval $ac_try) 2>&5
13353   ac_status=$?
13354   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13355   (exit $ac_status); }; }; then
13356   ac_cv_lib_m_ccos=yes
13357 else
13358   echo "$as_me: failed program was:" >&5
13359 sed 's/^/| /' conftest.$ac_ext >&5
13360
13361 ac_cv_lib_m_ccos=no
13362 fi
13363 rm -f conftest.err conftest.$ac_objext \
13364       conftest$ac_exeext conftest.$ac_ext
13365 LIBS=$ac_check_lib_save_LIBS
13366 fi
13367 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccos" >&5
13368 echo "${ECHO_T}$ac_cv_lib_m_ccos" >&6
13369 if test $ac_cv_lib_m_ccos = yes; then
13370
13371 cat >>confdefs.h <<\_ACEOF
13372 #define HAVE_CCOS 1
13373 _ACEOF
13374
13375 fi
13376
13377 echo "$as_me:$LINENO: checking for ccosl in -lm" >&5
13378 echo $ECHO_N "checking for ccosl in -lm... $ECHO_C" >&6
13379 if test "${ac_cv_lib_m_ccosl+set}" = set; then
13380   echo $ECHO_N "(cached) $ECHO_C" >&6
13381 else
13382   ac_check_lib_save_LIBS=$LIBS
13383 LIBS="-lm  $LIBS"
13384 if test x$gcc_no_link = xyes; then
13385   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13386 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13387    { (exit 1); exit 1; }; }
13388 fi
13389 cat >conftest.$ac_ext <<_ACEOF
13390 /* confdefs.h.  */
13391 _ACEOF
13392 cat confdefs.h >>conftest.$ac_ext
13393 cat >>conftest.$ac_ext <<_ACEOF
13394 /* end confdefs.h.  */
13395
13396 /* Override any gcc2 internal prototype to avoid an error.  */
13397 #ifdef __cplusplus
13398 extern "C"
13399 #endif
13400 /* We use char because int might match the return type of a gcc2
13401    builtin and then its argument prototype would still apply.  */
13402 char ccosl ();
13403 int
13404 main ()
13405 {
13406 ccosl ();
13407   ;
13408   return 0;
13409 }
13410 _ACEOF
13411 rm -f conftest.$ac_objext conftest$ac_exeext
13412 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13413   (eval $ac_link) 2>conftest.er1
13414   ac_status=$?
13415   grep -v '^ *+' conftest.er1 >conftest.err
13416   rm -f conftest.er1
13417   cat conftest.err >&5
13418   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13419   (exit $ac_status); } &&
13420          { ac_try='test -z "$ac_c_werror_flag"
13421                          || test ! -s conftest.err'
13422   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13423   (eval $ac_try) 2>&5
13424   ac_status=$?
13425   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13426   (exit $ac_status); }; } &&
13427          { ac_try='test -s conftest$ac_exeext'
13428   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13429   (eval $ac_try) 2>&5
13430   ac_status=$?
13431   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13432   (exit $ac_status); }; }; then
13433   ac_cv_lib_m_ccosl=yes
13434 else
13435   echo "$as_me: failed program was:" >&5
13436 sed 's/^/| /' conftest.$ac_ext >&5
13437
13438 ac_cv_lib_m_ccosl=no
13439 fi
13440 rm -f conftest.err conftest.$ac_objext \
13441       conftest$ac_exeext conftest.$ac_ext
13442 LIBS=$ac_check_lib_save_LIBS
13443 fi
13444 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosl" >&5
13445 echo "${ECHO_T}$ac_cv_lib_m_ccosl" >&6
13446 if test $ac_cv_lib_m_ccosl = yes; then
13447
13448 cat >>confdefs.h <<\_ACEOF
13449 #define HAVE_CCOSL 1
13450 _ACEOF
13451
13452 fi
13453
13454 echo "$as_me:$LINENO: checking for coshf in -lm" >&5
13455 echo $ECHO_N "checking for coshf in -lm... $ECHO_C" >&6
13456 if test "${ac_cv_lib_m_coshf+set}" = set; then
13457   echo $ECHO_N "(cached) $ECHO_C" >&6
13458 else
13459   ac_check_lib_save_LIBS=$LIBS
13460 LIBS="-lm  $LIBS"
13461 if test x$gcc_no_link = xyes; then
13462   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13463 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13464    { (exit 1); exit 1; }; }
13465 fi
13466 cat >conftest.$ac_ext <<_ACEOF
13467 /* confdefs.h.  */
13468 _ACEOF
13469 cat confdefs.h >>conftest.$ac_ext
13470 cat >>conftest.$ac_ext <<_ACEOF
13471 /* end confdefs.h.  */
13472
13473 /* Override any gcc2 internal prototype to avoid an error.  */
13474 #ifdef __cplusplus
13475 extern "C"
13476 #endif
13477 /* We use char because int might match the return type of a gcc2
13478    builtin and then its argument prototype would still apply.  */
13479 char coshf ();
13480 int
13481 main ()
13482 {
13483 coshf ();
13484   ;
13485   return 0;
13486 }
13487 _ACEOF
13488 rm -f conftest.$ac_objext conftest$ac_exeext
13489 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13490   (eval $ac_link) 2>conftest.er1
13491   ac_status=$?
13492   grep -v '^ *+' conftest.er1 >conftest.err
13493   rm -f conftest.er1
13494   cat conftest.err >&5
13495   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13496   (exit $ac_status); } &&
13497          { ac_try='test -z "$ac_c_werror_flag"
13498                          || test ! -s conftest.err'
13499   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13500   (eval $ac_try) 2>&5
13501   ac_status=$?
13502   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13503   (exit $ac_status); }; } &&
13504          { ac_try='test -s conftest$ac_exeext'
13505   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13506   (eval $ac_try) 2>&5
13507   ac_status=$?
13508   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13509   (exit $ac_status); }; }; then
13510   ac_cv_lib_m_coshf=yes
13511 else
13512   echo "$as_me: failed program was:" >&5
13513 sed 's/^/| /' conftest.$ac_ext >&5
13514
13515 ac_cv_lib_m_coshf=no
13516 fi
13517 rm -f conftest.err conftest.$ac_objext \
13518       conftest$ac_exeext conftest.$ac_ext
13519 LIBS=$ac_check_lib_save_LIBS
13520 fi
13521 echo "$as_me:$LINENO: result: $ac_cv_lib_m_coshf" >&5
13522 echo "${ECHO_T}$ac_cv_lib_m_coshf" >&6
13523 if test $ac_cv_lib_m_coshf = yes; then
13524
13525 cat >>confdefs.h <<\_ACEOF
13526 #define HAVE_COSHF 1
13527 _ACEOF
13528
13529 fi
13530
13531 echo "$as_me:$LINENO: checking for cosh in -lm" >&5
13532 echo $ECHO_N "checking for cosh in -lm... $ECHO_C" >&6
13533 if test "${ac_cv_lib_m_cosh+set}" = set; then
13534   echo $ECHO_N "(cached) $ECHO_C" >&6
13535 else
13536   ac_check_lib_save_LIBS=$LIBS
13537 LIBS="-lm  $LIBS"
13538 if test x$gcc_no_link = xyes; then
13539   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13540 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13541    { (exit 1); exit 1; }; }
13542 fi
13543 cat >conftest.$ac_ext <<_ACEOF
13544 /* confdefs.h.  */
13545 _ACEOF
13546 cat confdefs.h >>conftest.$ac_ext
13547 cat >>conftest.$ac_ext <<_ACEOF
13548 /* end confdefs.h.  */
13549
13550 /* Override any gcc2 internal prototype to avoid an error.  */
13551 #ifdef __cplusplus
13552 extern "C"
13553 #endif
13554 /* We use char because int might match the return type of a gcc2
13555    builtin and then its argument prototype would still apply.  */
13556 char cosh ();
13557 int
13558 main ()
13559 {
13560 cosh ();
13561   ;
13562   return 0;
13563 }
13564 _ACEOF
13565 rm -f conftest.$ac_objext conftest$ac_exeext
13566 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13567   (eval $ac_link) 2>conftest.er1
13568   ac_status=$?
13569   grep -v '^ *+' conftest.er1 >conftest.err
13570   rm -f conftest.er1
13571   cat conftest.err >&5
13572   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13573   (exit $ac_status); } &&
13574          { ac_try='test -z "$ac_c_werror_flag"
13575                          || test ! -s conftest.err'
13576   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13577   (eval $ac_try) 2>&5
13578   ac_status=$?
13579   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13580   (exit $ac_status); }; } &&
13581          { ac_try='test -s conftest$ac_exeext'
13582   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13583   (eval $ac_try) 2>&5
13584   ac_status=$?
13585   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13586   (exit $ac_status); }; }; then
13587   ac_cv_lib_m_cosh=yes
13588 else
13589   echo "$as_me: failed program was:" >&5
13590 sed 's/^/| /' conftest.$ac_ext >&5
13591
13592 ac_cv_lib_m_cosh=no
13593 fi
13594 rm -f conftest.err conftest.$ac_objext \
13595       conftest$ac_exeext conftest.$ac_ext
13596 LIBS=$ac_check_lib_save_LIBS
13597 fi
13598 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosh" >&5
13599 echo "${ECHO_T}$ac_cv_lib_m_cosh" >&6
13600 if test $ac_cv_lib_m_cosh = yes; then
13601
13602 cat >>confdefs.h <<\_ACEOF
13603 #define HAVE_COSH 1
13604 _ACEOF
13605
13606 fi
13607
13608 echo "$as_me:$LINENO: checking for coshl in -lm" >&5
13609 echo $ECHO_N "checking for coshl in -lm... $ECHO_C" >&6
13610 if test "${ac_cv_lib_m_coshl+set}" = set; then
13611   echo $ECHO_N "(cached) $ECHO_C" >&6
13612 else
13613   ac_check_lib_save_LIBS=$LIBS
13614 LIBS="-lm  $LIBS"
13615 if test x$gcc_no_link = xyes; then
13616   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13617 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13618    { (exit 1); exit 1; }; }
13619 fi
13620 cat >conftest.$ac_ext <<_ACEOF
13621 /* confdefs.h.  */
13622 _ACEOF
13623 cat confdefs.h >>conftest.$ac_ext
13624 cat >>conftest.$ac_ext <<_ACEOF
13625 /* end confdefs.h.  */
13626
13627 /* Override any gcc2 internal prototype to avoid an error.  */
13628 #ifdef __cplusplus
13629 extern "C"
13630 #endif
13631 /* We use char because int might match the return type of a gcc2
13632    builtin and then its argument prototype would still apply.  */
13633 char coshl ();
13634 int
13635 main ()
13636 {
13637 coshl ();
13638   ;
13639   return 0;
13640 }
13641 _ACEOF
13642 rm -f conftest.$ac_objext conftest$ac_exeext
13643 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13644   (eval $ac_link) 2>conftest.er1
13645   ac_status=$?
13646   grep -v '^ *+' conftest.er1 >conftest.err
13647   rm -f conftest.er1
13648   cat conftest.err >&5
13649   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13650   (exit $ac_status); } &&
13651          { ac_try='test -z "$ac_c_werror_flag"
13652                          || test ! -s conftest.err'
13653   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13654   (eval $ac_try) 2>&5
13655   ac_status=$?
13656   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13657   (exit $ac_status); }; } &&
13658          { ac_try='test -s conftest$ac_exeext'
13659   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13660   (eval $ac_try) 2>&5
13661   ac_status=$?
13662   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13663   (exit $ac_status); }; }; then
13664   ac_cv_lib_m_coshl=yes
13665 else
13666   echo "$as_me: failed program was:" >&5
13667 sed 's/^/| /' conftest.$ac_ext >&5
13668
13669 ac_cv_lib_m_coshl=no
13670 fi
13671 rm -f conftest.err conftest.$ac_objext \
13672       conftest$ac_exeext conftest.$ac_ext
13673 LIBS=$ac_check_lib_save_LIBS
13674 fi
13675 echo "$as_me:$LINENO: result: $ac_cv_lib_m_coshl" >&5
13676 echo "${ECHO_T}$ac_cv_lib_m_coshl" >&6
13677 if test $ac_cv_lib_m_coshl = yes; then
13678
13679 cat >>confdefs.h <<\_ACEOF
13680 #define HAVE_COSHL 1
13681 _ACEOF
13682
13683 fi
13684
13685 echo "$as_me:$LINENO: checking for ccoshf in -lm" >&5
13686 echo $ECHO_N "checking for ccoshf in -lm... $ECHO_C" >&6
13687 if test "${ac_cv_lib_m_ccoshf+set}" = set; then
13688   echo $ECHO_N "(cached) $ECHO_C" >&6
13689 else
13690   ac_check_lib_save_LIBS=$LIBS
13691 LIBS="-lm  $LIBS"
13692 if test x$gcc_no_link = xyes; then
13693   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13694 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13695    { (exit 1); exit 1; }; }
13696 fi
13697 cat >conftest.$ac_ext <<_ACEOF
13698 /* confdefs.h.  */
13699 _ACEOF
13700 cat confdefs.h >>conftest.$ac_ext
13701 cat >>conftest.$ac_ext <<_ACEOF
13702 /* end confdefs.h.  */
13703
13704 /* Override any gcc2 internal prototype to avoid an error.  */
13705 #ifdef __cplusplus
13706 extern "C"
13707 #endif
13708 /* We use char because int might match the return type of a gcc2
13709    builtin and then its argument prototype would still apply.  */
13710 char ccoshf ();
13711 int
13712 main ()
13713 {
13714 ccoshf ();
13715   ;
13716   return 0;
13717 }
13718 _ACEOF
13719 rm -f conftest.$ac_objext conftest$ac_exeext
13720 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13721   (eval $ac_link) 2>conftest.er1
13722   ac_status=$?
13723   grep -v '^ *+' conftest.er1 >conftest.err
13724   rm -f conftest.er1
13725   cat conftest.err >&5
13726   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13727   (exit $ac_status); } &&
13728          { ac_try='test -z "$ac_c_werror_flag"
13729                          || test ! -s conftest.err'
13730   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13731   (eval $ac_try) 2>&5
13732   ac_status=$?
13733   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13734   (exit $ac_status); }; } &&
13735          { ac_try='test -s conftest$ac_exeext'
13736   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13737   (eval $ac_try) 2>&5
13738   ac_status=$?
13739   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13740   (exit $ac_status); }; }; then
13741   ac_cv_lib_m_ccoshf=yes
13742 else
13743   echo "$as_me: failed program was:" >&5
13744 sed 's/^/| /' conftest.$ac_ext >&5
13745
13746 ac_cv_lib_m_ccoshf=no
13747 fi
13748 rm -f conftest.err conftest.$ac_objext \
13749       conftest$ac_exeext conftest.$ac_ext
13750 LIBS=$ac_check_lib_save_LIBS
13751 fi
13752 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccoshf" >&5
13753 echo "${ECHO_T}$ac_cv_lib_m_ccoshf" >&6
13754 if test $ac_cv_lib_m_ccoshf = yes; then
13755
13756 cat >>confdefs.h <<\_ACEOF
13757 #define HAVE_CCOSHF 1
13758 _ACEOF
13759
13760 fi
13761
13762 echo "$as_me:$LINENO: checking for ccosh in -lm" >&5
13763 echo $ECHO_N "checking for ccosh in -lm... $ECHO_C" >&6
13764 if test "${ac_cv_lib_m_ccosh+set}" = set; then
13765   echo $ECHO_N "(cached) $ECHO_C" >&6
13766 else
13767   ac_check_lib_save_LIBS=$LIBS
13768 LIBS="-lm  $LIBS"
13769 if test x$gcc_no_link = xyes; then
13770   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13771 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13772    { (exit 1); exit 1; }; }
13773 fi
13774 cat >conftest.$ac_ext <<_ACEOF
13775 /* confdefs.h.  */
13776 _ACEOF
13777 cat confdefs.h >>conftest.$ac_ext
13778 cat >>conftest.$ac_ext <<_ACEOF
13779 /* end confdefs.h.  */
13780
13781 /* Override any gcc2 internal prototype to avoid an error.  */
13782 #ifdef __cplusplus
13783 extern "C"
13784 #endif
13785 /* We use char because int might match the return type of a gcc2
13786    builtin and then its argument prototype would still apply.  */
13787 char ccosh ();
13788 int
13789 main ()
13790 {
13791 ccosh ();
13792   ;
13793   return 0;
13794 }
13795 _ACEOF
13796 rm -f conftest.$ac_objext conftest$ac_exeext
13797 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13798   (eval $ac_link) 2>conftest.er1
13799   ac_status=$?
13800   grep -v '^ *+' conftest.er1 >conftest.err
13801   rm -f conftest.er1
13802   cat conftest.err >&5
13803   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13804   (exit $ac_status); } &&
13805          { ac_try='test -z "$ac_c_werror_flag"
13806                          || test ! -s conftest.err'
13807   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13808   (eval $ac_try) 2>&5
13809   ac_status=$?
13810   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13811   (exit $ac_status); }; } &&
13812          { ac_try='test -s conftest$ac_exeext'
13813   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13814   (eval $ac_try) 2>&5
13815   ac_status=$?
13816   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13817   (exit $ac_status); }; }; then
13818   ac_cv_lib_m_ccosh=yes
13819 else
13820   echo "$as_me: failed program was:" >&5
13821 sed 's/^/| /' conftest.$ac_ext >&5
13822
13823 ac_cv_lib_m_ccosh=no
13824 fi
13825 rm -f conftest.err conftest.$ac_objext \
13826       conftest$ac_exeext conftest.$ac_ext
13827 LIBS=$ac_check_lib_save_LIBS
13828 fi
13829 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosh" >&5
13830 echo "${ECHO_T}$ac_cv_lib_m_ccosh" >&6
13831 if test $ac_cv_lib_m_ccosh = yes; then
13832
13833 cat >>confdefs.h <<\_ACEOF
13834 #define HAVE_CCOSH 1
13835 _ACEOF
13836
13837 fi
13838
13839 echo "$as_me:$LINENO: checking for ccoshl in -lm" >&5
13840 echo $ECHO_N "checking for ccoshl in -lm... $ECHO_C" >&6
13841 if test "${ac_cv_lib_m_ccoshl+set}" = set; then
13842   echo $ECHO_N "(cached) $ECHO_C" >&6
13843 else
13844   ac_check_lib_save_LIBS=$LIBS
13845 LIBS="-lm  $LIBS"
13846 if test x$gcc_no_link = xyes; then
13847   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13848 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13849    { (exit 1); exit 1; }; }
13850 fi
13851 cat >conftest.$ac_ext <<_ACEOF
13852 /* confdefs.h.  */
13853 _ACEOF
13854 cat confdefs.h >>conftest.$ac_ext
13855 cat >>conftest.$ac_ext <<_ACEOF
13856 /* end confdefs.h.  */
13857
13858 /* Override any gcc2 internal prototype to avoid an error.  */
13859 #ifdef __cplusplus
13860 extern "C"
13861 #endif
13862 /* We use char because int might match the return type of a gcc2
13863    builtin and then its argument prototype would still apply.  */
13864 char ccoshl ();
13865 int
13866 main ()
13867 {
13868 ccoshl ();
13869   ;
13870   return 0;
13871 }
13872 _ACEOF
13873 rm -f conftest.$ac_objext conftest$ac_exeext
13874 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13875   (eval $ac_link) 2>conftest.er1
13876   ac_status=$?
13877   grep -v '^ *+' conftest.er1 >conftest.err
13878   rm -f conftest.er1
13879   cat conftest.err >&5
13880   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13881   (exit $ac_status); } &&
13882          { ac_try='test -z "$ac_c_werror_flag"
13883                          || test ! -s conftest.err'
13884   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13885   (eval $ac_try) 2>&5
13886   ac_status=$?
13887   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13888   (exit $ac_status); }; } &&
13889          { ac_try='test -s conftest$ac_exeext'
13890   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13891   (eval $ac_try) 2>&5
13892   ac_status=$?
13893   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13894   (exit $ac_status); }; }; then
13895   ac_cv_lib_m_ccoshl=yes
13896 else
13897   echo "$as_me: failed program was:" >&5
13898 sed 's/^/| /' conftest.$ac_ext >&5
13899
13900 ac_cv_lib_m_ccoshl=no
13901 fi
13902 rm -f conftest.err conftest.$ac_objext \
13903       conftest$ac_exeext conftest.$ac_ext
13904 LIBS=$ac_check_lib_save_LIBS
13905 fi
13906 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccoshl" >&5
13907 echo "${ECHO_T}$ac_cv_lib_m_ccoshl" >&6
13908 if test $ac_cv_lib_m_ccoshl = yes; then
13909
13910 cat >>confdefs.h <<\_ACEOF
13911 #define HAVE_CCOSHL 1
13912 _ACEOF
13913
13914 fi
13915
13916 echo "$as_me:$LINENO: checking for expf in -lm" >&5
13917 echo $ECHO_N "checking for expf in -lm... $ECHO_C" >&6
13918 if test "${ac_cv_lib_m_expf+set}" = set; then
13919   echo $ECHO_N "(cached) $ECHO_C" >&6
13920 else
13921   ac_check_lib_save_LIBS=$LIBS
13922 LIBS="-lm  $LIBS"
13923 if test x$gcc_no_link = xyes; then
13924   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13925 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13926    { (exit 1); exit 1; }; }
13927 fi
13928 cat >conftest.$ac_ext <<_ACEOF
13929 /* confdefs.h.  */
13930 _ACEOF
13931 cat confdefs.h >>conftest.$ac_ext
13932 cat >>conftest.$ac_ext <<_ACEOF
13933 /* end confdefs.h.  */
13934
13935 /* Override any gcc2 internal prototype to avoid an error.  */
13936 #ifdef __cplusplus
13937 extern "C"
13938 #endif
13939 /* We use char because int might match the return type of a gcc2
13940    builtin and then its argument prototype would still apply.  */
13941 char expf ();
13942 int
13943 main ()
13944 {
13945 expf ();
13946   ;
13947   return 0;
13948 }
13949 _ACEOF
13950 rm -f conftest.$ac_objext conftest$ac_exeext
13951 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13952   (eval $ac_link) 2>conftest.er1
13953   ac_status=$?
13954   grep -v '^ *+' conftest.er1 >conftest.err
13955   rm -f conftest.er1
13956   cat conftest.err >&5
13957   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13958   (exit $ac_status); } &&
13959          { ac_try='test -z "$ac_c_werror_flag"
13960                          || test ! -s conftest.err'
13961   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13962   (eval $ac_try) 2>&5
13963   ac_status=$?
13964   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13965   (exit $ac_status); }; } &&
13966          { ac_try='test -s conftest$ac_exeext'
13967   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13968   (eval $ac_try) 2>&5
13969   ac_status=$?
13970   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13971   (exit $ac_status); }; }; then
13972   ac_cv_lib_m_expf=yes
13973 else
13974   echo "$as_me: failed program was:" >&5
13975 sed 's/^/| /' conftest.$ac_ext >&5
13976
13977 ac_cv_lib_m_expf=no
13978 fi
13979 rm -f conftest.err conftest.$ac_objext \
13980       conftest$ac_exeext conftest.$ac_ext
13981 LIBS=$ac_check_lib_save_LIBS
13982 fi
13983 echo "$as_me:$LINENO: result: $ac_cv_lib_m_expf" >&5
13984 echo "${ECHO_T}$ac_cv_lib_m_expf" >&6
13985 if test $ac_cv_lib_m_expf = yes; then
13986
13987 cat >>confdefs.h <<\_ACEOF
13988 #define HAVE_EXPF 1
13989 _ACEOF
13990
13991 fi
13992
13993 echo "$as_me:$LINENO: checking for exp in -lm" >&5
13994 echo $ECHO_N "checking for exp in -lm... $ECHO_C" >&6
13995 if test "${ac_cv_lib_m_exp+set}" = set; then
13996   echo $ECHO_N "(cached) $ECHO_C" >&6
13997 else
13998   ac_check_lib_save_LIBS=$LIBS
13999 LIBS="-lm  $LIBS"
14000 if test x$gcc_no_link = xyes; then
14001   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14002 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14003    { (exit 1); exit 1; }; }
14004 fi
14005 cat >conftest.$ac_ext <<_ACEOF
14006 /* confdefs.h.  */
14007 _ACEOF
14008 cat confdefs.h >>conftest.$ac_ext
14009 cat >>conftest.$ac_ext <<_ACEOF
14010 /* end confdefs.h.  */
14011
14012 /* Override any gcc2 internal prototype to avoid an error.  */
14013 #ifdef __cplusplus
14014 extern "C"
14015 #endif
14016 /* We use char because int might match the return type of a gcc2
14017    builtin and then its argument prototype would still apply.  */
14018 char exp ();
14019 int
14020 main ()
14021 {
14022 exp ();
14023   ;
14024   return 0;
14025 }
14026 _ACEOF
14027 rm -f conftest.$ac_objext conftest$ac_exeext
14028 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14029   (eval $ac_link) 2>conftest.er1
14030   ac_status=$?
14031   grep -v '^ *+' conftest.er1 >conftest.err
14032   rm -f conftest.er1
14033   cat conftest.err >&5
14034   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14035   (exit $ac_status); } &&
14036          { ac_try='test -z "$ac_c_werror_flag"
14037                          || test ! -s conftest.err'
14038   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14039   (eval $ac_try) 2>&5
14040   ac_status=$?
14041   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14042   (exit $ac_status); }; } &&
14043          { ac_try='test -s conftest$ac_exeext'
14044   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14045   (eval $ac_try) 2>&5
14046   ac_status=$?
14047   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14048   (exit $ac_status); }; }; then
14049   ac_cv_lib_m_exp=yes
14050 else
14051   echo "$as_me: failed program was:" >&5
14052 sed 's/^/| /' conftest.$ac_ext >&5
14053
14054 ac_cv_lib_m_exp=no
14055 fi
14056 rm -f conftest.err conftest.$ac_objext \
14057       conftest$ac_exeext conftest.$ac_ext
14058 LIBS=$ac_check_lib_save_LIBS
14059 fi
14060 echo "$as_me:$LINENO: result: $ac_cv_lib_m_exp" >&5
14061 echo "${ECHO_T}$ac_cv_lib_m_exp" >&6
14062 if test $ac_cv_lib_m_exp = yes; then
14063
14064 cat >>confdefs.h <<\_ACEOF
14065 #define HAVE_EXP 1
14066 _ACEOF
14067
14068 fi
14069
14070 echo "$as_me:$LINENO: checking for expl in -lm" >&5
14071 echo $ECHO_N "checking for expl in -lm... $ECHO_C" >&6
14072 if test "${ac_cv_lib_m_expl+set}" = set; then
14073   echo $ECHO_N "(cached) $ECHO_C" >&6
14074 else
14075   ac_check_lib_save_LIBS=$LIBS
14076 LIBS="-lm  $LIBS"
14077 if test x$gcc_no_link = xyes; then
14078   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14079 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14080    { (exit 1); exit 1; }; }
14081 fi
14082 cat >conftest.$ac_ext <<_ACEOF
14083 /* confdefs.h.  */
14084 _ACEOF
14085 cat confdefs.h >>conftest.$ac_ext
14086 cat >>conftest.$ac_ext <<_ACEOF
14087 /* end confdefs.h.  */
14088
14089 /* Override any gcc2 internal prototype to avoid an error.  */
14090 #ifdef __cplusplus
14091 extern "C"
14092 #endif
14093 /* We use char because int might match the return type of a gcc2
14094    builtin and then its argument prototype would still apply.  */
14095 char expl ();
14096 int
14097 main ()
14098 {
14099 expl ();
14100   ;
14101   return 0;
14102 }
14103 _ACEOF
14104 rm -f conftest.$ac_objext conftest$ac_exeext
14105 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14106   (eval $ac_link) 2>conftest.er1
14107   ac_status=$?
14108   grep -v '^ *+' conftest.er1 >conftest.err
14109   rm -f conftest.er1
14110   cat conftest.err >&5
14111   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14112   (exit $ac_status); } &&
14113          { ac_try='test -z "$ac_c_werror_flag"
14114                          || test ! -s conftest.err'
14115   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14116   (eval $ac_try) 2>&5
14117   ac_status=$?
14118   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14119   (exit $ac_status); }; } &&
14120          { ac_try='test -s conftest$ac_exeext'
14121   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14122   (eval $ac_try) 2>&5
14123   ac_status=$?
14124   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14125   (exit $ac_status); }; }; then
14126   ac_cv_lib_m_expl=yes
14127 else
14128   echo "$as_me: failed program was:" >&5
14129 sed 's/^/| /' conftest.$ac_ext >&5
14130
14131 ac_cv_lib_m_expl=no
14132 fi
14133 rm -f conftest.err conftest.$ac_objext \
14134       conftest$ac_exeext conftest.$ac_ext
14135 LIBS=$ac_check_lib_save_LIBS
14136 fi
14137 echo "$as_me:$LINENO: result: $ac_cv_lib_m_expl" >&5
14138 echo "${ECHO_T}$ac_cv_lib_m_expl" >&6
14139 if test $ac_cv_lib_m_expl = yes; then
14140
14141 cat >>confdefs.h <<\_ACEOF
14142 #define HAVE_EXPL 1
14143 _ACEOF
14144
14145 fi
14146
14147 echo "$as_me:$LINENO: checking for cexpf in -lm" >&5
14148 echo $ECHO_N "checking for cexpf in -lm... $ECHO_C" >&6
14149 if test "${ac_cv_lib_m_cexpf+set}" = set; then
14150   echo $ECHO_N "(cached) $ECHO_C" >&6
14151 else
14152   ac_check_lib_save_LIBS=$LIBS
14153 LIBS="-lm  $LIBS"
14154 if test x$gcc_no_link = xyes; then
14155   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14156 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14157    { (exit 1); exit 1; }; }
14158 fi
14159 cat >conftest.$ac_ext <<_ACEOF
14160 /* confdefs.h.  */
14161 _ACEOF
14162 cat confdefs.h >>conftest.$ac_ext
14163 cat >>conftest.$ac_ext <<_ACEOF
14164 /* end confdefs.h.  */
14165
14166 /* Override any gcc2 internal prototype to avoid an error.  */
14167 #ifdef __cplusplus
14168 extern "C"
14169 #endif
14170 /* We use char because int might match the return type of a gcc2
14171    builtin and then its argument prototype would still apply.  */
14172 char cexpf ();
14173 int
14174 main ()
14175 {
14176 cexpf ();
14177   ;
14178   return 0;
14179 }
14180 _ACEOF
14181 rm -f conftest.$ac_objext conftest$ac_exeext
14182 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14183   (eval $ac_link) 2>conftest.er1
14184   ac_status=$?
14185   grep -v '^ *+' conftest.er1 >conftest.err
14186   rm -f conftest.er1
14187   cat conftest.err >&5
14188   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14189   (exit $ac_status); } &&
14190          { ac_try='test -z "$ac_c_werror_flag"
14191                          || test ! -s conftest.err'
14192   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14193   (eval $ac_try) 2>&5
14194   ac_status=$?
14195   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14196   (exit $ac_status); }; } &&
14197          { ac_try='test -s conftest$ac_exeext'
14198   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14199   (eval $ac_try) 2>&5
14200   ac_status=$?
14201   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14202   (exit $ac_status); }; }; then
14203   ac_cv_lib_m_cexpf=yes
14204 else
14205   echo "$as_me: failed program was:" >&5
14206 sed 's/^/| /' conftest.$ac_ext >&5
14207
14208 ac_cv_lib_m_cexpf=no
14209 fi
14210 rm -f conftest.err conftest.$ac_objext \
14211       conftest$ac_exeext conftest.$ac_ext
14212 LIBS=$ac_check_lib_save_LIBS
14213 fi
14214 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexpf" >&5
14215 echo "${ECHO_T}$ac_cv_lib_m_cexpf" >&6
14216 if test $ac_cv_lib_m_cexpf = yes; then
14217
14218 cat >>confdefs.h <<\_ACEOF
14219 #define HAVE_CEXPF 1
14220 _ACEOF
14221
14222 fi
14223
14224 echo "$as_me:$LINENO: checking for cexp in -lm" >&5
14225 echo $ECHO_N "checking for cexp in -lm... $ECHO_C" >&6
14226 if test "${ac_cv_lib_m_cexp+set}" = set; then
14227   echo $ECHO_N "(cached) $ECHO_C" >&6
14228 else
14229   ac_check_lib_save_LIBS=$LIBS
14230 LIBS="-lm  $LIBS"
14231 if test x$gcc_no_link = xyes; then
14232   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14233 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14234    { (exit 1); exit 1; }; }
14235 fi
14236 cat >conftest.$ac_ext <<_ACEOF
14237 /* confdefs.h.  */
14238 _ACEOF
14239 cat confdefs.h >>conftest.$ac_ext
14240 cat >>conftest.$ac_ext <<_ACEOF
14241 /* end confdefs.h.  */
14242
14243 /* Override any gcc2 internal prototype to avoid an error.  */
14244 #ifdef __cplusplus
14245 extern "C"
14246 #endif
14247 /* We use char because int might match the return type of a gcc2
14248    builtin and then its argument prototype would still apply.  */
14249 char cexp ();
14250 int
14251 main ()
14252 {
14253 cexp ();
14254   ;
14255   return 0;
14256 }
14257 _ACEOF
14258 rm -f conftest.$ac_objext conftest$ac_exeext
14259 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14260   (eval $ac_link) 2>conftest.er1
14261   ac_status=$?
14262   grep -v '^ *+' conftest.er1 >conftest.err
14263   rm -f conftest.er1
14264   cat conftest.err >&5
14265   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14266   (exit $ac_status); } &&
14267          { ac_try='test -z "$ac_c_werror_flag"
14268                          || test ! -s conftest.err'
14269   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14270   (eval $ac_try) 2>&5
14271   ac_status=$?
14272   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14273   (exit $ac_status); }; } &&
14274          { ac_try='test -s conftest$ac_exeext'
14275   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14276   (eval $ac_try) 2>&5
14277   ac_status=$?
14278   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14279   (exit $ac_status); }; }; then
14280   ac_cv_lib_m_cexp=yes
14281 else
14282   echo "$as_me: failed program was:" >&5
14283 sed 's/^/| /' conftest.$ac_ext >&5
14284
14285 ac_cv_lib_m_cexp=no
14286 fi
14287 rm -f conftest.err conftest.$ac_objext \
14288       conftest$ac_exeext conftest.$ac_ext
14289 LIBS=$ac_check_lib_save_LIBS
14290 fi
14291 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexp" >&5
14292 echo "${ECHO_T}$ac_cv_lib_m_cexp" >&6
14293 if test $ac_cv_lib_m_cexp = yes; then
14294
14295 cat >>confdefs.h <<\_ACEOF
14296 #define HAVE_CEXP 1
14297 _ACEOF
14298
14299 fi
14300
14301 echo "$as_me:$LINENO: checking for cexpl in -lm" >&5
14302 echo $ECHO_N "checking for cexpl in -lm... $ECHO_C" >&6
14303 if test "${ac_cv_lib_m_cexpl+set}" = set; then
14304   echo $ECHO_N "(cached) $ECHO_C" >&6
14305 else
14306   ac_check_lib_save_LIBS=$LIBS
14307 LIBS="-lm  $LIBS"
14308 if test x$gcc_no_link = xyes; then
14309   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14310 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14311    { (exit 1); exit 1; }; }
14312 fi
14313 cat >conftest.$ac_ext <<_ACEOF
14314 /* confdefs.h.  */
14315 _ACEOF
14316 cat confdefs.h >>conftest.$ac_ext
14317 cat >>conftest.$ac_ext <<_ACEOF
14318 /* end confdefs.h.  */
14319
14320 /* Override any gcc2 internal prototype to avoid an error.  */
14321 #ifdef __cplusplus
14322 extern "C"
14323 #endif
14324 /* We use char because int might match the return type of a gcc2
14325    builtin and then its argument prototype would still apply.  */
14326 char cexpl ();
14327 int
14328 main ()
14329 {
14330 cexpl ();
14331   ;
14332   return 0;
14333 }
14334 _ACEOF
14335 rm -f conftest.$ac_objext conftest$ac_exeext
14336 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14337   (eval $ac_link) 2>conftest.er1
14338   ac_status=$?
14339   grep -v '^ *+' conftest.er1 >conftest.err
14340   rm -f conftest.er1
14341   cat conftest.err >&5
14342   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14343   (exit $ac_status); } &&
14344          { ac_try='test -z "$ac_c_werror_flag"
14345                          || test ! -s conftest.err'
14346   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14347   (eval $ac_try) 2>&5
14348   ac_status=$?
14349   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14350   (exit $ac_status); }; } &&
14351          { ac_try='test -s conftest$ac_exeext'
14352   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14353   (eval $ac_try) 2>&5
14354   ac_status=$?
14355   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14356   (exit $ac_status); }; }; then
14357   ac_cv_lib_m_cexpl=yes
14358 else
14359   echo "$as_me: failed program was:" >&5
14360 sed 's/^/| /' conftest.$ac_ext >&5
14361
14362 ac_cv_lib_m_cexpl=no
14363 fi
14364 rm -f conftest.err conftest.$ac_objext \
14365       conftest$ac_exeext conftest.$ac_ext
14366 LIBS=$ac_check_lib_save_LIBS
14367 fi
14368 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexpl" >&5
14369 echo "${ECHO_T}$ac_cv_lib_m_cexpl" >&6
14370 if test $ac_cv_lib_m_cexpl = yes; then
14371
14372 cat >>confdefs.h <<\_ACEOF
14373 #define HAVE_CEXPL 1
14374 _ACEOF
14375
14376 fi
14377
14378 echo "$as_me:$LINENO: checking for fabsf in -lm" >&5
14379 echo $ECHO_N "checking for fabsf in -lm... $ECHO_C" >&6
14380 if test "${ac_cv_lib_m_fabsf+set}" = set; then
14381   echo $ECHO_N "(cached) $ECHO_C" >&6
14382 else
14383   ac_check_lib_save_LIBS=$LIBS
14384 LIBS="-lm  $LIBS"
14385 if test x$gcc_no_link = xyes; then
14386   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14387 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14388    { (exit 1); exit 1; }; }
14389 fi
14390 cat >conftest.$ac_ext <<_ACEOF
14391 /* confdefs.h.  */
14392 _ACEOF
14393 cat confdefs.h >>conftest.$ac_ext
14394 cat >>conftest.$ac_ext <<_ACEOF
14395 /* end confdefs.h.  */
14396
14397 /* Override any gcc2 internal prototype to avoid an error.  */
14398 #ifdef __cplusplus
14399 extern "C"
14400 #endif
14401 /* We use char because int might match the return type of a gcc2
14402    builtin and then its argument prototype would still apply.  */
14403 char fabsf ();
14404 int
14405 main ()
14406 {
14407 fabsf ();
14408   ;
14409   return 0;
14410 }
14411 _ACEOF
14412 rm -f conftest.$ac_objext conftest$ac_exeext
14413 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14414   (eval $ac_link) 2>conftest.er1
14415   ac_status=$?
14416   grep -v '^ *+' conftest.er1 >conftest.err
14417   rm -f conftest.er1
14418   cat conftest.err >&5
14419   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14420   (exit $ac_status); } &&
14421          { ac_try='test -z "$ac_c_werror_flag"
14422                          || test ! -s conftest.err'
14423   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14424   (eval $ac_try) 2>&5
14425   ac_status=$?
14426   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14427   (exit $ac_status); }; } &&
14428          { ac_try='test -s conftest$ac_exeext'
14429   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14430   (eval $ac_try) 2>&5
14431   ac_status=$?
14432   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14433   (exit $ac_status); }; }; then
14434   ac_cv_lib_m_fabsf=yes
14435 else
14436   echo "$as_me: failed program was:" >&5
14437 sed 's/^/| /' conftest.$ac_ext >&5
14438
14439 ac_cv_lib_m_fabsf=no
14440 fi
14441 rm -f conftest.err conftest.$ac_objext \
14442       conftest$ac_exeext conftest.$ac_ext
14443 LIBS=$ac_check_lib_save_LIBS
14444 fi
14445 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabsf" >&5
14446 echo "${ECHO_T}$ac_cv_lib_m_fabsf" >&6
14447 if test $ac_cv_lib_m_fabsf = yes; then
14448
14449 cat >>confdefs.h <<\_ACEOF
14450 #define HAVE_FABSF 1
14451 _ACEOF
14452
14453 fi
14454
14455 echo "$as_me:$LINENO: checking for fabs in -lm" >&5
14456 echo $ECHO_N "checking for fabs in -lm... $ECHO_C" >&6
14457 if test "${ac_cv_lib_m_fabs+set}" = set; then
14458   echo $ECHO_N "(cached) $ECHO_C" >&6
14459 else
14460   ac_check_lib_save_LIBS=$LIBS
14461 LIBS="-lm  $LIBS"
14462 if test x$gcc_no_link = xyes; then
14463   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14464 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14465    { (exit 1); exit 1; }; }
14466 fi
14467 cat >conftest.$ac_ext <<_ACEOF
14468 /* confdefs.h.  */
14469 _ACEOF
14470 cat confdefs.h >>conftest.$ac_ext
14471 cat >>conftest.$ac_ext <<_ACEOF
14472 /* end confdefs.h.  */
14473
14474 /* Override any gcc2 internal prototype to avoid an error.  */
14475 #ifdef __cplusplus
14476 extern "C"
14477 #endif
14478 /* We use char because int might match the return type of a gcc2
14479    builtin and then its argument prototype would still apply.  */
14480 char fabs ();
14481 int
14482 main ()
14483 {
14484 fabs ();
14485   ;
14486   return 0;
14487 }
14488 _ACEOF
14489 rm -f conftest.$ac_objext conftest$ac_exeext
14490 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14491   (eval $ac_link) 2>conftest.er1
14492   ac_status=$?
14493   grep -v '^ *+' conftest.er1 >conftest.err
14494   rm -f conftest.er1
14495   cat conftest.err >&5
14496   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14497   (exit $ac_status); } &&
14498          { ac_try='test -z "$ac_c_werror_flag"
14499                          || test ! -s conftest.err'
14500   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14501   (eval $ac_try) 2>&5
14502   ac_status=$?
14503   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14504   (exit $ac_status); }; } &&
14505          { ac_try='test -s conftest$ac_exeext'
14506   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14507   (eval $ac_try) 2>&5
14508   ac_status=$?
14509   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14510   (exit $ac_status); }; }; then
14511   ac_cv_lib_m_fabs=yes
14512 else
14513   echo "$as_me: failed program was:" >&5
14514 sed 's/^/| /' conftest.$ac_ext >&5
14515
14516 ac_cv_lib_m_fabs=no
14517 fi
14518 rm -f conftest.err conftest.$ac_objext \
14519       conftest$ac_exeext conftest.$ac_ext
14520 LIBS=$ac_check_lib_save_LIBS
14521 fi
14522 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabs" >&5
14523 echo "${ECHO_T}$ac_cv_lib_m_fabs" >&6
14524 if test $ac_cv_lib_m_fabs = yes; then
14525
14526 cat >>confdefs.h <<\_ACEOF
14527 #define HAVE_FABS 1
14528 _ACEOF
14529
14530 fi
14531
14532 echo "$as_me:$LINENO: checking for fabsl in -lm" >&5
14533 echo $ECHO_N "checking for fabsl in -lm... $ECHO_C" >&6
14534 if test "${ac_cv_lib_m_fabsl+set}" = set; then
14535   echo $ECHO_N "(cached) $ECHO_C" >&6
14536 else
14537   ac_check_lib_save_LIBS=$LIBS
14538 LIBS="-lm  $LIBS"
14539 if test x$gcc_no_link = xyes; then
14540   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14541 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14542    { (exit 1); exit 1; }; }
14543 fi
14544 cat >conftest.$ac_ext <<_ACEOF
14545 /* confdefs.h.  */
14546 _ACEOF
14547 cat confdefs.h >>conftest.$ac_ext
14548 cat >>conftest.$ac_ext <<_ACEOF
14549 /* end confdefs.h.  */
14550
14551 /* Override any gcc2 internal prototype to avoid an error.  */
14552 #ifdef __cplusplus
14553 extern "C"
14554 #endif
14555 /* We use char because int might match the return type of a gcc2
14556    builtin and then its argument prototype would still apply.  */
14557 char fabsl ();
14558 int
14559 main ()
14560 {
14561 fabsl ();
14562   ;
14563   return 0;
14564 }
14565 _ACEOF
14566 rm -f conftest.$ac_objext conftest$ac_exeext
14567 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14568   (eval $ac_link) 2>conftest.er1
14569   ac_status=$?
14570   grep -v '^ *+' conftest.er1 >conftest.err
14571   rm -f conftest.er1
14572   cat conftest.err >&5
14573   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14574   (exit $ac_status); } &&
14575          { ac_try='test -z "$ac_c_werror_flag"
14576                          || test ! -s conftest.err'
14577   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14578   (eval $ac_try) 2>&5
14579   ac_status=$?
14580   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14581   (exit $ac_status); }; } &&
14582          { ac_try='test -s conftest$ac_exeext'
14583   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14584   (eval $ac_try) 2>&5
14585   ac_status=$?
14586   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14587   (exit $ac_status); }; }; then
14588   ac_cv_lib_m_fabsl=yes
14589 else
14590   echo "$as_me: failed program was:" >&5
14591 sed 's/^/| /' conftest.$ac_ext >&5
14592
14593 ac_cv_lib_m_fabsl=no
14594 fi
14595 rm -f conftest.err conftest.$ac_objext \
14596       conftest$ac_exeext conftest.$ac_ext
14597 LIBS=$ac_check_lib_save_LIBS
14598 fi
14599 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabsl" >&5
14600 echo "${ECHO_T}$ac_cv_lib_m_fabsl" >&6
14601 if test $ac_cv_lib_m_fabsl = yes; then
14602
14603 cat >>confdefs.h <<\_ACEOF
14604 #define HAVE_FABSL 1
14605 _ACEOF
14606
14607 fi
14608
14609 echo "$as_me:$LINENO: checking for cabsf in -lm" >&5
14610 echo $ECHO_N "checking for cabsf in -lm... $ECHO_C" >&6
14611 if test "${ac_cv_lib_m_cabsf+set}" = set; then
14612   echo $ECHO_N "(cached) $ECHO_C" >&6
14613 else
14614   ac_check_lib_save_LIBS=$LIBS
14615 LIBS="-lm  $LIBS"
14616 if test x$gcc_no_link = xyes; then
14617   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14618 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14619    { (exit 1); exit 1; }; }
14620 fi
14621 cat >conftest.$ac_ext <<_ACEOF
14622 /* confdefs.h.  */
14623 _ACEOF
14624 cat confdefs.h >>conftest.$ac_ext
14625 cat >>conftest.$ac_ext <<_ACEOF
14626 /* end confdefs.h.  */
14627
14628 /* Override any gcc2 internal prototype to avoid an error.  */
14629 #ifdef __cplusplus
14630 extern "C"
14631 #endif
14632 /* We use char because int might match the return type of a gcc2
14633    builtin and then its argument prototype would still apply.  */
14634 char cabsf ();
14635 int
14636 main ()
14637 {
14638 cabsf ();
14639   ;
14640   return 0;
14641 }
14642 _ACEOF
14643 rm -f conftest.$ac_objext conftest$ac_exeext
14644 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14645   (eval $ac_link) 2>conftest.er1
14646   ac_status=$?
14647   grep -v '^ *+' conftest.er1 >conftest.err
14648   rm -f conftest.er1
14649   cat conftest.err >&5
14650   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14651   (exit $ac_status); } &&
14652          { ac_try='test -z "$ac_c_werror_flag"
14653                          || test ! -s conftest.err'
14654   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14655   (eval $ac_try) 2>&5
14656   ac_status=$?
14657   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14658   (exit $ac_status); }; } &&
14659          { ac_try='test -s conftest$ac_exeext'
14660   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14661   (eval $ac_try) 2>&5
14662   ac_status=$?
14663   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14664   (exit $ac_status); }; }; then
14665   ac_cv_lib_m_cabsf=yes
14666 else
14667   echo "$as_me: failed program was:" >&5
14668 sed 's/^/| /' conftest.$ac_ext >&5
14669
14670 ac_cv_lib_m_cabsf=no
14671 fi
14672 rm -f conftest.err conftest.$ac_objext \
14673       conftest$ac_exeext conftest.$ac_ext
14674 LIBS=$ac_check_lib_save_LIBS
14675 fi
14676 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabsf" >&5
14677 echo "${ECHO_T}$ac_cv_lib_m_cabsf" >&6
14678 if test $ac_cv_lib_m_cabsf = yes; then
14679
14680 cat >>confdefs.h <<\_ACEOF
14681 #define HAVE_CABSF 1
14682 _ACEOF
14683
14684 fi
14685
14686 echo "$as_me:$LINENO: checking for cabs in -lm" >&5
14687 echo $ECHO_N "checking for cabs in -lm... $ECHO_C" >&6
14688 if test "${ac_cv_lib_m_cabs+set}" = set; then
14689   echo $ECHO_N "(cached) $ECHO_C" >&6
14690 else
14691   ac_check_lib_save_LIBS=$LIBS
14692 LIBS="-lm  $LIBS"
14693 if test x$gcc_no_link = xyes; then
14694   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14695 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14696    { (exit 1); exit 1; }; }
14697 fi
14698 cat >conftest.$ac_ext <<_ACEOF
14699 /* confdefs.h.  */
14700 _ACEOF
14701 cat confdefs.h >>conftest.$ac_ext
14702 cat >>conftest.$ac_ext <<_ACEOF
14703 /* end confdefs.h.  */
14704
14705 /* Override any gcc2 internal prototype to avoid an error.  */
14706 #ifdef __cplusplus
14707 extern "C"
14708 #endif
14709 /* We use char because int might match the return type of a gcc2
14710    builtin and then its argument prototype would still apply.  */
14711 char cabs ();
14712 int
14713 main ()
14714 {
14715 cabs ();
14716   ;
14717   return 0;
14718 }
14719 _ACEOF
14720 rm -f conftest.$ac_objext conftest$ac_exeext
14721 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14722   (eval $ac_link) 2>conftest.er1
14723   ac_status=$?
14724   grep -v '^ *+' conftest.er1 >conftest.err
14725   rm -f conftest.er1
14726   cat conftest.err >&5
14727   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14728   (exit $ac_status); } &&
14729          { ac_try='test -z "$ac_c_werror_flag"
14730                          || test ! -s conftest.err'
14731   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14732   (eval $ac_try) 2>&5
14733   ac_status=$?
14734   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14735   (exit $ac_status); }; } &&
14736          { ac_try='test -s conftest$ac_exeext'
14737   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14738   (eval $ac_try) 2>&5
14739   ac_status=$?
14740   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14741   (exit $ac_status); }; }; then
14742   ac_cv_lib_m_cabs=yes
14743 else
14744   echo "$as_me: failed program was:" >&5
14745 sed 's/^/| /' conftest.$ac_ext >&5
14746
14747 ac_cv_lib_m_cabs=no
14748 fi
14749 rm -f conftest.err conftest.$ac_objext \
14750       conftest$ac_exeext conftest.$ac_ext
14751 LIBS=$ac_check_lib_save_LIBS
14752 fi
14753 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabs" >&5
14754 echo "${ECHO_T}$ac_cv_lib_m_cabs" >&6
14755 if test $ac_cv_lib_m_cabs = yes; then
14756
14757 cat >>confdefs.h <<\_ACEOF
14758 #define HAVE_CABS 1
14759 _ACEOF
14760
14761 fi
14762
14763 echo "$as_me:$LINENO: checking for cabsl in -lm" >&5
14764 echo $ECHO_N "checking for cabsl in -lm... $ECHO_C" >&6
14765 if test "${ac_cv_lib_m_cabsl+set}" = set; then
14766   echo $ECHO_N "(cached) $ECHO_C" >&6
14767 else
14768   ac_check_lib_save_LIBS=$LIBS
14769 LIBS="-lm  $LIBS"
14770 if test x$gcc_no_link = xyes; then
14771   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14772 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14773    { (exit 1); exit 1; }; }
14774 fi
14775 cat >conftest.$ac_ext <<_ACEOF
14776 /* confdefs.h.  */
14777 _ACEOF
14778 cat confdefs.h >>conftest.$ac_ext
14779 cat >>conftest.$ac_ext <<_ACEOF
14780 /* end confdefs.h.  */
14781
14782 /* Override any gcc2 internal prototype to avoid an error.  */
14783 #ifdef __cplusplus
14784 extern "C"
14785 #endif
14786 /* We use char because int might match the return type of a gcc2
14787    builtin and then its argument prototype would still apply.  */
14788 char cabsl ();
14789 int
14790 main ()
14791 {
14792 cabsl ();
14793   ;
14794   return 0;
14795 }
14796 _ACEOF
14797 rm -f conftest.$ac_objext conftest$ac_exeext
14798 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14799   (eval $ac_link) 2>conftest.er1
14800   ac_status=$?
14801   grep -v '^ *+' conftest.er1 >conftest.err
14802   rm -f conftest.er1
14803   cat conftest.err >&5
14804   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14805   (exit $ac_status); } &&
14806          { ac_try='test -z "$ac_c_werror_flag"
14807                          || test ! -s conftest.err'
14808   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14809   (eval $ac_try) 2>&5
14810   ac_status=$?
14811   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14812   (exit $ac_status); }; } &&
14813          { ac_try='test -s conftest$ac_exeext'
14814   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14815   (eval $ac_try) 2>&5
14816   ac_status=$?
14817   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14818   (exit $ac_status); }; }; then
14819   ac_cv_lib_m_cabsl=yes
14820 else
14821   echo "$as_me: failed program was:" >&5
14822 sed 's/^/| /' conftest.$ac_ext >&5
14823
14824 ac_cv_lib_m_cabsl=no
14825 fi
14826 rm -f conftest.err conftest.$ac_objext \
14827       conftest$ac_exeext conftest.$ac_ext
14828 LIBS=$ac_check_lib_save_LIBS
14829 fi
14830 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabsl" >&5
14831 echo "${ECHO_T}$ac_cv_lib_m_cabsl" >&6
14832 if test $ac_cv_lib_m_cabsl = yes; then
14833
14834 cat >>confdefs.h <<\_ACEOF
14835 #define HAVE_CABSL 1
14836 _ACEOF
14837
14838 fi
14839
14840 echo "$as_me:$LINENO: checking for floorf in -lm" >&5
14841 echo $ECHO_N "checking for floorf in -lm... $ECHO_C" >&6
14842 if test "${ac_cv_lib_m_floorf+set}" = set; then
14843   echo $ECHO_N "(cached) $ECHO_C" >&6
14844 else
14845   ac_check_lib_save_LIBS=$LIBS
14846 LIBS="-lm  $LIBS"
14847 if test x$gcc_no_link = xyes; then
14848   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14849 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14850    { (exit 1); exit 1; }; }
14851 fi
14852 cat >conftest.$ac_ext <<_ACEOF
14853 /* confdefs.h.  */
14854 _ACEOF
14855 cat confdefs.h >>conftest.$ac_ext
14856 cat >>conftest.$ac_ext <<_ACEOF
14857 /* end confdefs.h.  */
14858
14859 /* Override any gcc2 internal prototype to avoid an error.  */
14860 #ifdef __cplusplus
14861 extern "C"
14862 #endif
14863 /* We use char because int might match the return type of a gcc2
14864    builtin and then its argument prototype would still apply.  */
14865 char floorf ();
14866 int
14867 main ()
14868 {
14869 floorf ();
14870   ;
14871   return 0;
14872 }
14873 _ACEOF
14874 rm -f conftest.$ac_objext conftest$ac_exeext
14875 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14876   (eval $ac_link) 2>conftest.er1
14877   ac_status=$?
14878   grep -v '^ *+' conftest.er1 >conftest.err
14879   rm -f conftest.er1
14880   cat conftest.err >&5
14881   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14882   (exit $ac_status); } &&
14883          { ac_try='test -z "$ac_c_werror_flag"
14884                          || test ! -s conftest.err'
14885   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14886   (eval $ac_try) 2>&5
14887   ac_status=$?
14888   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14889   (exit $ac_status); }; } &&
14890          { ac_try='test -s conftest$ac_exeext'
14891   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14892   (eval $ac_try) 2>&5
14893   ac_status=$?
14894   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14895   (exit $ac_status); }; }; then
14896   ac_cv_lib_m_floorf=yes
14897 else
14898   echo "$as_me: failed program was:" >&5
14899 sed 's/^/| /' conftest.$ac_ext >&5
14900
14901 ac_cv_lib_m_floorf=no
14902 fi
14903 rm -f conftest.err conftest.$ac_objext \
14904       conftest$ac_exeext conftest.$ac_ext
14905 LIBS=$ac_check_lib_save_LIBS
14906 fi
14907 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floorf" >&5
14908 echo "${ECHO_T}$ac_cv_lib_m_floorf" >&6
14909 if test $ac_cv_lib_m_floorf = yes; then
14910
14911 cat >>confdefs.h <<\_ACEOF
14912 #define HAVE_FLOORF 1
14913 _ACEOF
14914
14915 fi
14916
14917 echo "$as_me:$LINENO: checking for floor in -lm" >&5
14918 echo $ECHO_N "checking for floor in -lm... $ECHO_C" >&6
14919 if test "${ac_cv_lib_m_floor+set}" = set; then
14920   echo $ECHO_N "(cached) $ECHO_C" >&6
14921 else
14922   ac_check_lib_save_LIBS=$LIBS
14923 LIBS="-lm  $LIBS"
14924 if test x$gcc_no_link = xyes; then
14925   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14926 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14927    { (exit 1); exit 1; }; }
14928 fi
14929 cat >conftest.$ac_ext <<_ACEOF
14930 /* confdefs.h.  */
14931 _ACEOF
14932 cat confdefs.h >>conftest.$ac_ext
14933 cat >>conftest.$ac_ext <<_ACEOF
14934 /* end confdefs.h.  */
14935
14936 /* Override any gcc2 internal prototype to avoid an error.  */
14937 #ifdef __cplusplus
14938 extern "C"
14939 #endif
14940 /* We use char because int might match the return type of a gcc2
14941    builtin and then its argument prototype would still apply.  */
14942 char floor ();
14943 int
14944 main ()
14945 {
14946 floor ();
14947   ;
14948   return 0;
14949 }
14950 _ACEOF
14951 rm -f conftest.$ac_objext conftest$ac_exeext
14952 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14953   (eval $ac_link) 2>conftest.er1
14954   ac_status=$?
14955   grep -v '^ *+' conftest.er1 >conftest.err
14956   rm -f conftest.er1
14957   cat conftest.err >&5
14958   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14959   (exit $ac_status); } &&
14960          { ac_try='test -z "$ac_c_werror_flag"
14961                          || test ! -s conftest.err'
14962   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14963   (eval $ac_try) 2>&5
14964   ac_status=$?
14965   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14966   (exit $ac_status); }; } &&
14967          { ac_try='test -s conftest$ac_exeext'
14968   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14969   (eval $ac_try) 2>&5
14970   ac_status=$?
14971   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14972   (exit $ac_status); }; }; then
14973   ac_cv_lib_m_floor=yes
14974 else
14975   echo "$as_me: failed program was:" >&5
14976 sed 's/^/| /' conftest.$ac_ext >&5
14977
14978 ac_cv_lib_m_floor=no
14979 fi
14980 rm -f conftest.err conftest.$ac_objext \
14981       conftest$ac_exeext conftest.$ac_ext
14982 LIBS=$ac_check_lib_save_LIBS
14983 fi
14984 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floor" >&5
14985 echo "${ECHO_T}$ac_cv_lib_m_floor" >&6
14986 if test $ac_cv_lib_m_floor = yes; then
14987
14988 cat >>confdefs.h <<\_ACEOF
14989 #define HAVE_FLOOR 1
14990 _ACEOF
14991
14992 fi
14993
14994 echo "$as_me:$LINENO: checking for floorl in -lm" >&5
14995 echo $ECHO_N "checking for floorl in -lm... $ECHO_C" >&6
14996 if test "${ac_cv_lib_m_floorl+set}" = set; then
14997   echo $ECHO_N "(cached) $ECHO_C" >&6
14998 else
14999   ac_check_lib_save_LIBS=$LIBS
15000 LIBS="-lm  $LIBS"
15001 if test x$gcc_no_link = xyes; then
15002   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15003 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15004    { (exit 1); exit 1; }; }
15005 fi
15006 cat >conftest.$ac_ext <<_ACEOF
15007 /* confdefs.h.  */
15008 _ACEOF
15009 cat confdefs.h >>conftest.$ac_ext
15010 cat >>conftest.$ac_ext <<_ACEOF
15011 /* end confdefs.h.  */
15012
15013 /* Override any gcc2 internal prototype to avoid an error.  */
15014 #ifdef __cplusplus
15015 extern "C"
15016 #endif
15017 /* We use char because int might match the return type of a gcc2
15018    builtin and then its argument prototype would still apply.  */
15019 char floorl ();
15020 int
15021 main ()
15022 {
15023 floorl ();
15024   ;
15025   return 0;
15026 }
15027 _ACEOF
15028 rm -f conftest.$ac_objext conftest$ac_exeext
15029 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15030   (eval $ac_link) 2>conftest.er1
15031   ac_status=$?
15032   grep -v '^ *+' conftest.er1 >conftest.err
15033   rm -f conftest.er1
15034   cat conftest.err >&5
15035   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15036   (exit $ac_status); } &&
15037          { ac_try='test -z "$ac_c_werror_flag"
15038                          || test ! -s conftest.err'
15039   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15040   (eval $ac_try) 2>&5
15041   ac_status=$?
15042   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15043   (exit $ac_status); }; } &&
15044          { ac_try='test -s conftest$ac_exeext'
15045   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15046   (eval $ac_try) 2>&5
15047   ac_status=$?
15048   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15049   (exit $ac_status); }; }; then
15050   ac_cv_lib_m_floorl=yes
15051 else
15052   echo "$as_me: failed program was:" >&5
15053 sed 's/^/| /' conftest.$ac_ext >&5
15054
15055 ac_cv_lib_m_floorl=no
15056 fi
15057 rm -f conftest.err conftest.$ac_objext \
15058       conftest$ac_exeext conftest.$ac_ext
15059 LIBS=$ac_check_lib_save_LIBS
15060 fi
15061 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floorl" >&5
15062 echo "${ECHO_T}$ac_cv_lib_m_floorl" >&6
15063 if test $ac_cv_lib_m_floorl = yes; then
15064
15065 cat >>confdefs.h <<\_ACEOF
15066 #define HAVE_FLOORL 1
15067 _ACEOF
15068
15069 fi
15070
15071 echo "$as_me:$LINENO: checking for fmodf in -lm" >&5
15072 echo $ECHO_N "checking for fmodf in -lm... $ECHO_C" >&6
15073 if test "${ac_cv_lib_m_fmodf+set}" = set; then
15074   echo $ECHO_N "(cached) $ECHO_C" >&6
15075 else
15076   ac_check_lib_save_LIBS=$LIBS
15077 LIBS="-lm  $LIBS"
15078 if test x$gcc_no_link = xyes; then
15079   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15080 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15081    { (exit 1); exit 1; }; }
15082 fi
15083 cat >conftest.$ac_ext <<_ACEOF
15084 /* confdefs.h.  */
15085 _ACEOF
15086 cat confdefs.h >>conftest.$ac_ext
15087 cat >>conftest.$ac_ext <<_ACEOF
15088 /* end confdefs.h.  */
15089
15090 /* Override any gcc2 internal prototype to avoid an error.  */
15091 #ifdef __cplusplus
15092 extern "C"
15093 #endif
15094 /* We use char because int might match the return type of a gcc2
15095    builtin and then its argument prototype would still apply.  */
15096 char fmodf ();
15097 int
15098 main ()
15099 {
15100 fmodf ();
15101   ;
15102   return 0;
15103 }
15104 _ACEOF
15105 rm -f conftest.$ac_objext conftest$ac_exeext
15106 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15107   (eval $ac_link) 2>conftest.er1
15108   ac_status=$?
15109   grep -v '^ *+' conftest.er1 >conftest.err
15110   rm -f conftest.er1
15111   cat conftest.err >&5
15112   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15113   (exit $ac_status); } &&
15114          { ac_try='test -z "$ac_c_werror_flag"
15115                          || test ! -s conftest.err'
15116   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15117   (eval $ac_try) 2>&5
15118   ac_status=$?
15119   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15120   (exit $ac_status); }; } &&
15121          { ac_try='test -s conftest$ac_exeext'
15122   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15123   (eval $ac_try) 2>&5
15124   ac_status=$?
15125   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15126   (exit $ac_status); }; }; then
15127   ac_cv_lib_m_fmodf=yes
15128 else
15129   echo "$as_me: failed program was:" >&5
15130 sed 's/^/| /' conftest.$ac_ext >&5
15131
15132 ac_cv_lib_m_fmodf=no
15133 fi
15134 rm -f conftest.err conftest.$ac_objext \
15135       conftest$ac_exeext conftest.$ac_ext
15136 LIBS=$ac_check_lib_save_LIBS
15137 fi
15138 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fmodf" >&5
15139 echo "${ECHO_T}$ac_cv_lib_m_fmodf" >&6
15140 if test $ac_cv_lib_m_fmodf = yes; then
15141
15142 cat >>confdefs.h <<\_ACEOF
15143 #define HAVE_FMODF 1
15144 _ACEOF
15145
15146 fi
15147
15148 echo "$as_me:$LINENO: checking for fmod in -lm" >&5
15149 echo $ECHO_N "checking for fmod in -lm... $ECHO_C" >&6
15150 if test "${ac_cv_lib_m_fmod+set}" = set; then
15151   echo $ECHO_N "(cached) $ECHO_C" >&6
15152 else
15153   ac_check_lib_save_LIBS=$LIBS
15154 LIBS="-lm  $LIBS"
15155 if test x$gcc_no_link = xyes; then
15156   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15157 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15158    { (exit 1); exit 1; }; }
15159 fi
15160 cat >conftest.$ac_ext <<_ACEOF
15161 /* confdefs.h.  */
15162 _ACEOF
15163 cat confdefs.h >>conftest.$ac_ext
15164 cat >>conftest.$ac_ext <<_ACEOF
15165 /* end confdefs.h.  */
15166
15167 /* Override any gcc2 internal prototype to avoid an error.  */
15168 #ifdef __cplusplus
15169 extern "C"
15170 #endif
15171 /* We use char because int might match the return type of a gcc2
15172    builtin and then its argument prototype would still apply.  */
15173 char fmod ();
15174 int
15175 main ()
15176 {
15177 fmod ();
15178   ;
15179   return 0;
15180 }
15181 _ACEOF
15182 rm -f conftest.$ac_objext conftest$ac_exeext
15183 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15184   (eval $ac_link) 2>conftest.er1
15185   ac_status=$?
15186   grep -v '^ *+' conftest.er1 >conftest.err
15187   rm -f conftest.er1
15188   cat conftest.err >&5
15189   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15190   (exit $ac_status); } &&
15191          { ac_try='test -z "$ac_c_werror_flag"
15192                          || test ! -s conftest.err'
15193   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15194   (eval $ac_try) 2>&5
15195   ac_status=$?
15196   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15197   (exit $ac_status); }; } &&
15198          { ac_try='test -s conftest$ac_exeext'
15199   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15200   (eval $ac_try) 2>&5
15201   ac_status=$?
15202   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15203   (exit $ac_status); }; }; then
15204   ac_cv_lib_m_fmod=yes
15205 else
15206   echo "$as_me: failed program was:" >&5
15207 sed 's/^/| /' conftest.$ac_ext >&5
15208
15209 ac_cv_lib_m_fmod=no
15210 fi
15211 rm -f conftest.err conftest.$ac_objext \
15212       conftest$ac_exeext conftest.$ac_ext
15213 LIBS=$ac_check_lib_save_LIBS
15214 fi
15215 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fmod" >&5
15216 echo "${ECHO_T}$ac_cv_lib_m_fmod" >&6
15217 if test $ac_cv_lib_m_fmod = yes; then
15218
15219 cat >>confdefs.h <<\_ACEOF
15220 #define HAVE_FMOD 1
15221 _ACEOF
15222
15223 fi
15224
15225 echo "$as_me:$LINENO: checking for fmodl in -lm" >&5
15226 echo $ECHO_N "checking for fmodl in -lm... $ECHO_C" >&6
15227 if test "${ac_cv_lib_m_fmodl+set}" = set; then
15228   echo $ECHO_N "(cached) $ECHO_C" >&6
15229 else
15230   ac_check_lib_save_LIBS=$LIBS
15231 LIBS="-lm  $LIBS"
15232 if test x$gcc_no_link = xyes; then
15233   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15234 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15235    { (exit 1); exit 1; }; }
15236 fi
15237 cat >conftest.$ac_ext <<_ACEOF
15238 /* confdefs.h.  */
15239 _ACEOF
15240 cat confdefs.h >>conftest.$ac_ext
15241 cat >>conftest.$ac_ext <<_ACEOF
15242 /* end confdefs.h.  */
15243
15244 /* Override any gcc2 internal prototype to avoid an error.  */
15245 #ifdef __cplusplus
15246 extern "C"
15247 #endif
15248 /* We use char because int might match the return type of a gcc2
15249    builtin and then its argument prototype would still apply.  */
15250 char fmodl ();
15251 int
15252 main ()
15253 {
15254 fmodl ();
15255   ;
15256   return 0;
15257 }
15258 _ACEOF
15259 rm -f conftest.$ac_objext conftest$ac_exeext
15260 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15261   (eval $ac_link) 2>conftest.er1
15262   ac_status=$?
15263   grep -v '^ *+' conftest.er1 >conftest.err
15264   rm -f conftest.er1
15265   cat conftest.err >&5
15266   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15267   (exit $ac_status); } &&
15268          { ac_try='test -z "$ac_c_werror_flag"
15269                          || test ! -s conftest.err'
15270   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15271   (eval $ac_try) 2>&5
15272   ac_status=$?
15273   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15274   (exit $ac_status); }; } &&
15275          { ac_try='test -s conftest$ac_exeext'
15276   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15277   (eval $ac_try) 2>&5
15278   ac_status=$?
15279   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15280   (exit $ac_status); }; }; then
15281   ac_cv_lib_m_fmodl=yes
15282 else
15283   echo "$as_me: failed program was:" >&5
15284 sed 's/^/| /' conftest.$ac_ext >&5
15285
15286 ac_cv_lib_m_fmodl=no
15287 fi
15288 rm -f conftest.err conftest.$ac_objext \
15289       conftest$ac_exeext conftest.$ac_ext
15290 LIBS=$ac_check_lib_save_LIBS
15291 fi
15292 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fmodl" >&5
15293 echo "${ECHO_T}$ac_cv_lib_m_fmodl" >&6
15294 if test $ac_cv_lib_m_fmodl = yes; then
15295
15296 cat >>confdefs.h <<\_ACEOF
15297 #define HAVE_FMODL 1
15298 _ACEOF
15299
15300 fi
15301
15302 echo "$as_me:$LINENO: checking for frexpf in -lm" >&5
15303 echo $ECHO_N "checking for frexpf in -lm... $ECHO_C" >&6
15304 if test "${ac_cv_lib_m_frexpf+set}" = set; then
15305   echo $ECHO_N "(cached) $ECHO_C" >&6
15306 else
15307   ac_check_lib_save_LIBS=$LIBS
15308 LIBS="-lm  $LIBS"
15309 if test x$gcc_no_link = xyes; then
15310   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15311 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15312    { (exit 1); exit 1; }; }
15313 fi
15314 cat >conftest.$ac_ext <<_ACEOF
15315 /* confdefs.h.  */
15316 _ACEOF
15317 cat confdefs.h >>conftest.$ac_ext
15318 cat >>conftest.$ac_ext <<_ACEOF
15319 /* end confdefs.h.  */
15320
15321 /* Override any gcc2 internal prototype to avoid an error.  */
15322 #ifdef __cplusplus
15323 extern "C"
15324 #endif
15325 /* We use char because int might match the return type of a gcc2
15326    builtin and then its argument prototype would still apply.  */
15327 char frexpf ();
15328 int
15329 main ()
15330 {
15331 frexpf ();
15332   ;
15333   return 0;
15334 }
15335 _ACEOF
15336 rm -f conftest.$ac_objext conftest$ac_exeext
15337 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15338   (eval $ac_link) 2>conftest.er1
15339   ac_status=$?
15340   grep -v '^ *+' conftest.er1 >conftest.err
15341   rm -f conftest.er1
15342   cat conftest.err >&5
15343   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15344   (exit $ac_status); } &&
15345          { ac_try='test -z "$ac_c_werror_flag"
15346                          || test ! -s conftest.err'
15347   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15348   (eval $ac_try) 2>&5
15349   ac_status=$?
15350   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15351   (exit $ac_status); }; } &&
15352          { ac_try='test -s conftest$ac_exeext'
15353   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15354   (eval $ac_try) 2>&5
15355   ac_status=$?
15356   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15357   (exit $ac_status); }; }; then
15358   ac_cv_lib_m_frexpf=yes
15359 else
15360   echo "$as_me: failed program was:" >&5
15361 sed 's/^/| /' conftest.$ac_ext >&5
15362
15363 ac_cv_lib_m_frexpf=no
15364 fi
15365 rm -f conftest.err conftest.$ac_objext \
15366       conftest$ac_exeext conftest.$ac_ext
15367 LIBS=$ac_check_lib_save_LIBS
15368 fi
15369 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexpf" >&5
15370 echo "${ECHO_T}$ac_cv_lib_m_frexpf" >&6
15371 if test $ac_cv_lib_m_frexpf = yes; then
15372
15373 cat >>confdefs.h <<\_ACEOF
15374 #define HAVE_FREXPF 1
15375 _ACEOF
15376
15377 fi
15378
15379 echo "$as_me:$LINENO: checking for frexp in -lm" >&5
15380 echo $ECHO_N "checking for frexp in -lm... $ECHO_C" >&6
15381 if test "${ac_cv_lib_m_frexp+set}" = set; then
15382   echo $ECHO_N "(cached) $ECHO_C" >&6
15383 else
15384   ac_check_lib_save_LIBS=$LIBS
15385 LIBS="-lm  $LIBS"
15386 if test x$gcc_no_link = xyes; then
15387   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15388 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15389    { (exit 1); exit 1; }; }
15390 fi
15391 cat >conftest.$ac_ext <<_ACEOF
15392 /* confdefs.h.  */
15393 _ACEOF
15394 cat confdefs.h >>conftest.$ac_ext
15395 cat >>conftest.$ac_ext <<_ACEOF
15396 /* end confdefs.h.  */
15397
15398 /* Override any gcc2 internal prototype to avoid an error.  */
15399 #ifdef __cplusplus
15400 extern "C"
15401 #endif
15402 /* We use char because int might match the return type of a gcc2
15403    builtin and then its argument prototype would still apply.  */
15404 char frexp ();
15405 int
15406 main ()
15407 {
15408 frexp ();
15409   ;
15410   return 0;
15411 }
15412 _ACEOF
15413 rm -f conftest.$ac_objext conftest$ac_exeext
15414 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15415   (eval $ac_link) 2>conftest.er1
15416   ac_status=$?
15417   grep -v '^ *+' conftest.er1 >conftest.err
15418   rm -f conftest.er1
15419   cat conftest.err >&5
15420   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15421   (exit $ac_status); } &&
15422          { ac_try='test -z "$ac_c_werror_flag"
15423                          || test ! -s conftest.err'
15424   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15425   (eval $ac_try) 2>&5
15426   ac_status=$?
15427   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15428   (exit $ac_status); }; } &&
15429          { ac_try='test -s conftest$ac_exeext'
15430   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15431   (eval $ac_try) 2>&5
15432   ac_status=$?
15433   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15434   (exit $ac_status); }; }; then
15435   ac_cv_lib_m_frexp=yes
15436 else
15437   echo "$as_me: failed program was:" >&5
15438 sed 's/^/| /' conftest.$ac_ext >&5
15439
15440 ac_cv_lib_m_frexp=no
15441 fi
15442 rm -f conftest.err conftest.$ac_objext \
15443       conftest$ac_exeext conftest.$ac_ext
15444 LIBS=$ac_check_lib_save_LIBS
15445 fi
15446 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexp" >&5
15447 echo "${ECHO_T}$ac_cv_lib_m_frexp" >&6
15448 if test $ac_cv_lib_m_frexp = yes; then
15449
15450 cat >>confdefs.h <<\_ACEOF
15451 #define HAVE_FREXP 1
15452 _ACEOF
15453
15454 fi
15455
15456 echo "$as_me:$LINENO: checking for frexpl in -lm" >&5
15457 echo $ECHO_N "checking for frexpl in -lm... $ECHO_C" >&6
15458 if test "${ac_cv_lib_m_frexpl+set}" = set; then
15459   echo $ECHO_N "(cached) $ECHO_C" >&6
15460 else
15461   ac_check_lib_save_LIBS=$LIBS
15462 LIBS="-lm  $LIBS"
15463 if test x$gcc_no_link = xyes; then
15464   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15465 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15466    { (exit 1); exit 1; }; }
15467 fi
15468 cat >conftest.$ac_ext <<_ACEOF
15469 /* confdefs.h.  */
15470 _ACEOF
15471 cat confdefs.h >>conftest.$ac_ext
15472 cat >>conftest.$ac_ext <<_ACEOF
15473 /* end confdefs.h.  */
15474
15475 /* Override any gcc2 internal prototype to avoid an error.  */
15476 #ifdef __cplusplus
15477 extern "C"
15478 #endif
15479 /* We use char because int might match the return type of a gcc2
15480    builtin and then its argument prototype would still apply.  */
15481 char frexpl ();
15482 int
15483 main ()
15484 {
15485 frexpl ();
15486   ;
15487   return 0;
15488 }
15489 _ACEOF
15490 rm -f conftest.$ac_objext conftest$ac_exeext
15491 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15492   (eval $ac_link) 2>conftest.er1
15493   ac_status=$?
15494   grep -v '^ *+' conftest.er1 >conftest.err
15495   rm -f conftest.er1
15496   cat conftest.err >&5
15497   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15498   (exit $ac_status); } &&
15499          { ac_try='test -z "$ac_c_werror_flag"
15500                          || test ! -s conftest.err'
15501   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15502   (eval $ac_try) 2>&5
15503   ac_status=$?
15504   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15505   (exit $ac_status); }; } &&
15506          { ac_try='test -s conftest$ac_exeext'
15507   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15508   (eval $ac_try) 2>&5
15509   ac_status=$?
15510   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15511   (exit $ac_status); }; }; then
15512   ac_cv_lib_m_frexpl=yes
15513 else
15514   echo "$as_me: failed program was:" >&5
15515 sed 's/^/| /' conftest.$ac_ext >&5
15516
15517 ac_cv_lib_m_frexpl=no
15518 fi
15519 rm -f conftest.err conftest.$ac_objext \
15520       conftest$ac_exeext conftest.$ac_ext
15521 LIBS=$ac_check_lib_save_LIBS
15522 fi
15523 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexpl" >&5
15524 echo "${ECHO_T}$ac_cv_lib_m_frexpl" >&6
15525 if test $ac_cv_lib_m_frexpl = yes; then
15526
15527 cat >>confdefs.h <<\_ACEOF
15528 #define HAVE_FREXPL 1
15529 _ACEOF
15530
15531 fi
15532
15533 echo "$as_me:$LINENO: checking for hypotf in -lm" >&5
15534 echo $ECHO_N "checking for hypotf in -lm... $ECHO_C" >&6
15535 if test "${ac_cv_lib_m_hypotf+set}" = set; then
15536   echo $ECHO_N "(cached) $ECHO_C" >&6
15537 else
15538   ac_check_lib_save_LIBS=$LIBS
15539 LIBS="-lm  $LIBS"
15540 if test x$gcc_no_link = xyes; then
15541   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15542 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15543    { (exit 1); exit 1; }; }
15544 fi
15545 cat >conftest.$ac_ext <<_ACEOF
15546 /* confdefs.h.  */
15547 _ACEOF
15548 cat confdefs.h >>conftest.$ac_ext
15549 cat >>conftest.$ac_ext <<_ACEOF
15550 /* end confdefs.h.  */
15551
15552 /* Override any gcc2 internal prototype to avoid an error.  */
15553 #ifdef __cplusplus
15554 extern "C"
15555 #endif
15556 /* We use char because int might match the return type of a gcc2
15557    builtin and then its argument prototype would still apply.  */
15558 char hypotf ();
15559 int
15560 main ()
15561 {
15562 hypotf ();
15563   ;
15564   return 0;
15565 }
15566 _ACEOF
15567 rm -f conftest.$ac_objext conftest$ac_exeext
15568 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15569   (eval $ac_link) 2>conftest.er1
15570   ac_status=$?
15571   grep -v '^ *+' conftest.er1 >conftest.err
15572   rm -f conftest.er1
15573   cat conftest.err >&5
15574   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15575   (exit $ac_status); } &&
15576          { ac_try='test -z "$ac_c_werror_flag"
15577                          || test ! -s conftest.err'
15578   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15579   (eval $ac_try) 2>&5
15580   ac_status=$?
15581   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15582   (exit $ac_status); }; } &&
15583          { ac_try='test -s conftest$ac_exeext'
15584   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15585   (eval $ac_try) 2>&5
15586   ac_status=$?
15587   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15588   (exit $ac_status); }; }; then
15589   ac_cv_lib_m_hypotf=yes
15590 else
15591   echo "$as_me: failed program was:" >&5
15592 sed 's/^/| /' conftest.$ac_ext >&5
15593
15594 ac_cv_lib_m_hypotf=no
15595 fi
15596 rm -f conftest.err conftest.$ac_objext \
15597       conftest$ac_exeext conftest.$ac_ext
15598 LIBS=$ac_check_lib_save_LIBS
15599 fi
15600 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypotf" >&5
15601 echo "${ECHO_T}$ac_cv_lib_m_hypotf" >&6
15602 if test $ac_cv_lib_m_hypotf = yes; then
15603
15604 cat >>confdefs.h <<\_ACEOF
15605 #define HAVE_HYPOTF 1
15606 _ACEOF
15607
15608 fi
15609
15610 echo "$as_me:$LINENO: checking for hypot in -lm" >&5
15611 echo $ECHO_N "checking for hypot in -lm... $ECHO_C" >&6
15612 if test "${ac_cv_lib_m_hypot+set}" = set; then
15613   echo $ECHO_N "(cached) $ECHO_C" >&6
15614 else
15615   ac_check_lib_save_LIBS=$LIBS
15616 LIBS="-lm  $LIBS"
15617 if test x$gcc_no_link = xyes; then
15618   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15619 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15620    { (exit 1); exit 1; }; }
15621 fi
15622 cat >conftest.$ac_ext <<_ACEOF
15623 /* confdefs.h.  */
15624 _ACEOF
15625 cat confdefs.h >>conftest.$ac_ext
15626 cat >>conftest.$ac_ext <<_ACEOF
15627 /* end confdefs.h.  */
15628
15629 /* Override any gcc2 internal prototype to avoid an error.  */
15630 #ifdef __cplusplus
15631 extern "C"
15632 #endif
15633 /* We use char because int might match the return type of a gcc2
15634    builtin and then its argument prototype would still apply.  */
15635 char hypot ();
15636 int
15637 main ()
15638 {
15639 hypot ();
15640   ;
15641   return 0;
15642 }
15643 _ACEOF
15644 rm -f conftest.$ac_objext conftest$ac_exeext
15645 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15646   (eval $ac_link) 2>conftest.er1
15647   ac_status=$?
15648   grep -v '^ *+' conftest.er1 >conftest.err
15649   rm -f conftest.er1
15650   cat conftest.err >&5
15651   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15652   (exit $ac_status); } &&
15653          { ac_try='test -z "$ac_c_werror_flag"
15654                          || test ! -s conftest.err'
15655   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15656   (eval $ac_try) 2>&5
15657   ac_status=$?
15658   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15659   (exit $ac_status); }; } &&
15660          { ac_try='test -s conftest$ac_exeext'
15661   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15662   (eval $ac_try) 2>&5
15663   ac_status=$?
15664   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15665   (exit $ac_status); }; }; then
15666   ac_cv_lib_m_hypot=yes
15667 else
15668   echo "$as_me: failed program was:" >&5
15669 sed 's/^/| /' conftest.$ac_ext >&5
15670
15671 ac_cv_lib_m_hypot=no
15672 fi
15673 rm -f conftest.err conftest.$ac_objext \
15674       conftest$ac_exeext conftest.$ac_ext
15675 LIBS=$ac_check_lib_save_LIBS
15676 fi
15677 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypot" >&5
15678 echo "${ECHO_T}$ac_cv_lib_m_hypot" >&6
15679 if test $ac_cv_lib_m_hypot = yes; then
15680
15681 cat >>confdefs.h <<\_ACEOF
15682 #define HAVE_HYPOT 1
15683 _ACEOF
15684
15685 fi
15686
15687 echo "$as_me:$LINENO: checking for hypotl in -lm" >&5
15688 echo $ECHO_N "checking for hypotl in -lm... $ECHO_C" >&6
15689 if test "${ac_cv_lib_m_hypotl+set}" = set; then
15690   echo $ECHO_N "(cached) $ECHO_C" >&6
15691 else
15692   ac_check_lib_save_LIBS=$LIBS
15693 LIBS="-lm  $LIBS"
15694 if test x$gcc_no_link = xyes; then
15695   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15696 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15697    { (exit 1); exit 1; }; }
15698 fi
15699 cat >conftest.$ac_ext <<_ACEOF
15700 /* confdefs.h.  */
15701 _ACEOF
15702 cat confdefs.h >>conftest.$ac_ext
15703 cat >>conftest.$ac_ext <<_ACEOF
15704 /* end confdefs.h.  */
15705
15706 /* Override any gcc2 internal prototype to avoid an error.  */
15707 #ifdef __cplusplus
15708 extern "C"
15709 #endif
15710 /* We use char because int might match the return type of a gcc2
15711    builtin and then its argument prototype would still apply.  */
15712 char hypotl ();
15713 int
15714 main ()
15715 {
15716 hypotl ();
15717   ;
15718   return 0;
15719 }
15720 _ACEOF
15721 rm -f conftest.$ac_objext conftest$ac_exeext
15722 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15723   (eval $ac_link) 2>conftest.er1
15724   ac_status=$?
15725   grep -v '^ *+' conftest.er1 >conftest.err
15726   rm -f conftest.er1
15727   cat conftest.err >&5
15728   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15729   (exit $ac_status); } &&
15730          { ac_try='test -z "$ac_c_werror_flag"
15731                          || test ! -s conftest.err'
15732   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15733   (eval $ac_try) 2>&5
15734   ac_status=$?
15735   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15736   (exit $ac_status); }; } &&
15737          { ac_try='test -s conftest$ac_exeext'
15738   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15739   (eval $ac_try) 2>&5
15740   ac_status=$?
15741   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15742   (exit $ac_status); }; }; then
15743   ac_cv_lib_m_hypotl=yes
15744 else
15745   echo "$as_me: failed program was:" >&5
15746 sed 's/^/| /' conftest.$ac_ext >&5
15747
15748 ac_cv_lib_m_hypotl=no
15749 fi
15750 rm -f conftest.err conftest.$ac_objext \
15751       conftest$ac_exeext conftest.$ac_ext
15752 LIBS=$ac_check_lib_save_LIBS
15753 fi
15754 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypotl" >&5
15755 echo "${ECHO_T}$ac_cv_lib_m_hypotl" >&6
15756 if test $ac_cv_lib_m_hypotl = yes; then
15757
15758 cat >>confdefs.h <<\_ACEOF
15759 #define HAVE_HYPOTL 1
15760 _ACEOF
15761
15762 fi
15763
15764 echo "$as_me:$LINENO: checking for ldexpf in -lm" >&5
15765 echo $ECHO_N "checking for ldexpf in -lm... $ECHO_C" >&6
15766 if test "${ac_cv_lib_m_ldexpf+set}" = set; then
15767   echo $ECHO_N "(cached) $ECHO_C" >&6
15768 else
15769   ac_check_lib_save_LIBS=$LIBS
15770 LIBS="-lm  $LIBS"
15771 if test x$gcc_no_link = xyes; then
15772   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15773 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15774    { (exit 1); exit 1; }; }
15775 fi
15776 cat >conftest.$ac_ext <<_ACEOF
15777 /* confdefs.h.  */
15778 _ACEOF
15779 cat confdefs.h >>conftest.$ac_ext
15780 cat >>conftest.$ac_ext <<_ACEOF
15781 /* end confdefs.h.  */
15782
15783 /* Override any gcc2 internal prototype to avoid an error.  */
15784 #ifdef __cplusplus
15785 extern "C"
15786 #endif
15787 /* We use char because int might match the return type of a gcc2
15788    builtin and then its argument prototype would still apply.  */
15789 char ldexpf ();
15790 int
15791 main ()
15792 {
15793 ldexpf ();
15794   ;
15795   return 0;
15796 }
15797 _ACEOF
15798 rm -f conftest.$ac_objext conftest$ac_exeext
15799 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15800   (eval $ac_link) 2>conftest.er1
15801   ac_status=$?
15802   grep -v '^ *+' conftest.er1 >conftest.err
15803   rm -f conftest.er1
15804   cat conftest.err >&5
15805   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15806   (exit $ac_status); } &&
15807          { ac_try='test -z "$ac_c_werror_flag"
15808                          || test ! -s conftest.err'
15809   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15810   (eval $ac_try) 2>&5
15811   ac_status=$?
15812   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15813   (exit $ac_status); }; } &&
15814          { ac_try='test -s conftest$ac_exeext'
15815   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15816   (eval $ac_try) 2>&5
15817   ac_status=$?
15818   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15819   (exit $ac_status); }; }; then
15820   ac_cv_lib_m_ldexpf=yes
15821 else
15822   echo "$as_me: failed program was:" >&5
15823 sed 's/^/| /' conftest.$ac_ext >&5
15824
15825 ac_cv_lib_m_ldexpf=no
15826 fi
15827 rm -f conftest.err conftest.$ac_objext \
15828       conftest$ac_exeext conftest.$ac_ext
15829 LIBS=$ac_check_lib_save_LIBS
15830 fi
15831 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ldexpf" >&5
15832 echo "${ECHO_T}$ac_cv_lib_m_ldexpf" >&6
15833 if test $ac_cv_lib_m_ldexpf = yes; then
15834
15835 cat >>confdefs.h <<\_ACEOF
15836 #define HAVE_LDEXPF 1
15837 _ACEOF
15838
15839 fi
15840
15841 echo "$as_me:$LINENO: checking for ldexp in -lm" >&5
15842 echo $ECHO_N "checking for ldexp in -lm... $ECHO_C" >&6
15843 if test "${ac_cv_lib_m_ldexp+set}" = set; then
15844   echo $ECHO_N "(cached) $ECHO_C" >&6
15845 else
15846   ac_check_lib_save_LIBS=$LIBS
15847 LIBS="-lm  $LIBS"
15848 if test x$gcc_no_link = xyes; then
15849   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15850 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15851    { (exit 1); exit 1; }; }
15852 fi
15853 cat >conftest.$ac_ext <<_ACEOF
15854 /* confdefs.h.  */
15855 _ACEOF
15856 cat confdefs.h >>conftest.$ac_ext
15857 cat >>conftest.$ac_ext <<_ACEOF
15858 /* end confdefs.h.  */
15859
15860 /* Override any gcc2 internal prototype to avoid an error.  */
15861 #ifdef __cplusplus
15862 extern "C"
15863 #endif
15864 /* We use char because int might match the return type of a gcc2
15865    builtin and then its argument prototype would still apply.  */
15866 char ldexp ();
15867 int
15868 main ()
15869 {
15870 ldexp ();
15871   ;
15872   return 0;
15873 }
15874 _ACEOF
15875 rm -f conftest.$ac_objext conftest$ac_exeext
15876 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15877   (eval $ac_link) 2>conftest.er1
15878   ac_status=$?
15879   grep -v '^ *+' conftest.er1 >conftest.err
15880   rm -f conftest.er1
15881   cat conftest.err >&5
15882   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15883   (exit $ac_status); } &&
15884          { ac_try='test -z "$ac_c_werror_flag"
15885                          || test ! -s conftest.err'
15886   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15887   (eval $ac_try) 2>&5
15888   ac_status=$?
15889   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15890   (exit $ac_status); }; } &&
15891          { ac_try='test -s conftest$ac_exeext'
15892   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15893   (eval $ac_try) 2>&5
15894   ac_status=$?
15895   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15896   (exit $ac_status); }; }; then
15897   ac_cv_lib_m_ldexp=yes
15898 else
15899   echo "$as_me: failed program was:" >&5
15900 sed 's/^/| /' conftest.$ac_ext >&5
15901
15902 ac_cv_lib_m_ldexp=no
15903 fi
15904 rm -f conftest.err conftest.$ac_objext \
15905       conftest$ac_exeext conftest.$ac_ext
15906 LIBS=$ac_check_lib_save_LIBS
15907 fi
15908 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ldexp" >&5
15909 echo "${ECHO_T}$ac_cv_lib_m_ldexp" >&6
15910 if test $ac_cv_lib_m_ldexp = yes; then
15911
15912 cat >>confdefs.h <<\_ACEOF
15913 #define HAVE_LDEXP 1
15914 _ACEOF
15915
15916 fi
15917
15918 echo "$as_me:$LINENO: checking for ldexpl in -lm" >&5
15919 echo $ECHO_N "checking for ldexpl in -lm... $ECHO_C" >&6
15920 if test "${ac_cv_lib_m_ldexpl+set}" = set; then
15921   echo $ECHO_N "(cached) $ECHO_C" >&6
15922 else
15923   ac_check_lib_save_LIBS=$LIBS
15924 LIBS="-lm  $LIBS"
15925 if test x$gcc_no_link = xyes; then
15926   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15927 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15928    { (exit 1); exit 1; }; }
15929 fi
15930 cat >conftest.$ac_ext <<_ACEOF
15931 /* confdefs.h.  */
15932 _ACEOF
15933 cat confdefs.h >>conftest.$ac_ext
15934 cat >>conftest.$ac_ext <<_ACEOF
15935 /* end confdefs.h.  */
15936
15937 /* Override any gcc2 internal prototype to avoid an error.  */
15938 #ifdef __cplusplus
15939 extern "C"
15940 #endif
15941 /* We use char because int might match the return type of a gcc2
15942    builtin and then its argument prototype would still apply.  */
15943 char ldexpl ();
15944 int
15945 main ()
15946 {
15947 ldexpl ();
15948   ;
15949   return 0;
15950 }
15951 _ACEOF
15952 rm -f conftest.$ac_objext conftest$ac_exeext
15953 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15954   (eval $ac_link) 2>conftest.er1
15955   ac_status=$?
15956   grep -v '^ *+' conftest.er1 >conftest.err
15957   rm -f conftest.er1
15958   cat conftest.err >&5
15959   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15960   (exit $ac_status); } &&
15961          { ac_try='test -z "$ac_c_werror_flag"
15962                          || test ! -s conftest.err'
15963   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15964   (eval $ac_try) 2>&5
15965   ac_status=$?
15966   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15967   (exit $ac_status); }; } &&
15968          { ac_try='test -s conftest$ac_exeext'
15969   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15970   (eval $ac_try) 2>&5
15971   ac_status=$?
15972   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15973   (exit $ac_status); }; }; then
15974   ac_cv_lib_m_ldexpl=yes
15975 else
15976   echo "$as_me: failed program was:" >&5
15977 sed 's/^/| /' conftest.$ac_ext >&5
15978
15979 ac_cv_lib_m_ldexpl=no
15980 fi
15981 rm -f conftest.err conftest.$ac_objext \
15982       conftest$ac_exeext conftest.$ac_ext
15983 LIBS=$ac_check_lib_save_LIBS
15984 fi
15985 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ldexpl" >&5
15986 echo "${ECHO_T}$ac_cv_lib_m_ldexpl" >&6
15987 if test $ac_cv_lib_m_ldexpl = yes; then
15988
15989 cat >>confdefs.h <<\_ACEOF
15990 #define HAVE_LDEXPL 1
15991 _ACEOF
15992
15993 fi
15994
15995 echo "$as_me:$LINENO: checking for logf in -lm" >&5
15996 echo $ECHO_N "checking for logf in -lm... $ECHO_C" >&6
15997 if test "${ac_cv_lib_m_logf+set}" = set; then
15998   echo $ECHO_N "(cached) $ECHO_C" >&6
15999 else
16000   ac_check_lib_save_LIBS=$LIBS
16001 LIBS="-lm  $LIBS"
16002 if test x$gcc_no_link = xyes; then
16003   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16004 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16005    { (exit 1); exit 1; }; }
16006 fi
16007 cat >conftest.$ac_ext <<_ACEOF
16008 /* confdefs.h.  */
16009 _ACEOF
16010 cat confdefs.h >>conftest.$ac_ext
16011 cat >>conftest.$ac_ext <<_ACEOF
16012 /* end confdefs.h.  */
16013
16014 /* Override any gcc2 internal prototype to avoid an error.  */
16015 #ifdef __cplusplus
16016 extern "C"
16017 #endif
16018 /* We use char because int might match the return type of a gcc2
16019    builtin and then its argument prototype would still apply.  */
16020 char logf ();
16021 int
16022 main ()
16023 {
16024 logf ();
16025   ;
16026   return 0;
16027 }
16028 _ACEOF
16029 rm -f conftest.$ac_objext conftest$ac_exeext
16030 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16031   (eval $ac_link) 2>conftest.er1
16032   ac_status=$?
16033   grep -v '^ *+' conftest.er1 >conftest.err
16034   rm -f conftest.er1
16035   cat conftest.err >&5
16036   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16037   (exit $ac_status); } &&
16038          { ac_try='test -z "$ac_c_werror_flag"
16039                          || test ! -s conftest.err'
16040   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16041   (eval $ac_try) 2>&5
16042   ac_status=$?
16043   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16044   (exit $ac_status); }; } &&
16045          { ac_try='test -s conftest$ac_exeext'
16046   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16047   (eval $ac_try) 2>&5
16048   ac_status=$?
16049   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16050   (exit $ac_status); }; }; then
16051   ac_cv_lib_m_logf=yes
16052 else
16053   echo "$as_me: failed program was:" >&5
16054 sed 's/^/| /' conftest.$ac_ext >&5
16055
16056 ac_cv_lib_m_logf=no
16057 fi
16058 rm -f conftest.err conftest.$ac_objext \
16059       conftest$ac_exeext conftest.$ac_ext
16060 LIBS=$ac_check_lib_save_LIBS
16061 fi
16062 echo "$as_me:$LINENO: result: $ac_cv_lib_m_logf" >&5
16063 echo "${ECHO_T}$ac_cv_lib_m_logf" >&6
16064 if test $ac_cv_lib_m_logf = yes; then
16065
16066 cat >>confdefs.h <<\_ACEOF
16067 #define HAVE_LOGF 1
16068 _ACEOF
16069
16070 fi
16071
16072 echo "$as_me:$LINENO: checking for log in -lm" >&5
16073 echo $ECHO_N "checking for log in -lm... $ECHO_C" >&6
16074 if test "${ac_cv_lib_m_log+set}" = set; then
16075   echo $ECHO_N "(cached) $ECHO_C" >&6
16076 else
16077   ac_check_lib_save_LIBS=$LIBS
16078 LIBS="-lm  $LIBS"
16079 if test x$gcc_no_link = xyes; then
16080   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16081 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16082    { (exit 1); exit 1; }; }
16083 fi
16084 cat >conftest.$ac_ext <<_ACEOF
16085 /* confdefs.h.  */
16086 _ACEOF
16087 cat confdefs.h >>conftest.$ac_ext
16088 cat >>conftest.$ac_ext <<_ACEOF
16089 /* end confdefs.h.  */
16090
16091 /* Override any gcc2 internal prototype to avoid an error.  */
16092 #ifdef __cplusplus
16093 extern "C"
16094 #endif
16095 /* We use char because int might match the return type of a gcc2
16096    builtin and then its argument prototype would still apply.  */
16097 char log ();
16098 int
16099 main ()
16100 {
16101 log ();
16102   ;
16103   return 0;
16104 }
16105 _ACEOF
16106 rm -f conftest.$ac_objext conftest$ac_exeext
16107 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16108   (eval $ac_link) 2>conftest.er1
16109   ac_status=$?
16110   grep -v '^ *+' conftest.er1 >conftest.err
16111   rm -f conftest.er1
16112   cat conftest.err >&5
16113   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16114   (exit $ac_status); } &&
16115          { ac_try='test -z "$ac_c_werror_flag"
16116                          || test ! -s conftest.err'
16117   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16118   (eval $ac_try) 2>&5
16119   ac_status=$?
16120   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16121   (exit $ac_status); }; } &&
16122          { ac_try='test -s conftest$ac_exeext'
16123   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16124   (eval $ac_try) 2>&5
16125   ac_status=$?
16126   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16127   (exit $ac_status); }; }; then
16128   ac_cv_lib_m_log=yes
16129 else
16130   echo "$as_me: failed program was:" >&5
16131 sed 's/^/| /' conftest.$ac_ext >&5
16132
16133 ac_cv_lib_m_log=no
16134 fi
16135 rm -f conftest.err conftest.$ac_objext \
16136       conftest$ac_exeext conftest.$ac_ext
16137 LIBS=$ac_check_lib_save_LIBS
16138 fi
16139 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log" >&5
16140 echo "${ECHO_T}$ac_cv_lib_m_log" >&6
16141 if test $ac_cv_lib_m_log = yes; then
16142
16143 cat >>confdefs.h <<\_ACEOF
16144 #define HAVE_LOG 1
16145 _ACEOF
16146
16147 fi
16148
16149 echo "$as_me:$LINENO: checking for logl in -lm" >&5
16150 echo $ECHO_N "checking for logl in -lm... $ECHO_C" >&6
16151 if test "${ac_cv_lib_m_logl+set}" = set; then
16152   echo $ECHO_N "(cached) $ECHO_C" >&6
16153 else
16154   ac_check_lib_save_LIBS=$LIBS
16155 LIBS="-lm  $LIBS"
16156 if test x$gcc_no_link = xyes; then
16157   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16158 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16159    { (exit 1); exit 1; }; }
16160 fi
16161 cat >conftest.$ac_ext <<_ACEOF
16162 /* confdefs.h.  */
16163 _ACEOF
16164 cat confdefs.h >>conftest.$ac_ext
16165 cat >>conftest.$ac_ext <<_ACEOF
16166 /* end confdefs.h.  */
16167
16168 /* Override any gcc2 internal prototype to avoid an error.  */
16169 #ifdef __cplusplus
16170 extern "C"
16171 #endif
16172 /* We use char because int might match the return type of a gcc2
16173    builtin and then its argument prototype would still apply.  */
16174 char logl ();
16175 int
16176 main ()
16177 {
16178 logl ();
16179   ;
16180   return 0;
16181 }
16182 _ACEOF
16183 rm -f conftest.$ac_objext conftest$ac_exeext
16184 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16185   (eval $ac_link) 2>conftest.er1
16186   ac_status=$?
16187   grep -v '^ *+' conftest.er1 >conftest.err
16188   rm -f conftest.er1
16189   cat conftest.err >&5
16190   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16191   (exit $ac_status); } &&
16192          { ac_try='test -z "$ac_c_werror_flag"
16193                          || test ! -s conftest.err'
16194   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16195   (eval $ac_try) 2>&5
16196   ac_status=$?
16197   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16198   (exit $ac_status); }; } &&
16199          { ac_try='test -s conftest$ac_exeext'
16200   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16201   (eval $ac_try) 2>&5
16202   ac_status=$?
16203   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16204   (exit $ac_status); }; }; then
16205   ac_cv_lib_m_logl=yes
16206 else
16207   echo "$as_me: failed program was:" >&5
16208 sed 's/^/| /' conftest.$ac_ext >&5
16209
16210 ac_cv_lib_m_logl=no
16211 fi
16212 rm -f conftest.err conftest.$ac_objext \
16213       conftest$ac_exeext conftest.$ac_ext
16214 LIBS=$ac_check_lib_save_LIBS
16215 fi
16216 echo "$as_me:$LINENO: result: $ac_cv_lib_m_logl" >&5
16217 echo "${ECHO_T}$ac_cv_lib_m_logl" >&6
16218 if test $ac_cv_lib_m_logl = yes; then
16219
16220 cat >>confdefs.h <<\_ACEOF
16221 #define HAVE_LOGL 1
16222 _ACEOF
16223
16224 fi
16225
16226 echo "$as_me:$LINENO: checking for clogf in -lm" >&5
16227 echo $ECHO_N "checking for clogf in -lm... $ECHO_C" >&6
16228 if test "${ac_cv_lib_m_clogf+set}" = set; then
16229   echo $ECHO_N "(cached) $ECHO_C" >&6
16230 else
16231   ac_check_lib_save_LIBS=$LIBS
16232 LIBS="-lm  $LIBS"
16233 if test x$gcc_no_link = xyes; then
16234   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16235 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16236    { (exit 1); exit 1; }; }
16237 fi
16238 cat >conftest.$ac_ext <<_ACEOF
16239 /* confdefs.h.  */
16240 _ACEOF
16241 cat confdefs.h >>conftest.$ac_ext
16242 cat >>conftest.$ac_ext <<_ACEOF
16243 /* end confdefs.h.  */
16244
16245 /* Override any gcc2 internal prototype to avoid an error.  */
16246 #ifdef __cplusplus
16247 extern "C"
16248 #endif
16249 /* We use char because int might match the return type of a gcc2
16250    builtin and then its argument prototype would still apply.  */
16251 char clogf ();
16252 int
16253 main ()
16254 {
16255 clogf ();
16256   ;
16257   return 0;
16258 }
16259 _ACEOF
16260 rm -f conftest.$ac_objext conftest$ac_exeext
16261 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16262   (eval $ac_link) 2>conftest.er1
16263   ac_status=$?
16264   grep -v '^ *+' conftest.er1 >conftest.err
16265   rm -f conftest.er1
16266   cat conftest.err >&5
16267   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16268   (exit $ac_status); } &&
16269          { ac_try='test -z "$ac_c_werror_flag"
16270                          || test ! -s conftest.err'
16271   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16272   (eval $ac_try) 2>&5
16273   ac_status=$?
16274   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16275   (exit $ac_status); }; } &&
16276          { ac_try='test -s conftest$ac_exeext'
16277   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16278   (eval $ac_try) 2>&5
16279   ac_status=$?
16280   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16281   (exit $ac_status); }; }; then
16282   ac_cv_lib_m_clogf=yes
16283 else
16284   echo "$as_me: failed program was:" >&5
16285 sed 's/^/| /' conftest.$ac_ext >&5
16286
16287 ac_cv_lib_m_clogf=no
16288 fi
16289 rm -f conftest.err conftest.$ac_objext \
16290       conftest$ac_exeext conftest.$ac_ext
16291 LIBS=$ac_check_lib_save_LIBS
16292 fi
16293 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clogf" >&5
16294 echo "${ECHO_T}$ac_cv_lib_m_clogf" >&6
16295 if test $ac_cv_lib_m_clogf = yes; then
16296
16297 cat >>confdefs.h <<\_ACEOF
16298 #define HAVE_CLOGF 1
16299 _ACEOF
16300
16301 fi
16302
16303 echo "$as_me:$LINENO: checking for clog in -lm" >&5
16304 echo $ECHO_N "checking for clog in -lm... $ECHO_C" >&6
16305 if test "${ac_cv_lib_m_clog+set}" = set; then
16306   echo $ECHO_N "(cached) $ECHO_C" >&6
16307 else
16308   ac_check_lib_save_LIBS=$LIBS
16309 LIBS="-lm  $LIBS"
16310 if test x$gcc_no_link = xyes; then
16311   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16312 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16313    { (exit 1); exit 1; }; }
16314 fi
16315 cat >conftest.$ac_ext <<_ACEOF
16316 /* confdefs.h.  */
16317 _ACEOF
16318 cat confdefs.h >>conftest.$ac_ext
16319 cat >>conftest.$ac_ext <<_ACEOF
16320 /* end confdefs.h.  */
16321
16322 /* Override any gcc2 internal prototype to avoid an error.  */
16323 #ifdef __cplusplus
16324 extern "C"
16325 #endif
16326 /* We use char because int might match the return type of a gcc2
16327    builtin and then its argument prototype would still apply.  */
16328 char clog ();
16329 int
16330 main ()
16331 {
16332 clog ();
16333   ;
16334   return 0;
16335 }
16336 _ACEOF
16337 rm -f conftest.$ac_objext conftest$ac_exeext
16338 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16339   (eval $ac_link) 2>conftest.er1
16340   ac_status=$?
16341   grep -v '^ *+' conftest.er1 >conftest.err
16342   rm -f conftest.er1
16343   cat conftest.err >&5
16344   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16345   (exit $ac_status); } &&
16346          { ac_try='test -z "$ac_c_werror_flag"
16347                          || test ! -s conftest.err'
16348   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16349   (eval $ac_try) 2>&5
16350   ac_status=$?
16351   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16352   (exit $ac_status); }; } &&
16353          { ac_try='test -s conftest$ac_exeext'
16354   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16355   (eval $ac_try) 2>&5
16356   ac_status=$?
16357   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16358   (exit $ac_status); }; }; then
16359   ac_cv_lib_m_clog=yes
16360 else
16361   echo "$as_me: failed program was:" >&5
16362 sed 's/^/| /' conftest.$ac_ext >&5
16363
16364 ac_cv_lib_m_clog=no
16365 fi
16366 rm -f conftest.err conftest.$ac_objext \
16367       conftest$ac_exeext conftest.$ac_ext
16368 LIBS=$ac_check_lib_save_LIBS
16369 fi
16370 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog" >&5
16371 echo "${ECHO_T}$ac_cv_lib_m_clog" >&6
16372 if test $ac_cv_lib_m_clog = yes; then
16373
16374 cat >>confdefs.h <<\_ACEOF
16375 #define HAVE_CLOG 1
16376 _ACEOF
16377
16378 fi
16379
16380 echo "$as_me:$LINENO: checking for clogl in -lm" >&5
16381 echo $ECHO_N "checking for clogl in -lm... $ECHO_C" >&6
16382 if test "${ac_cv_lib_m_clogl+set}" = set; then
16383   echo $ECHO_N "(cached) $ECHO_C" >&6
16384 else
16385   ac_check_lib_save_LIBS=$LIBS
16386 LIBS="-lm  $LIBS"
16387 if test x$gcc_no_link = xyes; then
16388   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16389 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16390    { (exit 1); exit 1; }; }
16391 fi
16392 cat >conftest.$ac_ext <<_ACEOF
16393 /* confdefs.h.  */
16394 _ACEOF
16395 cat confdefs.h >>conftest.$ac_ext
16396 cat >>conftest.$ac_ext <<_ACEOF
16397 /* end confdefs.h.  */
16398
16399 /* Override any gcc2 internal prototype to avoid an error.  */
16400 #ifdef __cplusplus
16401 extern "C"
16402 #endif
16403 /* We use char because int might match the return type of a gcc2
16404    builtin and then its argument prototype would still apply.  */
16405 char clogl ();
16406 int
16407 main ()
16408 {
16409 clogl ();
16410   ;
16411   return 0;
16412 }
16413 _ACEOF
16414 rm -f conftest.$ac_objext conftest$ac_exeext
16415 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16416   (eval $ac_link) 2>conftest.er1
16417   ac_status=$?
16418   grep -v '^ *+' conftest.er1 >conftest.err
16419   rm -f conftest.er1
16420   cat conftest.err >&5
16421   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16422   (exit $ac_status); } &&
16423          { ac_try='test -z "$ac_c_werror_flag"
16424                          || test ! -s conftest.err'
16425   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16426   (eval $ac_try) 2>&5
16427   ac_status=$?
16428   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16429   (exit $ac_status); }; } &&
16430          { ac_try='test -s conftest$ac_exeext'
16431   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16432   (eval $ac_try) 2>&5
16433   ac_status=$?
16434   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16435   (exit $ac_status); }; }; then
16436   ac_cv_lib_m_clogl=yes
16437 else
16438   echo "$as_me: failed program was:" >&5
16439 sed 's/^/| /' conftest.$ac_ext >&5
16440
16441 ac_cv_lib_m_clogl=no
16442 fi
16443 rm -f conftest.err conftest.$ac_objext \
16444       conftest$ac_exeext conftest.$ac_ext
16445 LIBS=$ac_check_lib_save_LIBS
16446 fi
16447 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clogl" >&5
16448 echo "${ECHO_T}$ac_cv_lib_m_clogl" >&6
16449 if test $ac_cv_lib_m_clogl = yes; then
16450
16451 cat >>confdefs.h <<\_ACEOF
16452 #define HAVE_CLOGL 1
16453 _ACEOF
16454
16455 fi
16456
16457 echo "$as_me:$LINENO: checking for log10f in -lm" >&5
16458 echo $ECHO_N "checking for log10f in -lm... $ECHO_C" >&6
16459 if test "${ac_cv_lib_m_log10f+set}" = set; then
16460   echo $ECHO_N "(cached) $ECHO_C" >&6
16461 else
16462   ac_check_lib_save_LIBS=$LIBS
16463 LIBS="-lm  $LIBS"
16464 if test x$gcc_no_link = xyes; then
16465   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16466 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16467    { (exit 1); exit 1; }; }
16468 fi
16469 cat >conftest.$ac_ext <<_ACEOF
16470 /* confdefs.h.  */
16471 _ACEOF
16472 cat confdefs.h >>conftest.$ac_ext
16473 cat >>conftest.$ac_ext <<_ACEOF
16474 /* end confdefs.h.  */
16475
16476 /* Override any gcc2 internal prototype to avoid an error.  */
16477 #ifdef __cplusplus
16478 extern "C"
16479 #endif
16480 /* We use char because int might match the return type of a gcc2
16481    builtin and then its argument prototype would still apply.  */
16482 char log10f ();
16483 int
16484 main ()
16485 {
16486 log10f ();
16487   ;
16488   return 0;
16489 }
16490 _ACEOF
16491 rm -f conftest.$ac_objext conftest$ac_exeext
16492 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16493   (eval $ac_link) 2>conftest.er1
16494   ac_status=$?
16495   grep -v '^ *+' conftest.er1 >conftest.err
16496   rm -f conftest.er1
16497   cat conftest.err >&5
16498   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16499   (exit $ac_status); } &&
16500          { ac_try='test -z "$ac_c_werror_flag"
16501                          || test ! -s conftest.err'
16502   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16503   (eval $ac_try) 2>&5
16504   ac_status=$?
16505   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16506   (exit $ac_status); }; } &&
16507          { ac_try='test -s conftest$ac_exeext'
16508   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16509   (eval $ac_try) 2>&5
16510   ac_status=$?
16511   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16512   (exit $ac_status); }; }; then
16513   ac_cv_lib_m_log10f=yes
16514 else
16515   echo "$as_me: failed program was:" >&5
16516 sed 's/^/| /' conftest.$ac_ext >&5
16517
16518 ac_cv_lib_m_log10f=no
16519 fi
16520 rm -f conftest.err conftest.$ac_objext \
16521       conftest$ac_exeext conftest.$ac_ext
16522 LIBS=$ac_check_lib_save_LIBS
16523 fi
16524 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10f" >&5
16525 echo "${ECHO_T}$ac_cv_lib_m_log10f" >&6
16526 if test $ac_cv_lib_m_log10f = yes; then
16527
16528 cat >>confdefs.h <<\_ACEOF
16529 #define HAVE_LOG10F 1
16530 _ACEOF
16531
16532 fi
16533
16534 echo "$as_me:$LINENO: checking for log10 in -lm" >&5
16535 echo $ECHO_N "checking for log10 in -lm... $ECHO_C" >&6
16536 if test "${ac_cv_lib_m_log10+set}" = set; then
16537   echo $ECHO_N "(cached) $ECHO_C" >&6
16538 else
16539   ac_check_lib_save_LIBS=$LIBS
16540 LIBS="-lm  $LIBS"
16541 if test x$gcc_no_link = xyes; then
16542   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16543 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16544    { (exit 1); exit 1; }; }
16545 fi
16546 cat >conftest.$ac_ext <<_ACEOF
16547 /* confdefs.h.  */
16548 _ACEOF
16549 cat confdefs.h >>conftest.$ac_ext
16550 cat >>conftest.$ac_ext <<_ACEOF
16551 /* end confdefs.h.  */
16552
16553 /* Override any gcc2 internal prototype to avoid an error.  */
16554 #ifdef __cplusplus
16555 extern "C"
16556 #endif
16557 /* We use char because int might match the return type of a gcc2
16558    builtin and then its argument prototype would still apply.  */
16559 char log10 ();
16560 int
16561 main ()
16562 {
16563 log10 ();
16564   ;
16565   return 0;
16566 }
16567 _ACEOF
16568 rm -f conftest.$ac_objext conftest$ac_exeext
16569 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16570   (eval $ac_link) 2>conftest.er1
16571   ac_status=$?
16572   grep -v '^ *+' conftest.er1 >conftest.err
16573   rm -f conftest.er1
16574   cat conftest.err >&5
16575   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16576   (exit $ac_status); } &&
16577          { ac_try='test -z "$ac_c_werror_flag"
16578                          || test ! -s conftest.err'
16579   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16580   (eval $ac_try) 2>&5
16581   ac_status=$?
16582   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16583   (exit $ac_status); }; } &&
16584          { ac_try='test -s conftest$ac_exeext'
16585   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16586   (eval $ac_try) 2>&5
16587   ac_status=$?
16588   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16589   (exit $ac_status); }; }; then
16590   ac_cv_lib_m_log10=yes
16591 else
16592   echo "$as_me: failed program was:" >&5
16593 sed 's/^/| /' conftest.$ac_ext >&5
16594
16595 ac_cv_lib_m_log10=no
16596 fi
16597 rm -f conftest.err conftest.$ac_objext \
16598       conftest$ac_exeext conftest.$ac_ext
16599 LIBS=$ac_check_lib_save_LIBS
16600 fi
16601 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10" >&5
16602 echo "${ECHO_T}$ac_cv_lib_m_log10" >&6
16603 if test $ac_cv_lib_m_log10 = yes; then
16604
16605 cat >>confdefs.h <<\_ACEOF
16606 #define HAVE_LOG10 1
16607 _ACEOF
16608
16609 fi
16610
16611 echo "$as_me:$LINENO: checking for log10l in -lm" >&5
16612 echo $ECHO_N "checking for log10l in -lm... $ECHO_C" >&6
16613 if test "${ac_cv_lib_m_log10l+set}" = set; then
16614   echo $ECHO_N "(cached) $ECHO_C" >&6
16615 else
16616   ac_check_lib_save_LIBS=$LIBS
16617 LIBS="-lm  $LIBS"
16618 if test x$gcc_no_link = xyes; then
16619   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16620 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16621    { (exit 1); exit 1; }; }
16622 fi
16623 cat >conftest.$ac_ext <<_ACEOF
16624 /* confdefs.h.  */
16625 _ACEOF
16626 cat confdefs.h >>conftest.$ac_ext
16627 cat >>conftest.$ac_ext <<_ACEOF
16628 /* end confdefs.h.  */
16629
16630 /* Override any gcc2 internal prototype to avoid an error.  */
16631 #ifdef __cplusplus
16632 extern "C"
16633 #endif
16634 /* We use char because int might match the return type of a gcc2
16635    builtin and then its argument prototype would still apply.  */
16636 char log10l ();
16637 int
16638 main ()
16639 {
16640 log10l ();
16641   ;
16642   return 0;
16643 }
16644 _ACEOF
16645 rm -f conftest.$ac_objext conftest$ac_exeext
16646 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16647   (eval $ac_link) 2>conftest.er1
16648   ac_status=$?
16649   grep -v '^ *+' conftest.er1 >conftest.err
16650   rm -f conftest.er1
16651   cat conftest.err >&5
16652   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16653   (exit $ac_status); } &&
16654          { ac_try='test -z "$ac_c_werror_flag"
16655                          || test ! -s conftest.err'
16656   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16657   (eval $ac_try) 2>&5
16658   ac_status=$?
16659   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16660   (exit $ac_status); }; } &&
16661          { ac_try='test -s conftest$ac_exeext'
16662   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16663   (eval $ac_try) 2>&5
16664   ac_status=$?
16665   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16666   (exit $ac_status); }; }; then
16667   ac_cv_lib_m_log10l=yes
16668 else
16669   echo "$as_me: failed program was:" >&5
16670 sed 's/^/| /' conftest.$ac_ext >&5
16671
16672 ac_cv_lib_m_log10l=no
16673 fi
16674 rm -f conftest.err conftest.$ac_objext \
16675       conftest$ac_exeext conftest.$ac_ext
16676 LIBS=$ac_check_lib_save_LIBS
16677 fi
16678 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10l" >&5
16679 echo "${ECHO_T}$ac_cv_lib_m_log10l" >&6
16680 if test $ac_cv_lib_m_log10l = yes; then
16681
16682 cat >>confdefs.h <<\_ACEOF
16683 #define HAVE_LOG10L 1
16684 _ACEOF
16685
16686 fi
16687
16688 echo "$as_me:$LINENO: checking for clog10f in -lm" >&5
16689 echo $ECHO_N "checking for clog10f in -lm... $ECHO_C" >&6
16690 if test "${ac_cv_lib_m_clog10f+set}" = set; then
16691   echo $ECHO_N "(cached) $ECHO_C" >&6
16692 else
16693   ac_check_lib_save_LIBS=$LIBS
16694 LIBS="-lm  $LIBS"
16695 if test x$gcc_no_link = xyes; then
16696   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16697 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16698    { (exit 1); exit 1; }; }
16699 fi
16700 cat >conftest.$ac_ext <<_ACEOF
16701 /* confdefs.h.  */
16702 _ACEOF
16703 cat confdefs.h >>conftest.$ac_ext
16704 cat >>conftest.$ac_ext <<_ACEOF
16705 /* end confdefs.h.  */
16706
16707 /* Override any gcc2 internal prototype to avoid an error.  */
16708 #ifdef __cplusplus
16709 extern "C"
16710 #endif
16711 /* We use char because int might match the return type of a gcc2
16712    builtin and then its argument prototype would still apply.  */
16713 char clog10f ();
16714 int
16715 main ()
16716 {
16717 clog10f ();
16718   ;
16719   return 0;
16720 }
16721 _ACEOF
16722 rm -f conftest.$ac_objext conftest$ac_exeext
16723 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16724   (eval $ac_link) 2>conftest.er1
16725   ac_status=$?
16726   grep -v '^ *+' conftest.er1 >conftest.err
16727   rm -f conftest.er1
16728   cat conftest.err >&5
16729   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16730   (exit $ac_status); } &&
16731          { ac_try='test -z "$ac_c_werror_flag"
16732                          || test ! -s conftest.err'
16733   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16734   (eval $ac_try) 2>&5
16735   ac_status=$?
16736   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16737   (exit $ac_status); }; } &&
16738          { ac_try='test -s conftest$ac_exeext'
16739   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16740   (eval $ac_try) 2>&5
16741   ac_status=$?
16742   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16743   (exit $ac_status); }; }; then
16744   ac_cv_lib_m_clog10f=yes
16745 else
16746   echo "$as_me: failed program was:" >&5
16747 sed 's/^/| /' conftest.$ac_ext >&5
16748
16749 ac_cv_lib_m_clog10f=no
16750 fi
16751 rm -f conftest.err conftest.$ac_objext \
16752       conftest$ac_exeext conftest.$ac_ext
16753 LIBS=$ac_check_lib_save_LIBS
16754 fi
16755 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10f" >&5
16756 echo "${ECHO_T}$ac_cv_lib_m_clog10f" >&6
16757 if test $ac_cv_lib_m_clog10f = yes; then
16758
16759 cat >>confdefs.h <<\_ACEOF
16760 #define HAVE_CLOG10F 1
16761 _ACEOF
16762
16763 fi
16764
16765 echo "$as_me:$LINENO: checking for clog10 in -lm" >&5
16766 echo $ECHO_N "checking for clog10 in -lm... $ECHO_C" >&6
16767 if test "${ac_cv_lib_m_clog10+set}" = set; then
16768   echo $ECHO_N "(cached) $ECHO_C" >&6
16769 else
16770   ac_check_lib_save_LIBS=$LIBS
16771 LIBS="-lm  $LIBS"
16772 if test x$gcc_no_link = xyes; then
16773   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16774 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16775    { (exit 1); exit 1; }; }
16776 fi
16777 cat >conftest.$ac_ext <<_ACEOF
16778 /* confdefs.h.  */
16779 _ACEOF
16780 cat confdefs.h >>conftest.$ac_ext
16781 cat >>conftest.$ac_ext <<_ACEOF
16782 /* end confdefs.h.  */
16783
16784 /* Override any gcc2 internal prototype to avoid an error.  */
16785 #ifdef __cplusplus
16786 extern "C"
16787 #endif
16788 /* We use char because int might match the return type of a gcc2
16789    builtin and then its argument prototype would still apply.  */
16790 char clog10 ();
16791 int
16792 main ()
16793 {
16794 clog10 ();
16795   ;
16796   return 0;
16797 }
16798 _ACEOF
16799 rm -f conftest.$ac_objext conftest$ac_exeext
16800 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16801   (eval $ac_link) 2>conftest.er1
16802   ac_status=$?
16803   grep -v '^ *+' conftest.er1 >conftest.err
16804   rm -f conftest.er1
16805   cat conftest.err >&5
16806   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16807   (exit $ac_status); } &&
16808          { ac_try='test -z "$ac_c_werror_flag"
16809                          || test ! -s conftest.err'
16810   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16811   (eval $ac_try) 2>&5
16812   ac_status=$?
16813   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16814   (exit $ac_status); }; } &&
16815          { ac_try='test -s conftest$ac_exeext'
16816   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16817   (eval $ac_try) 2>&5
16818   ac_status=$?
16819   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16820   (exit $ac_status); }; }; then
16821   ac_cv_lib_m_clog10=yes
16822 else
16823   echo "$as_me: failed program was:" >&5
16824 sed 's/^/| /' conftest.$ac_ext >&5
16825
16826 ac_cv_lib_m_clog10=no
16827 fi
16828 rm -f conftest.err conftest.$ac_objext \
16829       conftest$ac_exeext conftest.$ac_ext
16830 LIBS=$ac_check_lib_save_LIBS
16831 fi
16832 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10" >&5
16833 echo "${ECHO_T}$ac_cv_lib_m_clog10" >&6
16834 if test $ac_cv_lib_m_clog10 = yes; then
16835
16836 cat >>confdefs.h <<\_ACEOF
16837 #define HAVE_CLOG10 1
16838 _ACEOF
16839
16840 fi
16841
16842 echo "$as_me:$LINENO: checking for clog10l in -lm" >&5
16843 echo $ECHO_N "checking for clog10l in -lm... $ECHO_C" >&6
16844 if test "${ac_cv_lib_m_clog10l+set}" = set; then
16845   echo $ECHO_N "(cached) $ECHO_C" >&6
16846 else
16847   ac_check_lib_save_LIBS=$LIBS
16848 LIBS="-lm  $LIBS"
16849 if test x$gcc_no_link = xyes; then
16850   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16851 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16852    { (exit 1); exit 1; }; }
16853 fi
16854 cat >conftest.$ac_ext <<_ACEOF
16855 /* confdefs.h.  */
16856 _ACEOF
16857 cat confdefs.h >>conftest.$ac_ext
16858 cat >>conftest.$ac_ext <<_ACEOF
16859 /* end confdefs.h.  */
16860
16861 /* Override any gcc2 internal prototype to avoid an error.  */
16862 #ifdef __cplusplus
16863 extern "C"
16864 #endif
16865 /* We use char because int might match the return type of a gcc2
16866    builtin and then its argument prototype would still apply.  */
16867 char clog10l ();
16868 int
16869 main ()
16870 {
16871 clog10l ();
16872   ;
16873   return 0;
16874 }
16875 _ACEOF
16876 rm -f conftest.$ac_objext conftest$ac_exeext
16877 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16878   (eval $ac_link) 2>conftest.er1
16879   ac_status=$?
16880   grep -v '^ *+' conftest.er1 >conftest.err
16881   rm -f conftest.er1
16882   cat conftest.err >&5
16883   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16884   (exit $ac_status); } &&
16885          { ac_try='test -z "$ac_c_werror_flag"
16886                          || test ! -s conftest.err'
16887   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16888   (eval $ac_try) 2>&5
16889   ac_status=$?
16890   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16891   (exit $ac_status); }; } &&
16892          { ac_try='test -s conftest$ac_exeext'
16893   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16894   (eval $ac_try) 2>&5
16895   ac_status=$?
16896   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16897   (exit $ac_status); }; }; then
16898   ac_cv_lib_m_clog10l=yes
16899 else
16900   echo "$as_me: failed program was:" >&5
16901 sed 's/^/| /' conftest.$ac_ext >&5
16902
16903 ac_cv_lib_m_clog10l=no
16904 fi
16905 rm -f conftest.err conftest.$ac_objext \
16906       conftest$ac_exeext conftest.$ac_ext
16907 LIBS=$ac_check_lib_save_LIBS
16908 fi
16909 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10l" >&5
16910 echo "${ECHO_T}$ac_cv_lib_m_clog10l" >&6
16911 if test $ac_cv_lib_m_clog10l = yes; then
16912
16913 cat >>confdefs.h <<\_ACEOF
16914 #define HAVE_CLOG10L 1
16915 _ACEOF
16916
16917 fi
16918
16919 echo "$as_me:$LINENO: checking for nextafterf in -lm" >&5
16920 echo $ECHO_N "checking for nextafterf in -lm... $ECHO_C" >&6
16921 if test "${ac_cv_lib_m_nextafterf+set}" = set; then
16922   echo $ECHO_N "(cached) $ECHO_C" >&6
16923 else
16924   ac_check_lib_save_LIBS=$LIBS
16925 LIBS="-lm  $LIBS"
16926 if test x$gcc_no_link = xyes; then
16927   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16928 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16929    { (exit 1); exit 1; }; }
16930 fi
16931 cat >conftest.$ac_ext <<_ACEOF
16932 /* confdefs.h.  */
16933 _ACEOF
16934 cat confdefs.h >>conftest.$ac_ext
16935 cat >>conftest.$ac_ext <<_ACEOF
16936 /* end confdefs.h.  */
16937
16938 /* Override any gcc2 internal prototype to avoid an error.  */
16939 #ifdef __cplusplus
16940 extern "C"
16941 #endif
16942 /* We use char because int might match the return type of a gcc2
16943    builtin and then its argument prototype would still apply.  */
16944 char nextafterf ();
16945 int
16946 main ()
16947 {
16948 nextafterf ();
16949   ;
16950   return 0;
16951 }
16952 _ACEOF
16953 rm -f conftest.$ac_objext conftest$ac_exeext
16954 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16955   (eval $ac_link) 2>conftest.er1
16956   ac_status=$?
16957   grep -v '^ *+' conftest.er1 >conftest.err
16958   rm -f conftest.er1
16959   cat conftest.err >&5
16960   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16961   (exit $ac_status); } &&
16962          { ac_try='test -z "$ac_c_werror_flag"
16963                          || test ! -s conftest.err'
16964   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16965   (eval $ac_try) 2>&5
16966   ac_status=$?
16967   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16968   (exit $ac_status); }; } &&
16969          { ac_try='test -s conftest$ac_exeext'
16970   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16971   (eval $ac_try) 2>&5
16972   ac_status=$?
16973   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16974   (exit $ac_status); }; }; then
16975   ac_cv_lib_m_nextafterf=yes
16976 else
16977   echo "$as_me: failed program was:" >&5
16978 sed 's/^/| /' conftest.$ac_ext >&5
16979
16980 ac_cv_lib_m_nextafterf=no
16981 fi
16982 rm -f conftest.err conftest.$ac_objext \
16983       conftest$ac_exeext conftest.$ac_ext
16984 LIBS=$ac_check_lib_save_LIBS
16985 fi
16986 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafterf" >&5
16987 echo "${ECHO_T}$ac_cv_lib_m_nextafterf" >&6
16988 if test $ac_cv_lib_m_nextafterf = yes; then
16989
16990 cat >>confdefs.h <<\_ACEOF
16991 #define HAVE_NEXTAFTERF 1
16992 _ACEOF
16993
16994 fi
16995
16996 echo "$as_me:$LINENO: checking for nextafter in -lm" >&5
16997 echo $ECHO_N "checking for nextafter in -lm... $ECHO_C" >&6
16998 if test "${ac_cv_lib_m_nextafter+set}" = set; then
16999   echo $ECHO_N "(cached) $ECHO_C" >&6
17000 else
17001   ac_check_lib_save_LIBS=$LIBS
17002 LIBS="-lm  $LIBS"
17003 if test x$gcc_no_link = xyes; then
17004   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17005 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17006    { (exit 1); exit 1; }; }
17007 fi
17008 cat >conftest.$ac_ext <<_ACEOF
17009 /* confdefs.h.  */
17010 _ACEOF
17011 cat confdefs.h >>conftest.$ac_ext
17012 cat >>conftest.$ac_ext <<_ACEOF
17013 /* end confdefs.h.  */
17014
17015 /* Override any gcc2 internal prototype to avoid an error.  */
17016 #ifdef __cplusplus
17017 extern "C"
17018 #endif
17019 /* We use char because int might match the return type of a gcc2
17020    builtin and then its argument prototype would still apply.  */
17021 char nextafter ();
17022 int
17023 main ()
17024 {
17025 nextafter ();
17026   ;
17027   return 0;
17028 }
17029 _ACEOF
17030 rm -f conftest.$ac_objext conftest$ac_exeext
17031 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17032   (eval $ac_link) 2>conftest.er1
17033   ac_status=$?
17034   grep -v '^ *+' conftest.er1 >conftest.err
17035   rm -f conftest.er1
17036   cat conftest.err >&5
17037   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17038   (exit $ac_status); } &&
17039          { ac_try='test -z "$ac_c_werror_flag"
17040                          || test ! -s conftest.err'
17041   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17042   (eval $ac_try) 2>&5
17043   ac_status=$?
17044   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17045   (exit $ac_status); }; } &&
17046          { ac_try='test -s conftest$ac_exeext'
17047   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17048   (eval $ac_try) 2>&5
17049   ac_status=$?
17050   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17051   (exit $ac_status); }; }; then
17052   ac_cv_lib_m_nextafter=yes
17053 else
17054   echo "$as_me: failed program was:" >&5
17055 sed 's/^/| /' conftest.$ac_ext >&5
17056
17057 ac_cv_lib_m_nextafter=no
17058 fi
17059 rm -f conftest.err conftest.$ac_objext \
17060       conftest$ac_exeext conftest.$ac_ext
17061 LIBS=$ac_check_lib_save_LIBS
17062 fi
17063 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafter" >&5
17064 echo "${ECHO_T}$ac_cv_lib_m_nextafter" >&6
17065 if test $ac_cv_lib_m_nextafter = yes; then
17066
17067 cat >>confdefs.h <<\_ACEOF
17068 #define HAVE_NEXTAFTER 1
17069 _ACEOF
17070
17071 fi
17072
17073 echo "$as_me:$LINENO: checking for nextafterl in -lm" >&5
17074 echo $ECHO_N "checking for nextafterl in -lm... $ECHO_C" >&6
17075 if test "${ac_cv_lib_m_nextafterl+set}" = set; then
17076   echo $ECHO_N "(cached) $ECHO_C" >&6
17077 else
17078   ac_check_lib_save_LIBS=$LIBS
17079 LIBS="-lm  $LIBS"
17080 if test x$gcc_no_link = xyes; then
17081   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17082 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17083    { (exit 1); exit 1; }; }
17084 fi
17085 cat >conftest.$ac_ext <<_ACEOF
17086 /* confdefs.h.  */
17087 _ACEOF
17088 cat confdefs.h >>conftest.$ac_ext
17089 cat >>conftest.$ac_ext <<_ACEOF
17090 /* end confdefs.h.  */
17091
17092 /* Override any gcc2 internal prototype to avoid an error.  */
17093 #ifdef __cplusplus
17094 extern "C"
17095 #endif
17096 /* We use char because int might match the return type of a gcc2
17097    builtin and then its argument prototype would still apply.  */
17098 char nextafterl ();
17099 int
17100 main ()
17101 {
17102 nextafterl ();
17103   ;
17104   return 0;
17105 }
17106 _ACEOF
17107 rm -f conftest.$ac_objext conftest$ac_exeext
17108 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17109   (eval $ac_link) 2>conftest.er1
17110   ac_status=$?
17111   grep -v '^ *+' conftest.er1 >conftest.err
17112   rm -f conftest.er1
17113   cat conftest.err >&5
17114   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17115   (exit $ac_status); } &&
17116          { ac_try='test -z "$ac_c_werror_flag"
17117                          || test ! -s conftest.err'
17118   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17119   (eval $ac_try) 2>&5
17120   ac_status=$?
17121   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17122   (exit $ac_status); }; } &&
17123          { ac_try='test -s conftest$ac_exeext'
17124   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17125   (eval $ac_try) 2>&5
17126   ac_status=$?
17127   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17128   (exit $ac_status); }; }; then
17129   ac_cv_lib_m_nextafterl=yes
17130 else
17131   echo "$as_me: failed program was:" >&5
17132 sed 's/^/| /' conftest.$ac_ext >&5
17133
17134 ac_cv_lib_m_nextafterl=no
17135 fi
17136 rm -f conftest.err conftest.$ac_objext \
17137       conftest$ac_exeext conftest.$ac_ext
17138 LIBS=$ac_check_lib_save_LIBS
17139 fi
17140 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafterl" >&5
17141 echo "${ECHO_T}$ac_cv_lib_m_nextafterl" >&6
17142 if test $ac_cv_lib_m_nextafterl = yes; then
17143
17144 cat >>confdefs.h <<\_ACEOF
17145 #define HAVE_NEXTAFTERL 1
17146 _ACEOF
17147
17148 fi
17149
17150 echo "$as_me:$LINENO: checking for powf in -lm" >&5
17151 echo $ECHO_N "checking for powf in -lm... $ECHO_C" >&6
17152 if test "${ac_cv_lib_m_powf+set}" = set; then
17153   echo $ECHO_N "(cached) $ECHO_C" >&6
17154 else
17155   ac_check_lib_save_LIBS=$LIBS
17156 LIBS="-lm  $LIBS"
17157 if test x$gcc_no_link = xyes; then
17158   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17159 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17160    { (exit 1); exit 1; }; }
17161 fi
17162 cat >conftest.$ac_ext <<_ACEOF
17163 /* confdefs.h.  */
17164 _ACEOF
17165 cat confdefs.h >>conftest.$ac_ext
17166 cat >>conftest.$ac_ext <<_ACEOF
17167 /* end confdefs.h.  */
17168
17169 /* Override any gcc2 internal prototype to avoid an error.  */
17170 #ifdef __cplusplus
17171 extern "C"
17172 #endif
17173 /* We use char because int might match the return type of a gcc2
17174    builtin and then its argument prototype would still apply.  */
17175 char powf ();
17176 int
17177 main ()
17178 {
17179 powf ();
17180   ;
17181   return 0;
17182 }
17183 _ACEOF
17184 rm -f conftest.$ac_objext conftest$ac_exeext
17185 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17186   (eval $ac_link) 2>conftest.er1
17187   ac_status=$?
17188   grep -v '^ *+' conftest.er1 >conftest.err
17189   rm -f conftest.er1
17190   cat conftest.err >&5
17191   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17192   (exit $ac_status); } &&
17193          { ac_try='test -z "$ac_c_werror_flag"
17194                          || test ! -s conftest.err'
17195   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17196   (eval $ac_try) 2>&5
17197   ac_status=$?
17198   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17199   (exit $ac_status); }; } &&
17200          { ac_try='test -s conftest$ac_exeext'
17201   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17202   (eval $ac_try) 2>&5
17203   ac_status=$?
17204   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17205   (exit $ac_status); }; }; then
17206   ac_cv_lib_m_powf=yes
17207 else
17208   echo "$as_me: failed program was:" >&5
17209 sed 's/^/| /' conftest.$ac_ext >&5
17210
17211 ac_cv_lib_m_powf=no
17212 fi
17213 rm -f conftest.err conftest.$ac_objext \
17214       conftest$ac_exeext conftest.$ac_ext
17215 LIBS=$ac_check_lib_save_LIBS
17216 fi
17217 echo "$as_me:$LINENO: result: $ac_cv_lib_m_powf" >&5
17218 echo "${ECHO_T}$ac_cv_lib_m_powf" >&6
17219 if test $ac_cv_lib_m_powf = yes; then
17220
17221 cat >>confdefs.h <<\_ACEOF
17222 #define HAVE_POWF 1
17223 _ACEOF
17224
17225 fi
17226
17227 echo "$as_me:$LINENO: checking for pow in -lm" >&5
17228 echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
17229 if test "${ac_cv_lib_m_pow+set}" = set; then
17230   echo $ECHO_N "(cached) $ECHO_C" >&6
17231 else
17232   ac_check_lib_save_LIBS=$LIBS
17233 LIBS="-lm  $LIBS"
17234 if test x$gcc_no_link = xyes; then
17235   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17236 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17237    { (exit 1); exit 1; }; }
17238 fi
17239 cat >conftest.$ac_ext <<_ACEOF
17240 /* confdefs.h.  */
17241 _ACEOF
17242 cat confdefs.h >>conftest.$ac_ext
17243 cat >>conftest.$ac_ext <<_ACEOF
17244 /* end confdefs.h.  */
17245
17246 /* Override any gcc2 internal prototype to avoid an error.  */
17247 #ifdef __cplusplus
17248 extern "C"
17249 #endif
17250 /* We use char because int might match the return type of a gcc2
17251    builtin and then its argument prototype would still apply.  */
17252 char pow ();
17253 int
17254 main ()
17255 {
17256 pow ();
17257   ;
17258   return 0;
17259 }
17260 _ACEOF
17261 rm -f conftest.$ac_objext conftest$ac_exeext
17262 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17263   (eval $ac_link) 2>conftest.er1
17264   ac_status=$?
17265   grep -v '^ *+' conftest.er1 >conftest.err
17266   rm -f conftest.er1
17267   cat conftest.err >&5
17268   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17269   (exit $ac_status); } &&
17270          { ac_try='test -z "$ac_c_werror_flag"
17271                          || test ! -s conftest.err'
17272   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17273   (eval $ac_try) 2>&5
17274   ac_status=$?
17275   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17276   (exit $ac_status); }; } &&
17277          { ac_try='test -s conftest$ac_exeext'
17278   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17279   (eval $ac_try) 2>&5
17280   ac_status=$?
17281   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17282   (exit $ac_status); }; }; then
17283   ac_cv_lib_m_pow=yes
17284 else
17285   echo "$as_me: failed program was:" >&5
17286 sed 's/^/| /' conftest.$ac_ext >&5
17287
17288 ac_cv_lib_m_pow=no
17289 fi
17290 rm -f conftest.err conftest.$ac_objext \
17291       conftest$ac_exeext conftest.$ac_ext
17292 LIBS=$ac_check_lib_save_LIBS
17293 fi
17294 echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
17295 echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
17296 if test $ac_cv_lib_m_pow = yes; then
17297
17298 cat >>confdefs.h <<\_ACEOF
17299 #define HAVE_POW 1
17300 _ACEOF
17301
17302 fi
17303
17304 echo "$as_me:$LINENO: checking for powl in -lm" >&5
17305 echo $ECHO_N "checking for powl in -lm... $ECHO_C" >&6
17306 if test "${ac_cv_lib_m_powl+set}" = set; then
17307   echo $ECHO_N "(cached) $ECHO_C" >&6
17308 else
17309   ac_check_lib_save_LIBS=$LIBS
17310 LIBS="-lm  $LIBS"
17311 if test x$gcc_no_link = xyes; then
17312   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17313 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17314    { (exit 1); exit 1; }; }
17315 fi
17316 cat >conftest.$ac_ext <<_ACEOF
17317 /* confdefs.h.  */
17318 _ACEOF
17319 cat confdefs.h >>conftest.$ac_ext
17320 cat >>conftest.$ac_ext <<_ACEOF
17321 /* end confdefs.h.  */
17322
17323 /* Override any gcc2 internal prototype to avoid an error.  */
17324 #ifdef __cplusplus
17325 extern "C"
17326 #endif
17327 /* We use char because int might match the return type of a gcc2
17328    builtin and then its argument prototype would still apply.  */
17329 char powl ();
17330 int
17331 main ()
17332 {
17333 powl ();
17334   ;
17335   return 0;
17336 }
17337 _ACEOF
17338 rm -f conftest.$ac_objext conftest$ac_exeext
17339 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17340   (eval $ac_link) 2>conftest.er1
17341   ac_status=$?
17342   grep -v '^ *+' conftest.er1 >conftest.err
17343   rm -f conftest.er1
17344   cat conftest.err >&5
17345   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17346   (exit $ac_status); } &&
17347          { ac_try='test -z "$ac_c_werror_flag"
17348                          || test ! -s conftest.err'
17349   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17350   (eval $ac_try) 2>&5
17351   ac_status=$?
17352   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17353   (exit $ac_status); }; } &&
17354          { ac_try='test -s conftest$ac_exeext'
17355   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17356   (eval $ac_try) 2>&5
17357   ac_status=$?
17358   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17359   (exit $ac_status); }; }; then
17360   ac_cv_lib_m_powl=yes
17361 else
17362   echo "$as_me: failed program was:" >&5
17363 sed 's/^/| /' conftest.$ac_ext >&5
17364
17365 ac_cv_lib_m_powl=no
17366 fi
17367 rm -f conftest.err conftest.$ac_objext \
17368       conftest$ac_exeext conftest.$ac_ext
17369 LIBS=$ac_check_lib_save_LIBS
17370 fi
17371 echo "$as_me:$LINENO: result: $ac_cv_lib_m_powl" >&5
17372 echo "${ECHO_T}$ac_cv_lib_m_powl" >&6
17373 if test $ac_cv_lib_m_powl = yes; then
17374
17375 cat >>confdefs.h <<\_ACEOF
17376 #define HAVE_POWL 1
17377 _ACEOF
17378
17379 fi
17380
17381 echo "$as_me:$LINENO: checking for cpowf in -lm" >&5
17382 echo $ECHO_N "checking for cpowf in -lm... $ECHO_C" >&6
17383 if test "${ac_cv_lib_m_cpowf+set}" = set; then
17384   echo $ECHO_N "(cached) $ECHO_C" >&6
17385 else
17386   ac_check_lib_save_LIBS=$LIBS
17387 LIBS="-lm  $LIBS"
17388 if test x$gcc_no_link = xyes; then
17389   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17390 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17391    { (exit 1); exit 1; }; }
17392 fi
17393 cat >conftest.$ac_ext <<_ACEOF
17394 /* confdefs.h.  */
17395 _ACEOF
17396 cat confdefs.h >>conftest.$ac_ext
17397 cat >>conftest.$ac_ext <<_ACEOF
17398 /* end confdefs.h.  */
17399
17400 /* Override any gcc2 internal prototype to avoid an error.  */
17401 #ifdef __cplusplus
17402 extern "C"
17403 #endif
17404 /* We use char because int might match the return type of a gcc2
17405    builtin and then its argument prototype would still apply.  */
17406 char cpowf ();
17407 int
17408 main ()
17409 {
17410 cpowf ();
17411   ;
17412   return 0;
17413 }
17414 _ACEOF
17415 rm -f conftest.$ac_objext conftest$ac_exeext
17416 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17417   (eval $ac_link) 2>conftest.er1
17418   ac_status=$?
17419   grep -v '^ *+' conftest.er1 >conftest.err
17420   rm -f conftest.er1
17421   cat conftest.err >&5
17422   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17423   (exit $ac_status); } &&
17424          { ac_try='test -z "$ac_c_werror_flag"
17425                          || test ! -s conftest.err'
17426   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17427   (eval $ac_try) 2>&5
17428   ac_status=$?
17429   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17430   (exit $ac_status); }; } &&
17431          { ac_try='test -s conftest$ac_exeext'
17432   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17433   (eval $ac_try) 2>&5
17434   ac_status=$?
17435   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17436   (exit $ac_status); }; }; then
17437   ac_cv_lib_m_cpowf=yes
17438 else
17439   echo "$as_me: failed program was:" >&5
17440 sed 's/^/| /' conftest.$ac_ext >&5
17441
17442 ac_cv_lib_m_cpowf=no
17443 fi
17444 rm -f conftest.err conftest.$ac_objext \
17445       conftest$ac_exeext conftest.$ac_ext
17446 LIBS=$ac_check_lib_save_LIBS
17447 fi
17448 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpowf" >&5
17449 echo "${ECHO_T}$ac_cv_lib_m_cpowf" >&6
17450 if test $ac_cv_lib_m_cpowf = yes; then
17451
17452 cat >>confdefs.h <<\_ACEOF
17453 #define HAVE_CPOWF 1
17454 _ACEOF
17455
17456 fi
17457
17458 echo "$as_me:$LINENO: checking for cpow in -lm" >&5
17459 echo $ECHO_N "checking for cpow in -lm... $ECHO_C" >&6
17460 if test "${ac_cv_lib_m_cpow+set}" = set; then
17461   echo $ECHO_N "(cached) $ECHO_C" >&6
17462 else
17463   ac_check_lib_save_LIBS=$LIBS
17464 LIBS="-lm  $LIBS"
17465 if test x$gcc_no_link = xyes; then
17466   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17467 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17468    { (exit 1); exit 1; }; }
17469 fi
17470 cat >conftest.$ac_ext <<_ACEOF
17471 /* confdefs.h.  */
17472 _ACEOF
17473 cat confdefs.h >>conftest.$ac_ext
17474 cat >>conftest.$ac_ext <<_ACEOF
17475 /* end confdefs.h.  */
17476
17477 /* Override any gcc2 internal prototype to avoid an error.  */
17478 #ifdef __cplusplus
17479 extern "C"
17480 #endif
17481 /* We use char because int might match the return type of a gcc2
17482    builtin and then its argument prototype would still apply.  */
17483 char cpow ();
17484 int
17485 main ()
17486 {
17487 cpow ();
17488   ;
17489   return 0;
17490 }
17491 _ACEOF
17492 rm -f conftest.$ac_objext conftest$ac_exeext
17493 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17494   (eval $ac_link) 2>conftest.er1
17495   ac_status=$?
17496   grep -v '^ *+' conftest.er1 >conftest.err
17497   rm -f conftest.er1
17498   cat conftest.err >&5
17499   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17500   (exit $ac_status); } &&
17501          { ac_try='test -z "$ac_c_werror_flag"
17502                          || test ! -s conftest.err'
17503   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17504   (eval $ac_try) 2>&5
17505   ac_status=$?
17506   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17507   (exit $ac_status); }; } &&
17508          { ac_try='test -s conftest$ac_exeext'
17509   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17510   (eval $ac_try) 2>&5
17511   ac_status=$?
17512   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17513   (exit $ac_status); }; }; then
17514   ac_cv_lib_m_cpow=yes
17515 else
17516   echo "$as_me: failed program was:" >&5
17517 sed 's/^/| /' conftest.$ac_ext >&5
17518
17519 ac_cv_lib_m_cpow=no
17520 fi
17521 rm -f conftest.err conftest.$ac_objext \
17522       conftest$ac_exeext conftest.$ac_ext
17523 LIBS=$ac_check_lib_save_LIBS
17524 fi
17525 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpow" >&5
17526 echo "${ECHO_T}$ac_cv_lib_m_cpow" >&6
17527 if test $ac_cv_lib_m_cpow = yes; then
17528
17529 cat >>confdefs.h <<\_ACEOF
17530 #define HAVE_CPOW 1
17531 _ACEOF
17532
17533 fi
17534
17535 echo "$as_me:$LINENO: checking for cpowl in -lm" >&5
17536 echo $ECHO_N "checking for cpowl in -lm... $ECHO_C" >&6
17537 if test "${ac_cv_lib_m_cpowl+set}" = set; then
17538   echo $ECHO_N "(cached) $ECHO_C" >&6
17539 else
17540   ac_check_lib_save_LIBS=$LIBS
17541 LIBS="-lm  $LIBS"
17542 if test x$gcc_no_link = xyes; then
17543   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17544 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17545    { (exit 1); exit 1; }; }
17546 fi
17547 cat >conftest.$ac_ext <<_ACEOF
17548 /* confdefs.h.  */
17549 _ACEOF
17550 cat confdefs.h >>conftest.$ac_ext
17551 cat >>conftest.$ac_ext <<_ACEOF
17552 /* end confdefs.h.  */
17553
17554 /* Override any gcc2 internal prototype to avoid an error.  */
17555 #ifdef __cplusplus
17556 extern "C"
17557 #endif
17558 /* We use char because int might match the return type of a gcc2
17559    builtin and then its argument prototype would still apply.  */
17560 char cpowl ();
17561 int
17562 main ()
17563 {
17564 cpowl ();
17565   ;
17566   return 0;
17567 }
17568 _ACEOF
17569 rm -f conftest.$ac_objext conftest$ac_exeext
17570 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17571   (eval $ac_link) 2>conftest.er1
17572   ac_status=$?
17573   grep -v '^ *+' conftest.er1 >conftest.err
17574   rm -f conftest.er1
17575   cat conftest.err >&5
17576   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17577   (exit $ac_status); } &&
17578          { ac_try='test -z "$ac_c_werror_flag"
17579                          || test ! -s conftest.err'
17580   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17581   (eval $ac_try) 2>&5
17582   ac_status=$?
17583   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17584   (exit $ac_status); }; } &&
17585          { ac_try='test -s conftest$ac_exeext'
17586   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17587   (eval $ac_try) 2>&5
17588   ac_status=$?
17589   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17590   (exit $ac_status); }; }; then
17591   ac_cv_lib_m_cpowl=yes
17592 else
17593   echo "$as_me: failed program was:" >&5
17594 sed 's/^/| /' conftest.$ac_ext >&5
17595
17596 ac_cv_lib_m_cpowl=no
17597 fi
17598 rm -f conftest.err conftest.$ac_objext \
17599       conftest$ac_exeext conftest.$ac_ext
17600 LIBS=$ac_check_lib_save_LIBS
17601 fi
17602 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpowl" >&5
17603 echo "${ECHO_T}$ac_cv_lib_m_cpowl" >&6
17604 if test $ac_cv_lib_m_cpowl = yes; then
17605
17606 cat >>confdefs.h <<\_ACEOF
17607 #define HAVE_CPOWL 1
17608 _ACEOF
17609
17610 fi
17611
17612 echo "$as_me:$LINENO: checking for roundf in -lm" >&5
17613 echo $ECHO_N "checking for roundf in -lm... $ECHO_C" >&6
17614 if test "${ac_cv_lib_m_roundf+set}" = set; then
17615   echo $ECHO_N "(cached) $ECHO_C" >&6
17616 else
17617   ac_check_lib_save_LIBS=$LIBS
17618 LIBS="-lm  $LIBS"
17619 if test x$gcc_no_link = xyes; then
17620   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17621 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17622    { (exit 1); exit 1; }; }
17623 fi
17624 cat >conftest.$ac_ext <<_ACEOF
17625 /* confdefs.h.  */
17626 _ACEOF
17627 cat confdefs.h >>conftest.$ac_ext
17628 cat >>conftest.$ac_ext <<_ACEOF
17629 /* end confdefs.h.  */
17630
17631 /* Override any gcc2 internal prototype to avoid an error.  */
17632 #ifdef __cplusplus
17633 extern "C"
17634 #endif
17635 /* We use char because int might match the return type of a gcc2
17636    builtin and then its argument prototype would still apply.  */
17637 char roundf ();
17638 int
17639 main ()
17640 {
17641 roundf ();
17642   ;
17643   return 0;
17644 }
17645 _ACEOF
17646 rm -f conftest.$ac_objext conftest$ac_exeext
17647 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17648   (eval $ac_link) 2>conftest.er1
17649   ac_status=$?
17650   grep -v '^ *+' conftest.er1 >conftest.err
17651   rm -f conftest.er1
17652   cat conftest.err >&5
17653   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17654   (exit $ac_status); } &&
17655          { ac_try='test -z "$ac_c_werror_flag"
17656                          || test ! -s conftest.err'
17657   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17658   (eval $ac_try) 2>&5
17659   ac_status=$?
17660   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17661   (exit $ac_status); }; } &&
17662          { ac_try='test -s conftest$ac_exeext'
17663   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17664   (eval $ac_try) 2>&5
17665   ac_status=$?
17666   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17667   (exit $ac_status); }; }; then
17668   ac_cv_lib_m_roundf=yes
17669 else
17670   echo "$as_me: failed program was:" >&5
17671 sed 's/^/| /' conftest.$ac_ext >&5
17672
17673 ac_cv_lib_m_roundf=no
17674 fi
17675 rm -f conftest.err conftest.$ac_objext \
17676       conftest$ac_exeext conftest.$ac_ext
17677 LIBS=$ac_check_lib_save_LIBS
17678 fi
17679 echo "$as_me:$LINENO: result: $ac_cv_lib_m_roundf" >&5
17680 echo "${ECHO_T}$ac_cv_lib_m_roundf" >&6
17681 if test $ac_cv_lib_m_roundf = yes; then
17682
17683 cat >>confdefs.h <<\_ACEOF
17684 #define HAVE_ROUNDF 1
17685 _ACEOF
17686
17687 fi
17688
17689 echo "$as_me:$LINENO: checking for round in -lm" >&5
17690 echo $ECHO_N "checking for round in -lm... $ECHO_C" >&6
17691 if test "${ac_cv_lib_m_round+set}" = set; then
17692   echo $ECHO_N "(cached) $ECHO_C" >&6
17693 else
17694   ac_check_lib_save_LIBS=$LIBS
17695 LIBS="-lm  $LIBS"
17696 if test x$gcc_no_link = xyes; then
17697   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17698 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17699    { (exit 1); exit 1; }; }
17700 fi
17701 cat >conftest.$ac_ext <<_ACEOF
17702 /* confdefs.h.  */
17703 _ACEOF
17704 cat confdefs.h >>conftest.$ac_ext
17705 cat >>conftest.$ac_ext <<_ACEOF
17706 /* end confdefs.h.  */
17707
17708 /* Override any gcc2 internal prototype to avoid an error.  */
17709 #ifdef __cplusplus
17710 extern "C"
17711 #endif
17712 /* We use char because int might match the return type of a gcc2
17713    builtin and then its argument prototype would still apply.  */
17714 char round ();
17715 int
17716 main ()
17717 {
17718 round ();
17719   ;
17720   return 0;
17721 }
17722 _ACEOF
17723 rm -f conftest.$ac_objext conftest$ac_exeext
17724 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17725   (eval $ac_link) 2>conftest.er1
17726   ac_status=$?
17727   grep -v '^ *+' conftest.er1 >conftest.err
17728   rm -f conftest.er1
17729   cat conftest.err >&5
17730   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17731   (exit $ac_status); } &&
17732          { ac_try='test -z "$ac_c_werror_flag"
17733                          || test ! -s conftest.err'
17734   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17735   (eval $ac_try) 2>&5
17736   ac_status=$?
17737   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17738   (exit $ac_status); }; } &&
17739          { ac_try='test -s conftest$ac_exeext'
17740   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17741   (eval $ac_try) 2>&5
17742   ac_status=$?
17743   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17744   (exit $ac_status); }; }; then
17745   ac_cv_lib_m_round=yes
17746 else
17747   echo "$as_me: failed program was:" >&5
17748 sed 's/^/| /' conftest.$ac_ext >&5
17749
17750 ac_cv_lib_m_round=no
17751 fi
17752 rm -f conftest.err conftest.$ac_objext \
17753       conftest$ac_exeext conftest.$ac_ext
17754 LIBS=$ac_check_lib_save_LIBS
17755 fi
17756 echo "$as_me:$LINENO: result: $ac_cv_lib_m_round" >&5
17757 echo "${ECHO_T}$ac_cv_lib_m_round" >&6
17758 if test $ac_cv_lib_m_round = yes; then
17759
17760 cat >>confdefs.h <<\_ACEOF
17761 #define HAVE_ROUND 1
17762 _ACEOF
17763
17764 fi
17765
17766 echo "$as_me:$LINENO: checking for roundl in -lm" >&5
17767 echo $ECHO_N "checking for roundl in -lm... $ECHO_C" >&6
17768 if test "${ac_cv_lib_m_roundl+set}" = set; then
17769   echo $ECHO_N "(cached) $ECHO_C" >&6
17770 else
17771   ac_check_lib_save_LIBS=$LIBS
17772 LIBS="-lm  $LIBS"
17773 if test x$gcc_no_link = xyes; then
17774   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17775 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17776    { (exit 1); exit 1; }; }
17777 fi
17778 cat >conftest.$ac_ext <<_ACEOF
17779 /* confdefs.h.  */
17780 _ACEOF
17781 cat confdefs.h >>conftest.$ac_ext
17782 cat >>conftest.$ac_ext <<_ACEOF
17783 /* end confdefs.h.  */
17784
17785 /* Override any gcc2 internal prototype to avoid an error.  */
17786 #ifdef __cplusplus
17787 extern "C"
17788 #endif
17789 /* We use char because int might match the return type of a gcc2
17790    builtin and then its argument prototype would still apply.  */
17791 char roundl ();
17792 int
17793 main ()
17794 {
17795 roundl ();
17796   ;
17797   return 0;
17798 }
17799 _ACEOF
17800 rm -f conftest.$ac_objext conftest$ac_exeext
17801 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17802   (eval $ac_link) 2>conftest.er1
17803   ac_status=$?
17804   grep -v '^ *+' conftest.er1 >conftest.err
17805   rm -f conftest.er1
17806   cat conftest.err >&5
17807   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17808   (exit $ac_status); } &&
17809          { ac_try='test -z "$ac_c_werror_flag"
17810                          || test ! -s conftest.err'
17811   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17812   (eval $ac_try) 2>&5
17813   ac_status=$?
17814   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17815   (exit $ac_status); }; } &&
17816          { ac_try='test -s conftest$ac_exeext'
17817   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17818   (eval $ac_try) 2>&5
17819   ac_status=$?
17820   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17821   (exit $ac_status); }; }; then
17822   ac_cv_lib_m_roundl=yes
17823 else
17824   echo "$as_me: failed program was:" >&5
17825 sed 's/^/| /' conftest.$ac_ext >&5
17826
17827 ac_cv_lib_m_roundl=no
17828 fi
17829 rm -f conftest.err conftest.$ac_objext \
17830       conftest$ac_exeext conftest.$ac_ext
17831 LIBS=$ac_check_lib_save_LIBS
17832 fi
17833 echo "$as_me:$LINENO: result: $ac_cv_lib_m_roundl" >&5
17834 echo "${ECHO_T}$ac_cv_lib_m_roundl" >&6
17835 if test $ac_cv_lib_m_roundl = yes; then
17836
17837 cat >>confdefs.h <<\_ACEOF
17838 #define HAVE_ROUNDL 1
17839 _ACEOF
17840
17841 fi
17842
17843 echo "$as_me:$LINENO: checking for scalbnf in -lm" >&5
17844 echo $ECHO_N "checking for scalbnf in -lm... $ECHO_C" >&6
17845 if test "${ac_cv_lib_m_scalbnf+set}" = set; then
17846   echo $ECHO_N "(cached) $ECHO_C" >&6
17847 else
17848   ac_check_lib_save_LIBS=$LIBS
17849 LIBS="-lm  $LIBS"
17850 if test x$gcc_no_link = xyes; then
17851   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17852 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17853    { (exit 1); exit 1; }; }
17854 fi
17855 cat >conftest.$ac_ext <<_ACEOF
17856 /* confdefs.h.  */
17857 _ACEOF
17858 cat confdefs.h >>conftest.$ac_ext
17859 cat >>conftest.$ac_ext <<_ACEOF
17860 /* end confdefs.h.  */
17861
17862 /* Override any gcc2 internal prototype to avoid an error.  */
17863 #ifdef __cplusplus
17864 extern "C"
17865 #endif
17866 /* We use char because int might match the return type of a gcc2
17867    builtin and then its argument prototype would still apply.  */
17868 char scalbnf ();
17869 int
17870 main ()
17871 {
17872 scalbnf ();
17873   ;
17874   return 0;
17875 }
17876 _ACEOF
17877 rm -f conftest.$ac_objext conftest$ac_exeext
17878 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17879   (eval $ac_link) 2>conftest.er1
17880   ac_status=$?
17881   grep -v '^ *+' conftest.er1 >conftest.err
17882   rm -f conftest.er1
17883   cat conftest.err >&5
17884   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17885   (exit $ac_status); } &&
17886          { ac_try='test -z "$ac_c_werror_flag"
17887                          || test ! -s conftest.err'
17888   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17889   (eval $ac_try) 2>&5
17890   ac_status=$?
17891   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17892   (exit $ac_status); }; } &&
17893          { ac_try='test -s conftest$ac_exeext'
17894   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17895   (eval $ac_try) 2>&5
17896   ac_status=$?
17897   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17898   (exit $ac_status); }; }; then
17899   ac_cv_lib_m_scalbnf=yes
17900 else
17901   echo "$as_me: failed program was:" >&5
17902 sed 's/^/| /' conftest.$ac_ext >&5
17903
17904 ac_cv_lib_m_scalbnf=no
17905 fi
17906 rm -f conftest.err conftest.$ac_objext \
17907       conftest$ac_exeext conftest.$ac_ext
17908 LIBS=$ac_check_lib_save_LIBS
17909 fi
17910 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbnf" >&5
17911 echo "${ECHO_T}$ac_cv_lib_m_scalbnf" >&6
17912 if test $ac_cv_lib_m_scalbnf = yes; then
17913
17914 cat >>confdefs.h <<\_ACEOF
17915 #define HAVE_SCALBNF 1
17916 _ACEOF
17917
17918 fi
17919
17920 echo "$as_me:$LINENO: checking for scalbn in -lm" >&5
17921 echo $ECHO_N "checking for scalbn in -lm... $ECHO_C" >&6
17922 if test "${ac_cv_lib_m_scalbn+set}" = set; then
17923   echo $ECHO_N "(cached) $ECHO_C" >&6
17924 else
17925   ac_check_lib_save_LIBS=$LIBS
17926 LIBS="-lm  $LIBS"
17927 if test x$gcc_no_link = xyes; then
17928   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17929 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17930    { (exit 1); exit 1; }; }
17931 fi
17932 cat >conftest.$ac_ext <<_ACEOF
17933 /* confdefs.h.  */
17934 _ACEOF
17935 cat confdefs.h >>conftest.$ac_ext
17936 cat >>conftest.$ac_ext <<_ACEOF
17937 /* end confdefs.h.  */
17938
17939 /* Override any gcc2 internal prototype to avoid an error.  */
17940 #ifdef __cplusplus
17941 extern "C"
17942 #endif
17943 /* We use char because int might match the return type of a gcc2
17944    builtin and then its argument prototype would still apply.  */
17945 char scalbn ();
17946 int
17947 main ()
17948 {
17949 scalbn ();
17950   ;
17951   return 0;
17952 }
17953 _ACEOF
17954 rm -f conftest.$ac_objext conftest$ac_exeext
17955 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17956   (eval $ac_link) 2>conftest.er1
17957   ac_status=$?
17958   grep -v '^ *+' conftest.er1 >conftest.err
17959   rm -f conftest.er1
17960   cat conftest.err >&5
17961   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17962   (exit $ac_status); } &&
17963          { ac_try='test -z "$ac_c_werror_flag"
17964                          || test ! -s conftest.err'
17965   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17966   (eval $ac_try) 2>&5
17967   ac_status=$?
17968   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17969   (exit $ac_status); }; } &&
17970          { ac_try='test -s conftest$ac_exeext'
17971   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17972   (eval $ac_try) 2>&5
17973   ac_status=$?
17974   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17975   (exit $ac_status); }; }; then
17976   ac_cv_lib_m_scalbn=yes
17977 else
17978   echo "$as_me: failed program was:" >&5
17979 sed 's/^/| /' conftest.$ac_ext >&5
17980
17981 ac_cv_lib_m_scalbn=no
17982 fi
17983 rm -f conftest.err conftest.$ac_objext \
17984       conftest$ac_exeext conftest.$ac_ext
17985 LIBS=$ac_check_lib_save_LIBS
17986 fi
17987 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbn" >&5
17988 echo "${ECHO_T}$ac_cv_lib_m_scalbn" >&6
17989 if test $ac_cv_lib_m_scalbn = yes; then
17990
17991 cat >>confdefs.h <<\_ACEOF
17992 #define HAVE_SCALBN 1
17993 _ACEOF
17994
17995 fi
17996
17997 echo "$as_me:$LINENO: checking for scalbnl in -lm" >&5
17998 echo $ECHO_N "checking for scalbnl in -lm... $ECHO_C" >&6
17999 if test "${ac_cv_lib_m_scalbnl+set}" = set; then
18000   echo $ECHO_N "(cached) $ECHO_C" >&6
18001 else
18002   ac_check_lib_save_LIBS=$LIBS
18003 LIBS="-lm  $LIBS"
18004 if test x$gcc_no_link = xyes; then
18005   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18006 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18007    { (exit 1); exit 1; }; }
18008 fi
18009 cat >conftest.$ac_ext <<_ACEOF
18010 /* confdefs.h.  */
18011 _ACEOF
18012 cat confdefs.h >>conftest.$ac_ext
18013 cat >>conftest.$ac_ext <<_ACEOF
18014 /* end confdefs.h.  */
18015
18016 /* Override any gcc2 internal prototype to avoid an error.  */
18017 #ifdef __cplusplus
18018 extern "C"
18019 #endif
18020 /* We use char because int might match the return type of a gcc2
18021    builtin and then its argument prototype would still apply.  */
18022 char scalbnl ();
18023 int
18024 main ()
18025 {
18026 scalbnl ();
18027   ;
18028   return 0;
18029 }
18030 _ACEOF
18031 rm -f conftest.$ac_objext conftest$ac_exeext
18032 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18033   (eval $ac_link) 2>conftest.er1
18034   ac_status=$?
18035   grep -v '^ *+' conftest.er1 >conftest.err
18036   rm -f conftest.er1
18037   cat conftest.err >&5
18038   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18039   (exit $ac_status); } &&
18040          { ac_try='test -z "$ac_c_werror_flag"
18041                          || test ! -s conftest.err'
18042   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18043   (eval $ac_try) 2>&5
18044   ac_status=$?
18045   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18046   (exit $ac_status); }; } &&
18047          { ac_try='test -s conftest$ac_exeext'
18048   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18049   (eval $ac_try) 2>&5
18050   ac_status=$?
18051   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18052   (exit $ac_status); }; }; then
18053   ac_cv_lib_m_scalbnl=yes
18054 else
18055   echo "$as_me: failed program was:" >&5
18056 sed 's/^/| /' conftest.$ac_ext >&5
18057
18058 ac_cv_lib_m_scalbnl=no
18059 fi
18060 rm -f conftest.err conftest.$ac_objext \
18061       conftest$ac_exeext conftest.$ac_ext
18062 LIBS=$ac_check_lib_save_LIBS
18063 fi
18064 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbnl" >&5
18065 echo "${ECHO_T}$ac_cv_lib_m_scalbnl" >&6
18066 if test $ac_cv_lib_m_scalbnl = yes; then
18067
18068 cat >>confdefs.h <<\_ACEOF
18069 #define HAVE_SCALBNL 1
18070 _ACEOF
18071
18072 fi
18073
18074 echo "$as_me:$LINENO: checking for sinf in -lm" >&5
18075 echo $ECHO_N "checking for sinf in -lm... $ECHO_C" >&6
18076 if test "${ac_cv_lib_m_sinf+set}" = set; then
18077   echo $ECHO_N "(cached) $ECHO_C" >&6
18078 else
18079   ac_check_lib_save_LIBS=$LIBS
18080 LIBS="-lm  $LIBS"
18081 if test x$gcc_no_link = xyes; then
18082   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18083 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18084    { (exit 1); exit 1; }; }
18085 fi
18086 cat >conftest.$ac_ext <<_ACEOF
18087 /* confdefs.h.  */
18088 _ACEOF
18089 cat confdefs.h >>conftest.$ac_ext
18090 cat >>conftest.$ac_ext <<_ACEOF
18091 /* end confdefs.h.  */
18092
18093 /* Override any gcc2 internal prototype to avoid an error.  */
18094 #ifdef __cplusplus
18095 extern "C"
18096 #endif
18097 /* We use char because int might match the return type of a gcc2
18098    builtin and then its argument prototype would still apply.  */
18099 char sinf ();
18100 int
18101 main ()
18102 {
18103 sinf ();
18104   ;
18105   return 0;
18106 }
18107 _ACEOF
18108 rm -f conftest.$ac_objext conftest$ac_exeext
18109 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18110   (eval $ac_link) 2>conftest.er1
18111   ac_status=$?
18112   grep -v '^ *+' conftest.er1 >conftest.err
18113   rm -f conftest.er1
18114   cat conftest.err >&5
18115   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18116   (exit $ac_status); } &&
18117          { ac_try='test -z "$ac_c_werror_flag"
18118                          || test ! -s conftest.err'
18119   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18120   (eval $ac_try) 2>&5
18121   ac_status=$?
18122   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18123   (exit $ac_status); }; } &&
18124          { ac_try='test -s conftest$ac_exeext'
18125   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18126   (eval $ac_try) 2>&5
18127   ac_status=$?
18128   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18129   (exit $ac_status); }; }; then
18130   ac_cv_lib_m_sinf=yes
18131 else
18132   echo "$as_me: failed program was:" >&5
18133 sed 's/^/| /' conftest.$ac_ext >&5
18134
18135 ac_cv_lib_m_sinf=no
18136 fi
18137 rm -f conftest.err conftest.$ac_objext \
18138       conftest$ac_exeext conftest.$ac_ext
18139 LIBS=$ac_check_lib_save_LIBS
18140 fi
18141 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinf" >&5
18142 echo "${ECHO_T}$ac_cv_lib_m_sinf" >&6
18143 if test $ac_cv_lib_m_sinf = yes; then
18144
18145 cat >>confdefs.h <<\_ACEOF
18146 #define HAVE_SINF 1
18147 _ACEOF
18148
18149 fi
18150
18151 echo "$as_me:$LINENO: checking for sin in -lm" >&5
18152 echo $ECHO_N "checking for sin in -lm... $ECHO_C" >&6
18153 if test "${ac_cv_lib_m_sin+set}" = set; then
18154   echo $ECHO_N "(cached) $ECHO_C" >&6
18155 else
18156   ac_check_lib_save_LIBS=$LIBS
18157 LIBS="-lm  $LIBS"
18158 if test x$gcc_no_link = xyes; then
18159   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18160 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18161    { (exit 1); exit 1; }; }
18162 fi
18163 cat >conftest.$ac_ext <<_ACEOF
18164 /* confdefs.h.  */
18165 _ACEOF
18166 cat confdefs.h >>conftest.$ac_ext
18167 cat >>conftest.$ac_ext <<_ACEOF
18168 /* end confdefs.h.  */
18169
18170 /* Override any gcc2 internal prototype to avoid an error.  */
18171 #ifdef __cplusplus
18172 extern "C"
18173 #endif
18174 /* We use char because int might match the return type of a gcc2
18175    builtin and then its argument prototype would still apply.  */
18176 char sin ();
18177 int
18178 main ()
18179 {
18180 sin ();
18181   ;
18182   return 0;
18183 }
18184 _ACEOF
18185 rm -f conftest.$ac_objext conftest$ac_exeext
18186 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18187   (eval $ac_link) 2>conftest.er1
18188   ac_status=$?
18189   grep -v '^ *+' conftest.er1 >conftest.err
18190   rm -f conftest.er1
18191   cat conftest.err >&5
18192   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18193   (exit $ac_status); } &&
18194          { ac_try='test -z "$ac_c_werror_flag"
18195                          || test ! -s conftest.err'
18196   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18197   (eval $ac_try) 2>&5
18198   ac_status=$?
18199   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18200   (exit $ac_status); }; } &&
18201          { ac_try='test -s conftest$ac_exeext'
18202   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18203   (eval $ac_try) 2>&5
18204   ac_status=$?
18205   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18206   (exit $ac_status); }; }; then
18207   ac_cv_lib_m_sin=yes
18208 else
18209   echo "$as_me: failed program was:" >&5
18210 sed 's/^/| /' conftest.$ac_ext >&5
18211
18212 ac_cv_lib_m_sin=no
18213 fi
18214 rm -f conftest.err conftest.$ac_objext \
18215       conftest$ac_exeext conftest.$ac_ext
18216 LIBS=$ac_check_lib_save_LIBS
18217 fi
18218 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sin" >&5
18219 echo "${ECHO_T}$ac_cv_lib_m_sin" >&6
18220 if test $ac_cv_lib_m_sin = yes; then
18221
18222 cat >>confdefs.h <<\_ACEOF
18223 #define HAVE_SIN 1
18224 _ACEOF
18225
18226 fi
18227
18228 echo "$as_me:$LINENO: checking for sinl in -lm" >&5
18229 echo $ECHO_N "checking for sinl in -lm... $ECHO_C" >&6
18230 if test "${ac_cv_lib_m_sinl+set}" = set; then
18231   echo $ECHO_N "(cached) $ECHO_C" >&6
18232 else
18233   ac_check_lib_save_LIBS=$LIBS
18234 LIBS="-lm  $LIBS"
18235 if test x$gcc_no_link = xyes; then
18236   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18237 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18238    { (exit 1); exit 1; }; }
18239 fi
18240 cat >conftest.$ac_ext <<_ACEOF
18241 /* confdefs.h.  */
18242 _ACEOF
18243 cat confdefs.h >>conftest.$ac_ext
18244 cat >>conftest.$ac_ext <<_ACEOF
18245 /* end confdefs.h.  */
18246
18247 /* Override any gcc2 internal prototype to avoid an error.  */
18248 #ifdef __cplusplus
18249 extern "C"
18250 #endif
18251 /* We use char because int might match the return type of a gcc2
18252    builtin and then its argument prototype would still apply.  */
18253 char sinl ();
18254 int
18255 main ()
18256 {
18257 sinl ();
18258   ;
18259   return 0;
18260 }
18261 _ACEOF
18262 rm -f conftest.$ac_objext conftest$ac_exeext
18263 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18264   (eval $ac_link) 2>conftest.er1
18265   ac_status=$?
18266   grep -v '^ *+' conftest.er1 >conftest.err
18267   rm -f conftest.er1
18268   cat conftest.err >&5
18269   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18270   (exit $ac_status); } &&
18271          { ac_try='test -z "$ac_c_werror_flag"
18272                          || test ! -s conftest.err'
18273   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18274   (eval $ac_try) 2>&5
18275   ac_status=$?
18276   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18277   (exit $ac_status); }; } &&
18278          { ac_try='test -s conftest$ac_exeext'
18279   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18280   (eval $ac_try) 2>&5
18281   ac_status=$?
18282   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18283   (exit $ac_status); }; }; then
18284   ac_cv_lib_m_sinl=yes
18285 else
18286   echo "$as_me: failed program was:" >&5
18287 sed 's/^/| /' conftest.$ac_ext >&5
18288
18289 ac_cv_lib_m_sinl=no
18290 fi
18291 rm -f conftest.err conftest.$ac_objext \
18292       conftest$ac_exeext conftest.$ac_ext
18293 LIBS=$ac_check_lib_save_LIBS
18294 fi
18295 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinl" >&5
18296 echo "${ECHO_T}$ac_cv_lib_m_sinl" >&6
18297 if test $ac_cv_lib_m_sinl = yes; then
18298
18299 cat >>confdefs.h <<\_ACEOF
18300 #define HAVE_SINL 1
18301 _ACEOF
18302
18303 fi
18304
18305 echo "$as_me:$LINENO: checking for csinf in -lm" >&5
18306 echo $ECHO_N "checking for csinf in -lm... $ECHO_C" >&6
18307 if test "${ac_cv_lib_m_csinf+set}" = set; then
18308   echo $ECHO_N "(cached) $ECHO_C" >&6
18309 else
18310   ac_check_lib_save_LIBS=$LIBS
18311 LIBS="-lm  $LIBS"
18312 if test x$gcc_no_link = xyes; then
18313   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18314 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18315    { (exit 1); exit 1; }; }
18316 fi
18317 cat >conftest.$ac_ext <<_ACEOF
18318 /* confdefs.h.  */
18319 _ACEOF
18320 cat confdefs.h >>conftest.$ac_ext
18321 cat >>conftest.$ac_ext <<_ACEOF
18322 /* end confdefs.h.  */
18323
18324 /* Override any gcc2 internal prototype to avoid an error.  */
18325 #ifdef __cplusplus
18326 extern "C"
18327 #endif
18328 /* We use char because int might match the return type of a gcc2
18329    builtin and then its argument prototype would still apply.  */
18330 char csinf ();
18331 int
18332 main ()
18333 {
18334 csinf ();
18335   ;
18336   return 0;
18337 }
18338 _ACEOF
18339 rm -f conftest.$ac_objext conftest$ac_exeext
18340 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18341   (eval $ac_link) 2>conftest.er1
18342   ac_status=$?
18343   grep -v '^ *+' conftest.er1 >conftest.err
18344   rm -f conftest.er1
18345   cat conftest.err >&5
18346   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18347   (exit $ac_status); } &&
18348          { ac_try='test -z "$ac_c_werror_flag"
18349                          || test ! -s conftest.err'
18350   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18351   (eval $ac_try) 2>&5
18352   ac_status=$?
18353   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18354   (exit $ac_status); }; } &&
18355          { ac_try='test -s conftest$ac_exeext'
18356   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18357   (eval $ac_try) 2>&5
18358   ac_status=$?
18359   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18360   (exit $ac_status); }; }; then
18361   ac_cv_lib_m_csinf=yes
18362 else
18363   echo "$as_me: failed program was:" >&5
18364 sed 's/^/| /' conftest.$ac_ext >&5
18365
18366 ac_cv_lib_m_csinf=no
18367 fi
18368 rm -f conftest.err conftest.$ac_objext \
18369       conftest$ac_exeext conftest.$ac_ext
18370 LIBS=$ac_check_lib_save_LIBS
18371 fi
18372 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinf" >&5
18373 echo "${ECHO_T}$ac_cv_lib_m_csinf" >&6
18374 if test $ac_cv_lib_m_csinf = yes; then
18375
18376 cat >>confdefs.h <<\_ACEOF
18377 #define HAVE_CSINF 1
18378 _ACEOF
18379
18380 fi
18381
18382 echo "$as_me:$LINENO: checking for csin in -lm" >&5
18383 echo $ECHO_N "checking for csin in -lm... $ECHO_C" >&6
18384 if test "${ac_cv_lib_m_csin+set}" = set; then
18385   echo $ECHO_N "(cached) $ECHO_C" >&6
18386 else
18387   ac_check_lib_save_LIBS=$LIBS
18388 LIBS="-lm  $LIBS"
18389 if test x$gcc_no_link = xyes; then
18390   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18391 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18392    { (exit 1); exit 1; }; }
18393 fi
18394 cat >conftest.$ac_ext <<_ACEOF
18395 /* confdefs.h.  */
18396 _ACEOF
18397 cat confdefs.h >>conftest.$ac_ext
18398 cat >>conftest.$ac_ext <<_ACEOF
18399 /* end confdefs.h.  */
18400
18401 /* Override any gcc2 internal prototype to avoid an error.  */
18402 #ifdef __cplusplus
18403 extern "C"
18404 #endif
18405 /* We use char because int might match the return type of a gcc2
18406    builtin and then its argument prototype would still apply.  */
18407 char csin ();
18408 int
18409 main ()
18410 {
18411 csin ();
18412   ;
18413   return 0;
18414 }
18415 _ACEOF
18416 rm -f conftest.$ac_objext conftest$ac_exeext
18417 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18418   (eval $ac_link) 2>conftest.er1
18419   ac_status=$?
18420   grep -v '^ *+' conftest.er1 >conftest.err
18421   rm -f conftest.er1
18422   cat conftest.err >&5
18423   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18424   (exit $ac_status); } &&
18425          { ac_try='test -z "$ac_c_werror_flag"
18426                          || test ! -s conftest.err'
18427   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18428   (eval $ac_try) 2>&5
18429   ac_status=$?
18430   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18431   (exit $ac_status); }; } &&
18432          { ac_try='test -s conftest$ac_exeext'
18433   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18434   (eval $ac_try) 2>&5
18435   ac_status=$?
18436   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18437   (exit $ac_status); }; }; then
18438   ac_cv_lib_m_csin=yes
18439 else
18440   echo "$as_me: failed program was:" >&5
18441 sed 's/^/| /' conftest.$ac_ext >&5
18442
18443 ac_cv_lib_m_csin=no
18444 fi
18445 rm -f conftest.err conftest.$ac_objext \
18446       conftest$ac_exeext conftest.$ac_ext
18447 LIBS=$ac_check_lib_save_LIBS
18448 fi
18449 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csin" >&5
18450 echo "${ECHO_T}$ac_cv_lib_m_csin" >&6
18451 if test $ac_cv_lib_m_csin = yes; then
18452
18453 cat >>confdefs.h <<\_ACEOF
18454 #define HAVE_CSIN 1
18455 _ACEOF
18456
18457 fi
18458
18459 echo "$as_me:$LINENO: checking for csinl in -lm" >&5
18460 echo $ECHO_N "checking for csinl in -lm... $ECHO_C" >&6
18461 if test "${ac_cv_lib_m_csinl+set}" = set; then
18462   echo $ECHO_N "(cached) $ECHO_C" >&6
18463 else
18464   ac_check_lib_save_LIBS=$LIBS
18465 LIBS="-lm  $LIBS"
18466 if test x$gcc_no_link = xyes; then
18467   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18468 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18469    { (exit 1); exit 1; }; }
18470 fi
18471 cat >conftest.$ac_ext <<_ACEOF
18472 /* confdefs.h.  */
18473 _ACEOF
18474 cat confdefs.h >>conftest.$ac_ext
18475 cat >>conftest.$ac_ext <<_ACEOF
18476 /* end confdefs.h.  */
18477
18478 /* Override any gcc2 internal prototype to avoid an error.  */
18479 #ifdef __cplusplus
18480 extern "C"
18481 #endif
18482 /* We use char because int might match the return type of a gcc2
18483    builtin and then its argument prototype would still apply.  */
18484 char csinl ();
18485 int
18486 main ()
18487 {
18488 csinl ();
18489   ;
18490   return 0;
18491 }
18492 _ACEOF
18493 rm -f conftest.$ac_objext conftest$ac_exeext
18494 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18495   (eval $ac_link) 2>conftest.er1
18496   ac_status=$?
18497   grep -v '^ *+' conftest.er1 >conftest.err
18498   rm -f conftest.er1
18499   cat conftest.err >&5
18500   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18501   (exit $ac_status); } &&
18502          { ac_try='test -z "$ac_c_werror_flag"
18503                          || test ! -s conftest.err'
18504   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18505   (eval $ac_try) 2>&5
18506   ac_status=$?
18507   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18508   (exit $ac_status); }; } &&
18509          { ac_try='test -s conftest$ac_exeext'
18510   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18511   (eval $ac_try) 2>&5
18512   ac_status=$?
18513   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18514   (exit $ac_status); }; }; then
18515   ac_cv_lib_m_csinl=yes
18516 else
18517   echo "$as_me: failed program was:" >&5
18518 sed 's/^/| /' conftest.$ac_ext >&5
18519
18520 ac_cv_lib_m_csinl=no
18521 fi
18522 rm -f conftest.err conftest.$ac_objext \
18523       conftest$ac_exeext conftest.$ac_ext
18524 LIBS=$ac_check_lib_save_LIBS
18525 fi
18526 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinl" >&5
18527 echo "${ECHO_T}$ac_cv_lib_m_csinl" >&6
18528 if test $ac_cv_lib_m_csinl = yes; then
18529
18530 cat >>confdefs.h <<\_ACEOF
18531 #define HAVE_CSINL 1
18532 _ACEOF
18533
18534 fi
18535
18536 echo "$as_me:$LINENO: checking for sinhf in -lm" >&5
18537 echo $ECHO_N "checking for sinhf in -lm... $ECHO_C" >&6
18538 if test "${ac_cv_lib_m_sinhf+set}" = set; then
18539   echo $ECHO_N "(cached) $ECHO_C" >&6
18540 else
18541   ac_check_lib_save_LIBS=$LIBS
18542 LIBS="-lm  $LIBS"
18543 if test x$gcc_no_link = xyes; then
18544   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18545 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18546    { (exit 1); exit 1; }; }
18547 fi
18548 cat >conftest.$ac_ext <<_ACEOF
18549 /* confdefs.h.  */
18550 _ACEOF
18551 cat confdefs.h >>conftest.$ac_ext
18552 cat >>conftest.$ac_ext <<_ACEOF
18553 /* end confdefs.h.  */
18554
18555 /* Override any gcc2 internal prototype to avoid an error.  */
18556 #ifdef __cplusplus
18557 extern "C"
18558 #endif
18559 /* We use char because int might match the return type of a gcc2
18560    builtin and then its argument prototype would still apply.  */
18561 char sinhf ();
18562 int
18563 main ()
18564 {
18565 sinhf ();
18566   ;
18567   return 0;
18568 }
18569 _ACEOF
18570 rm -f conftest.$ac_objext conftest$ac_exeext
18571 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18572   (eval $ac_link) 2>conftest.er1
18573   ac_status=$?
18574   grep -v '^ *+' conftest.er1 >conftest.err
18575   rm -f conftest.er1
18576   cat conftest.err >&5
18577   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18578   (exit $ac_status); } &&
18579          { ac_try='test -z "$ac_c_werror_flag"
18580                          || test ! -s conftest.err'
18581   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18582   (eval $ac_try) 2>&5
18583   ac_status=$?
18584   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18585   (exit $ac_status); }; } &&
18586          { ac_try='test -s conftest$ac_exeext'
18587   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18588   (eval $ac_try) 2>&5
18589   ac_status=$?
18590   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18591   (exit $ac_status); }; }; then
18592   ac_cv_lib_m_sinhf=yes
18593 else
18594   echo "$as_me: failed program was:" >&5
18595 sed 's/^/| /' conftest.$ac_ext >&5
18596
18597 ac_cv_lib_m_sinhf=no
18598 fi
18599 rm -f conftest.err conftest.$ac_objext \
18600       conftest$ac_exeext conftest.$ac_ext
18601 LIBS=$ac_check_lib_save_LIBS
18602 fi
18603 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinhf" >&5
18604 echo "${ECHO_T}$ac_cv_lib_m_sinhf" >&6
18605 if test $ac_cv_lib_m_sinhf = yes; then
18606
18607 cat >>confdefs.h <<\_ACEOF
18608 #define HAVE_SINHF 1
18609 _ACEOF
18610
18611 fi
18612
18613 echo "$as_me:$LINENO: checking for sinh in -lm" >&5
18614 echo $ECHO_N "checking for sinh in -lm... $ECHO_C" >&6
18615 if test "${ac_cv_lib_m_sinh+set}" = set; then
18616   echo $ECHO_N "(cached) $ECHO_C" >&6
18617 else
18618   ac_check_lib_save_LIBS=$LIBS
18619 LIBS="-lm  $LIBS"
18620 if test x$gcc_no_link = xyes; then
18621   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18622 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18623    { (exit 1); exit 1; }; }
18624 fi
18625 cat >conftest.$ac_ext <<_ACEOF
18626 /* confdefs.h.  */
18627 _ACEOF
18628 cat confdefs.h >>conftest.$ac_ext
18629 cat >>conftest.$ac_ext <<_ACEOF
18630 /* end confdefs.h.  */
18631
18632 /* Override any gcc2 internal prototype to avoid an error.  */
18633 #ifdef __cplusplus
18634 extern "C"
18635 #endif
18636 /* We use char because int might match the return type of a gcc2
18637    builtin and then its argument prototype would still apply.  */
18638 char sinh ();
18639 int
18640 main ()
18641 {
18642 sinh ();
18643   ;
18644   return 0;
18645 }
18646 _ACEOF
18647 rm -f conftest.$ac_objext conftest$ac_exeext
18648 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18649   (eval $ac_link) 2>conftest.er1
18650   ac_status=$?
18651   grep -v '^ *+' conftest.er1 >conftest.err
18652   rm -f conftest.er1
18653   cat conftest.err >&5
18654   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18655   (exit $ac_status); } &&
18656          { ac_try='test -z "$ac_c_werror_flag"
18657                          || test ! -s conftest.err'
18658   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18659   (eval $ac_try) 2>&5
18660   ac_status=$?
18661   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18662   (exit $ac_status); }; } &&
18663          { ac_try='test -s conftest$ac_exeext'
18664   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18665   (eval $ac_try) 2>&5
18666   ac_status=$?
18667   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18668   (exit $ac_status); }; }; then
18669   ac_cv_lib_m_sinh=yes
18670 else
18671   echo "$as_me: failed program was:" >&5
18672 sed 's/^/| /' conftest.$ac_ext >&5
18673
18674 ac_cv_lib_m_sinh=no
18675 fi
18676 rm -f conftest.err conftest.$ac_objext \
18677       conftest$ac_exeext conftest.$ac_ext
18678 LIBS=$ac_check_lib_save_LIBS
18679 fi
18680 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinh" >&5
18681 echo "${ECHO_T}$ac_cv_lib_m_sinh" >&6
18682 if test $ac_cv_lib_m_sinh = yes; then
18683
18684 cat >>confdefs.h <<\_ACEOF
18685 #define HAVE_SINH 1
18686 _ACEOF
18687
18688 fi
18689
18690 echo "$as_me:$LINENO: checking for sinhl in -lm" >&5
18691 echo $ECHO_N "checking for sinhl in -lm... $ECHO_C" >&6
18692 if test "${ac_cv_lib_m_sinhl+set}" = set; then
18693   echo $ECHO_N "(cached) $ECHO_C" >&6
18694 else
18695   ac_check_lib_save_LIBS=$LIBS
18696 LIBS="-lm  $LIBS"
18697 if test x$gcc_no_link = xyes; then
18698   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18699 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18700    { (exit 1); exit 1; }; }
18701 fi
18702 cat >conftest.$ac_ext <<_ACEOF
18703 /* confdefs.h.  */
18704 _ACEOF
18705 cat confdefs.h >>conftest.$ac_ext
18706 cat >>conftest.$ac_ext <<_ACEOF
18707 /* end confdefs.h.  */
18708
18709 /* Override any gcc2 internal prototype to avoid an error.  */
18710 #ifdef __cplusplus
18711 extern "C"
18712 #endif
18713 /* We use char because int might match the return type of a gcc2
18714    builtin and then its argument prototype would still apply.  */
18715 char sinhl ();
18716 int
18717 main ()
18718 {
18719 sinhl ();
18720   ;
18721   return 0;
18722 }
18723 _ACEOF
18724 rm -f conftest.$ac_objext conftest$ac_exeext
18725 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18726   (eval $ac_link) 2>conftest.er1
18727   ac_status=$?
18728   grep -v '^ *+' conftest.er1 >conftest.err
18729   rm -f conftest.er1
18730   cat conftest.err >&5
18731   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18732   (exit $ac_status); } &&
18733          { ac_try='test -z "$ac_c_werror_flag"
18734                          || test ! -s conftest.err'
18735   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18736   (eval $ac_try) 2>&5
18737   ac_status=$?
18738   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18739   (exit $ac_status); }; } &&
18740          { ac_try='test -s conftest$ac_exeext'
18741   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18742   (eval $ac_try) 2>&5
18743   ac_status=$?
18744   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18745   (exit $ac_status); }; }; then
18746   ac_cv_lib_m_sinhl=yes
18747 else
18748   echo "$as_me: failed program was:" >&5
18749 sed 's/^/| /' conftest.$ac_ext >&5
18750
18751 ac_cv_lib_m_sinhl=no
18752 fi
18753 rm -f conftest.err conftest.$ac_objext \
18754       conftest$ac_exeext conftest.$ac_ext
18755 LIBS=$ac_check_lib_save_LIBS
18756 fi
18757 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinhl" >&5
18758 echo "${ECHO_T}$ac_cv_lib_m_sinhl" >&6
18759 if test $ac_cv_lib_m_sinhl = yes; then
18760
18761 cat >>confdefs.h <<\_ACEOF
18762 #define HAVE_SINHL 1
18763 _ACEOF
18764
18765 fi
18766
18767 echo "$as_me:$LINENO: checking for csinhf in -lm" >&5
18768 echo $ECHO_N "checking for csinhf in -lm... $ECHO_C" >&6
18769 if test "${ac_cv_lib_m_csinhf+set}" = set; then
18770   echo $ECHO_N "(cached) $ECHO_C" >&6
18771 else
18772   ac_check_lib_save_LIBS=$LIBS
18773 LIBS="-lm  $LIBS"
18774 if test x$gcc_no_link = xyes; then
18775   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18776 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18777    { (exit 1); exit 1; }; }
18778 fi
18779 cat >conftest.$ac_ext <<_ACEOF
18780 /* confdefs.h.  */
18781 _ACEOF
18782 cat confdefs.h >>conftest.$ac_ext
18783 cat >>conftest.$ac_ext <<_ACEOF
18784 /* end confdefs.h.  */
18785
18786 /* Override any gcc2 internal prototype to avoid an error.  */
18787 #ifdef __cplusplus
18788 extern "C"
18789 #endif
18790 /* We use char because int might match the return type of a gcc2
18791    builtin and then its argument prototype would still apply.  */
18792 char csinhf ();
18793 int
18794 main ()
18795 {
18796 csinhf ();
18797   ;
18798   return 0;
18799 }
18800 _ACEOF
18801 rm -f conftest.$ac_objext conftest$ac_exeext
18802 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18803   (eval $ac_link) 2>conftest.er1
18804   ac_status=$?
18805   grep -v '^ *+' conftest.er1 >conftest.err
18806   rm -f conftest.er1
18807   cat conftest.err >&5
18808   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18809   (exit $ac_status); } &&
18810          { ac_try='test -z "$ac_c_werror_flag"
18811                          || test ! -s conftest.err'
18812   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18813   (eval $ac_try) 2>&5
18814   ac_status=$?
18815   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18816   (exit $ac_status); }; } &&
18817          { ac_try='test -s conftest$ac_exeext'
18818   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18819   (eval $ac_try) 2>&5
18820   ac_status=$?
18821   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18822   (exit $ac_status); }; }; then
18823   ac_cv_lib_m_csinhf=yes
18824 else
18825   echo "$as_me: failed program was:" >&5
18826 sed 's/^/| /' conftest.$ac_ext >&5
18827
18828 ac_cv_lib_m_csinhf=no
18829 fi
18830 rm -f conftest.err conftest.$ac_objext \
18831       conftest$ac_exeext conftest.$ac_ext
18832 LIBS=$ac_check_lib_save_LIBS
18833 fi
18834 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinhf" >&5
18835 echo "${ECHO_T}$ac_cv_lib_m_csinhf" >&6
18836 if test $ac_cv_lib_m_csinhf = yes; then
18837
18838 cat >>confdefs.h <<\_ACEOF
18839 #define HAVE_CSINHF 1
18840 _ACEOF
18841
18842 fi
18843
18844 echo "$as_me:$LINENO: checking for csinh in -lm" >&5
18845 echo $ECHO_N "checking for csinh in -lm... $ECHO_C" >&6
18846 if test "${ac_cv_lib_m_csinh+set}" = set; then
18847   echo $ECHO_N "(cached) $ECHO_C" >&6
18848 else
18849   ac_check_lib_save_LIBS=$LIBS
18850 LIBS="-lm  $LIBS"
18851 if test x$gcc_no_link = xyes; then
18852   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18853 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18854    { (exit 1); exit 1; }; }
18855 fi
18856 cat >conftest.$ac_ext <<_ACEOF
18857 /* confdefs.h.  */
18858 _ACEOF
18859 cat confdefs.h >>conftest.$ac_ext
18860 cat >>conftest.$ac_ext <<_ACEOF
18861 /* end confdefs.h.  */
18862
18863 /* Override any gcc2 internal prototype to avoid an error.  */
18864 #ifdef __cplusplus
18865 extern "C"
18866 #endif
18867 /* We use char because int might match the return type of a gcc2
18868    builtin and then its argument prototype would still apply.  */
18869 char csinh ();
18870 int
18871 main ()
18872 {
18873 csinh ();
18874   ;
18875   return 0;
18876 }
18877 _ACEOF
18878 rm -f conftest.$ac_objext conftest$ac_exeext
18879 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18880   (eval $ac_link) 2>conftest.er1
18881   ac_status=$?
18882   grep -v '^ *+' conftest.er1 >conftest.err
18883   rm -f conftest.er1
18884   cat conftest.err >&5
18885   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18886   (exit $ac_status); } &&
18887          { ac_try='test -z "$ac_c_werror_flag"
18888                          || test ! -s conftest.err'
18889   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18890   (eval $ac_try) 2>&5
18891   ac_status=$?
18892   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18893   (exit $ac_status); }; } &&
18894          { ac_try='test -s conftest$ac_exeext'
18895   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18896   (eval $ac_try) 2>&5
18897   ac_status=$?
18898   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18899   (exit $ac_status); }; }; then
18900   ac_cv_lib_m_csinh=yes
18901 else
18902   echo "$as_me: failed program was:" >&5
18903 sed 's/^/| /' conftest.$ac_ext >&5
18904
18905 ac_cv_lib_m_csinh=no
18906 fi
18907 rm -f conftest.err conftest.$ac_objext \
18908       conftest$ac_exeext conftest.$ac_ext
18909 LIBS=$ac_check_lib_save_LIBS
18910 fi
18911 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinh" >&5
18912 echo "${ECHO_T}$ac_cv_lib_m_csinh" >&6
18913 if test $ac_cv_lib_m_csinh = yes; then
18914
18915 cat >>confdefs.h <<\_ACEOF
18916 #define HAVE_CSINH 1
18917 _ACEOF
18918
18919 fi
18920
18921 echo "$as_me:$LINENO: checking for csinhl in -lm" >&5
18922 echo $ECHO_N "checking for csinhl in -lm... $ECHO_C" >&6
18923 if test "${ac_cv_lib_m_csinhl+set}" = set; then
18924   echo $ECHO_N "(cached) $ECHO_C" >&6
18925 else
18926   ac_check_lib_save_LIBS=$LIBS
18927 LIBS="-lm  $LIBS"
18928 if test x$gcc_no_link = xyes; then
18929   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18930 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18931    { (exit 1); exit 1; }; }
18932 fi
18933 cat >conftest.$ac_ext <<_ACEOF
18934 /* confdefs.h.  */
18935 _ACEOF
18936 cat confdefs.h >>conftest.$ac_ext
18937 cat >>conftest.$ac_ext <<_ACEOF
18938 /* end confdefs.h.  */
18939
18940 /* Override any gcc2 internal prototype to avoid an error.  */
18941 #ifdef __cplusplus
18942 extern "C"
18943 #endif
18944 /* We use char because int might match the return type of a gcc2
18945    builtin and then its argument prototype would still apply.  */
18946 char csinhl ();
18947 int
18948 main ()
18949 {
18950 csinhl ();
18951   ;
18952   return 0;
18953 }
18954 _ACEOF
18955 rm -f conftest.$ac_objext conftest$ac_exeext
18956 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18957   (eval $ac_link) 2>conftest.er1
18958   ac_status=$?
18959   grep -v '^ *+' conftest.er1 >conftest.err
18960   rm -f conftest.er1
18961   cat conftest.err >&5
18962   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18963   (exit $ac_status); } &&
18964          { ac_try='test -z "$ac_c_werror_flag"
18965                          || test ! -s conftest.err'
18966   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18967   (eval $ac_try) 2>&5
18968   ac_status=$?
18969   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18970   (exit $ac_status); }; } &&
18971          { ac_try='test -s conftest$ac_exeext'
18972   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18973   (eval $ac_try) 2>&5
18974   ac_status=$?
18975   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18976   (exit $ac_status); }; }; then
18977   ac_cv_lib_m_csinhl=yes
18978 else
18979   echo "$as_me: failed program was:" >&5
18980 sed 's/^/| /' conftest.$ac_ext >&5
18981
18982 ac_cv_lib_m_csinhl=no
18983 fi
18984 rm -f conftest.err conftest.$ac_objext \
18985       conftest$ac_exeext conftest.$ac_ext
18986 LIBS=$ac_check_lib_save_LIBS
18987 fi
18988 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinhl" >&5
18989 echo "${ECHO_T}$ac_cv_lib_m_csinhl" >&6
18990 if test $ac_cv_lib_m_csinhl = yes; then
18991
18992 cat >>confdefs.h <<\_ACEOF
18993 #define HAVE_CSINHL 1
18994 _ACEOF
18995
18996 fi
18997
18998 echo "$as_me:$LINENO: checking for sqrtf in -lm" >&5
18999 echo $ECHO_N "checking for sqrtf in -lm... $ECHO_C" >&6
19000 if test "${ac_cv_lib_m_sqrtf+set}" = set; then
19001   echo $ECHO_N "(cached) $ECHO_C" >&6
19002 else
19003   ac_check_lib_save_LIBS=$LIBS
19004 LIBS="-lm  $LIBS"
19005 if test x$gcc_no_link = xyes; then
19006   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19007 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19008    { (exit 1); exit 1; }; }
19009 fi
19010 cat >conftest.$ac_ext <<_ACEOF
19011 /* confdefs.h.  */
19012 _ACEOF
19013 cat confdefs.h >>conftest.$ac_ext
19014 cat >>conftest.$ac_ext <<_ACEOF
19015 /* end confdefs.h.  */
19016
19017 /* Override any gcc2 internal prototype to avoid an error.  */
19018 #ifdef __cplusplus
19019 extern "C"
19020 #endif
19021 /* We use char because int might match the return type of a gcc2
19022    builtin and then its argument prototype would still apply.  */
19023 char sqrtf ();
19024 int
19025 main ()
19026 {
19027 sqrtf ();
19028   ;
19029   return 0;
19030 }
19031 _ACEOF
19032 rm -f conftest.$ac_objext conftest$ac_exeext
19033 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19034   (eval $ac_link) 2>conftest.er1
19035   ac_status=$?
19036   grep -v '^ *+' conftest.er1 >conftest.err
19037   rm -f conftest.er1
19038   cat conftest.err >&5
19039   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19040   (exit $ac_status); } &&
19041          { ac_try='test -z "$ac_c_werror_flag"
19042                          || test ! -s conftest.err'
19043   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19044   (eval $ac_try) 2>&5
19045   ac_status=$?
19046   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19047   (exit $ac_status); }; } &&
19048          { ac_try='test -s conftest$ac_exeext'
19049   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19050   (eval $ac_try) 2>&5
19051   ac_status=$?
19052   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19053   (exit $ac_status); }; }; then
19054   ac_cv_lib_m_sqrtf=yes
19055 else
19056   echo "$as_me: failed program was:" >&5
19057 sed 's/^/| /' conftest.$ac_ext >&5
19058
19059 ac_cv_lib_m_sqrtf=no
19060 fi
19061 rm -f conftest.err conftest.$ac_objext \
19062       conftest$ac_exeext conftest.$ac_ext
19063 LIBS=$ac_check_lib_save_LIBS
19064 fi
19065 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrtf" >&5
19066 echo "${ECHO_T}$ac_cv_lib_m_sqrtf" >&6
19067 if test $ac_cv_lib_m_sqrtf = yes; then
19068
19069 cat >>confdefs.h <<\_ACEOF
19070 #define HAVE_SQRTF 1
19071 _ACEOF
19072
19073 fi
19074
19075 echo "$as_me:$LINENO: checking for sqrt in -lm" >&5
19076 echo $ECHO_N "checking for sqrt in -lm... $ECHO_C" >&6
19077 if test "${ac_cv_lib_m_sqrt+set}" = set; then
19078   echo $ECHO_N "(cached) $ECHO_C" >&6
19079 else
19080   ac_check_lib_save_LIBS=$LIBS
19081 LIBS="-lm  $LIBS"
19082 if test x$gcc_no_link = xyes; then
19083   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19084 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19085    { (exit 1); exit 1; }; }
19086 fi
19087 cat >conftest.$ac_ext <<_ACEOF
19088 /* confdefs.h.  */
19089 _ACEOF
19090 cat confdefs.h >>conftest.$ac_ext
19091 cat >>conftest.$ac_ext <<_ACEOF
19092 /* end confdefs.h.  */
19093
19094 /* Override any gcc2 internal prototype to avoid an error.  */
19095 #ifdef __cplusplus
19096 extern "C"
19097 #endif
19098 /* We use char because int might match the return type of a gcc2
19099    builtin and then its argument prototype would still apply.  */
19100 char sqrt ();
19101 int
19102 main ()
19103 {
19104 sqrt ();
19105   ;
19106   return 0;
19107 }
19108 _ACEOF
19109 rm -f conftest.$ac_objext conftest$ac_exeext
19110 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19111   (eval $ac_link) 2>conftest.er1
19112   ac_status=$?
19113   grep -v '^ *+' conftest.er1 >conftest.err
19114   rm -f conftest.er1
19115   cat conftest.err >&5
19116   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19117   (exit $ac_status); } &&
19118          { ac_try='test -z "$ac_c_werror_flag"
19119                          || test ! -s conftest.err'
19120   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19121   (eval $ac_try) 2>&5
19122   ac_status=$?
19123   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19124   (exit $ac_status); }; } &&
19125          { ac_try='test -s conftest$ac_exeext'
19126   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19127   (eval $ac_try) 2>&5
19128   ac_status=$?
19129   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19130   (exit $ac_status); }; }; then
19131   ac_cv_lib_m_sqrt=yes
19132 else
19133   echo "$as_me: failed program was:" >&5
19134 sed 's/^/| /' conftest.$ac_ext >&5
19135
19136 ac_cv_lib_m_sqrt=no
19137 fi
19138 rm -f conftest.err conftest.$ac_objext \
19139       conftest$ac_exeext conftest.$ac_ext
19140 LIBS=$ac_check_lib_save_LIBS
19141 fi
19142 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrt" >&5
19143 echo "${ECHO_T}$ac_cv_lib_m_sqrt" >&6
19144 if test $ac_cv_lib_m_sqrt = yes; then
19145
19146 cat >>confdefs.h <<\_ACEOF
19147 #define HAVE_SQRT 1
19148 _ACEOF
19149
19150 fi
19151
19152 echo "$as_me:$LINENO: checking for sqrtl in -lm" >&5
19153 echo $ECHO_N "checking for sqrtl in -lm... $ECHO_C" >&6
19154 if test "${ac_cv_lib_m_sqrtl+set}" = set; then
19155   echo $ECHO_N "(cached) $ECHO_C" >&6
19156 else
19157   ac_check_lib_save_LIBS=$LIBS
19158 LIBS="-lm  $LIBS"
19159 if test x$gcc_no_link = xyes; then
19160   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19161 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19162    { (exit 1); exit 1; }; }
19163 fi
19164 cat >conftest.$ac_ext <<_ACEOF
19165 /* confdefs.h.  */
19166 _ACEOF
19167 cat confdefs.h >>conftest.$ac_ext
19168 cat >>conftest.$ac_ext <<_ACEOF
19169 /* end confdefs.h.  */
19170
19171 /* Override any gcc2 internal prototype to avoid an error.  */
19172 #ifdef __cplusplus
19173 extern "C"
19174 #endif
19175 /* We use char because int might match the return type of a gcc2
19176    builtin and then its argument prototype would still apply.  */
19177 char sqrtl ();
19178 int
19179 main ()
19180 {
19181 sqrtl ();
19182   ;
19183   return 0;
19184 }
19185 _ACEOF
19186 rm -f conftest.$ac_objext conftest$ac_exeext
19187 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19188   (eval $ac_link) 2>conftest.er1
19189   ac_status=$?
19190   grep -v '^ *+' conftest.er1 >conftest.err
19191   rm -f conftest.er1
19192   cat conftest.err >&5
19193   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19194   (exit $ac_status); } &&
19195          { ac_try='test -z "$ac_c_werror_flag"
19196                          || test ! -s conftest.err'
19197   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19198   (eval $ac_try) 2>&5
19199   ac_status=$?
19200   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19201   (exit $ac_status); }; } &&
19202          { ac_try='test -s conftest$ac_exeext'
19203   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19204   (eval $ac_try) 2>&5
19205   ac_status=$?
19206   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19207   (exit $ac_status); }; }; then
19208   ac_cv_lib_m_sqrtl=yes
19209 else
19210   echo "$as_me: failed program was:" >&5
19211 sed 's/^/| /' conftest.$ac_ext >&5
19212
19213 ac_cv_lib_m_sqrtl=no
19214 fi
19215 rm -f conftest.err conftest.$ac_objext \
19216       conftest$ac_exeext conftest.$ac_ext
19217 LIBS=$ac_check_lib_save_LIBS
19218 fi
19219 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrtl" >&5
19220 echo "${ECHO_T}$ac_cv_lib_m_sqrtl" >&6
19221 if test $ac_cv_lib_m_sqrtl = yes; then
19222
19223 cat >>confdefs.h <<\_ACEOF
19224 #define HAVE_SQRTL 1
19225 _ACEOF
19226
19227 fi
19228
19229 echo "$as_me:$LINENO: checking for csqrtf in -lm" >&5
19230 echo $ECHO_N "checking for csqrtf in -lm... $ECHO_C" >&6
19231 if test "${ac_cv_lib_m_csqrtf+set}" = set; then
19232   echo $ECHO_N "(cached) $ECHO_C" >&6
19233 else
19234   ac_check_lib_save_LIBS=$LIBS
19235 LIBS="-lm  $LIBS"
19236 if test x$gcc_no_link = xyes; then
19237   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19238 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19239    { (exit 1); exit 1; }; }
19240 fi
19241 cat >conftest.$ac_ext <<_ACEOF
19242 /* confdefs.h.  */
19243 _ACEOF
19244 cat confdefs.h >>conftest.$ac_ext
19245 cat >>conftest.$ac_ext <<_ACEOF
19246 /* end confdefs.h.  */
19247
19248 /* Override any gcc2 internal prototype to avoid an error.  */
19249 #ifdef __cplusplus
19250 extern "C"
19251 #endif
19252 /* We use char because int might match the return type of a gcc2
19253    builtin and then its argument prototype would still apply.  */
19254 char csqrtf ();
19255 int
19256 main ()
19257 {
19258 csqrtf ();
19259   ;
19260   return 0;
19261 }
19262 _ACEOF
19263 rm -f conftest.$ac_objext conftest$ac_exeext
19264 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19265   (eval $ac_link) 2>conftest.er1
19266   ac_status=$?
19267   grep -v '^ *+' conftest.er1 >conftest.err
19268   rm -f conftest.er1
19269   cat conftest.err >&5
19270   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19271   (exit $ac_status); } &&
19272          { ac_try='test -z "$ac_c_werror_flag"
19273                          || test ! -s conftest.err'
19274   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19275   (eval $ac_try) 2>&5
19276   ac_status=$?
19277   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19278   (exit $ac_status); }; } &&
19279          { ac_try='test -s conftest$ac_exeext'
19280   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19281   (eval $ac_try) 2>&5
19282   ac_status=$?
19283   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19284   (exit $ac_status); }; }; then
19285   ac_cv_lib_m_csqrtf=yes
19286 else
19287   echo "$as_me: failed program was:" >&5
19288 sed 's/^/| /' conftest.$ac_ext >&5
19289
19290 ac_cv_lib_m_csqrtf=no
19291 fi
19292 rm -f conftest.err conftest.$ac_objext \
19293       conftest$ac_exeext conftest.$ac_ext
19294 LIBS=$ac_check_lib_save_LIBS
19295 fi
19296 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrtf" >&5
19297 echo "${ECHO_T}$ac_cv_lib_m_csqrtf" >&6
19298 if test $ac_cv_lib_m_csqrtf = yes; then
19299
19300 cat >>confdefs.h <<\_ACEOF
19301 #define HAVE_CSQRTF 1
19302 _ACEOF
19303
19304 fi
19305
19306 echo "$as_me:$LINENO: checking for csqrt in -lm" >&5
19307 echo $ECHO_N "checking for csqrt in -lm... $ECHO_C" >&6
19308 if test "${ac_cv_lib_m_csqrt+set}" = set; then
19309   echo $ECHO_N "(cached) $ECHO_C" >&6
19310 else
19311   ac_check_lib_save_LIBS=$LIBS
19312 LIBS="-lm  $LIBS"
19313 if test x$gcc_no_link = xyes; then
19314   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19315 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19316    { (exit 1); exit 1; }; }
19317 fi
19318 cat >conftest.$ac_ext <<_ACEOF
19319 /* confdefs.h.  */
19320 _ACEOF
19321 cat confdefs.h >>conftest.$ac_ext
19322 cat >>conftest.$ac_ext <<_ACEOF
19323 /* end confdefs.h.  */
19324
19325 /* Override any gcc2 internal prototype to avoid an error.  */
19326 #ifdef __cplusplus
19327 extern "C"
19328 #endif
19329 /* We use char because int might match the return type of a gcc2
19330    builtin and then its argument prototype would still apply.  */
19331 char csqrt ();
19332 int
19333 main ()
19334 {
19335 csqrt ();
19336   ;
19337   return 0;
19338 }
19339 _ACEOF
19340 rm -f conftest.$ac_objext conftest$ac_exeext
19341 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19342   (eval $ac_link) 2>conftest.er1
19343   ac_status=$?
19344   grep -v '^ *+' conftest.er1 >conftest.err
19345   rm -f conftest.er1
19346   cat conftest.err >&5
19347   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19348   (exit $ac_status); } &&
19349          { ac_try='test -z "$ac_c_werror_flag"
19350                          || test ! -s conftest.err'
19351   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19352   (eval $ac_try) 2>&5
19353   ac_status=$?
19354   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19355   (exit $ac_status); }; } &&
19356          { ac_try='test -s conftest$ac_exeext'
19357   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19358   (eval $ac_try) 2>&5
19359   ac_status=$?
19360   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19361   (exit $ac_status); }; }; then
19362   ac_cv_lib_m_csqrt=yes
19363 else
19364   echo "$as_me: failed program was:" >&5
19365 sed 's/^/| /' conftest.$ac_ext >&5
19366
19367 ac_cv_lib_m_csqrt=no
19368 fi
19369 rm -f conftest.err conftest.$ac_objext \
19370       conftest$ac_exeext conftest.$ac_ext
19371 LIBS=$ac_check_lib_save_LIBS
19372 fi
19373 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrt" >&5
19374 echo "${ECHO_T}$ac_cv_lib_m_csqrt" >&6
19375 if test $ac_cv_lib_m_csqrt = yes; then
19376
19377 cat >>confdefs.h <<\_ACEOF
19378 #define HAVE_CSQRT 1
19379 _ACEOF
19380
19381 fi
19382
19383 echo "$as_me:$LINENO: checking for csqrtl in -lm" >&5
19384 echo $ECHO_N "checking for csqrtl in -lm... $ECHO_C" >&6
19385 if test "${ac_cv_lib_m_csqrtl+set}" = set; then
19386   echo $ECHO_N "(cached) $ECHO_C" >&6
19387 else
19388   ac_check_lib_save_LIBS=$LIBS
19389 LIBS="-lm  $LIBS"
19390 if test x$gcc_no_link = xyes; then
19391   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19392 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19393    { (exit 1); exit 1; }; }
19394 fi
19395 cat >conftest.$ac_ext <<_ACEOF
19396 /* confdefs.h.  */
19397 _ACEOF
19398 cat confdefs.h >>conftest.$ac_ext
19399 cat >>conftest.$ac_ext <<_ACEOF
19400 /* end confdefs.h.  */
19401
19402 /* Override any gcc2 internal prototype to avoid an error.  */
19403 #ifdef __cplusplus
19404 extern "C"
19405 #endif
19406 /* We use char because int might match the return type of a gcc2
19407    builtin and then its argument prototype would still apply.  */
19408 char csqrtl ();
19409 int
19410 main ()
19411 {
19412 csqrtl ();
19413   ;
19414   return 0;
19415 }
19416 _ACEOF
19417 rm -f conftest.$ac_objext conftest$ac_exeext
19418 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19419   (eval $ac_link) 2>conftest.er1
19420   ac_status=$?
19421   grep -v '^ *+' conftest.er1 >conftest.err
19422   rm -f conftest.er1
19423   cat conftest.err >&5
19424   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19425   (exit $ac_status); } &&
19426          { ac_try='test -z "$ac_c_werror_flag"
19427                          || test ! -s conftest.err'
19428   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19429   (eval $ac_try) 2>&5
19430   ac_status=$?
19431   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19432   (exit $ac_status); }; } &&
19433          { ac_try='test -s conftest$ac_exeext'
19434   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19435   (eval $ac_try) 2>&5
19436   ac_status=$?
19437   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19438   (exit $ac_status); }; }; then
19439   ac_cv_lib_m_csqrtl=yes
19440 else
19441   echo "$as_me: failed program was:" >&5
19442 sed 's/^/| /' conftest.$ac_ext >&5
19443
19444 ac_cv_lib_m_csqrtl=no
19445 fi
19446 rm -f conftest.err conftest.$ac_objext \
19447       conftest$ac_exeext conftest.$ac_ext
19448 LIBS=$ac_check_lib_save_LIBS
19449 fi
19450 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrtl" >&5
19451 echo "${ECHO_T}$ac_cv_lib_m_csqrtl" >&6
19452 if test $ac_cv_lib_m_csqrtl = yes; then
19453
19454 cat >>confdefs.h <<\_ACEOF
19455 #define HAVE_CSQRTL 1
19456 _ACEOF
19457
19458 fi
19459
19460 echo "$as_me:$LINENO: checking for tanf in -lm" >&5
19461 echo $ECHO_N "checking for tanf in -lm... $ECHO_C" >&6
19462 if test "${ac_cv_lib_m_tanf+set}" = set; then
19463   echo $ECHO_N "(cached) $ECHO_C" >&6
19464 else
19465   ac_check_lib_save_LIBS=$LIBS
19466 LIBS="-lm  $LIBS"
19467 if test x$gcc_no_link = xyes; then
19468   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19469 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19470    { (exit 1); exit 1; }; }
19471 fi
19472 cat >conftest.$ac_ext <<_ACEOF
19473 /* confdefs.h.  */
19474 _ACEOF
19475 cat confdefs.h >>conftest.$ac_ext
19476 cat >>conftest.$ac_ext <<_ACEOF
19477 /* end confdefs.h.  */
19478
19479 /* Override any gcc2 internal prototype to avoid an error.  */
19480 #ifdef __cplusplus
19481 extern "C"
19482 #endif
19483 /* We use char because int might match the return type of a gcc2
19484    builtin and then its argument prototype would still apply.  */
19485 char tanf ();
19486 int
19487 main ()
19488 {
19489 tanf ();
19490   ;
19491   return 0;
19492 }
19493 _ACEOF
19494 rm -f conftest.$ac_objext conftest$ac_exeext
19495 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19496   (eval $ac_link) 2>conftest.er1
19497   ac_status=$?
19498   grep -v '^ *+' conftest.er1 >conftest.err
19499   rm -f conftest.er1
19500   cat conftest.err >&5
19501   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19502   (exit $ac_status); } &&
19503          { ac_try='test -z "$ac_c_werror_flag"
19504                          || test ! -s conftest.err'
19505   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19506   (eval $ac_try) 2>&5
19507   ac_status=$?
19508   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19509   (exit $ac_status); }; } &&
19510          { ac_try='test -s conftest$ac_exeext'
19511   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19512   (eval $ac_try) 2>&5
19513   ac_status=$?
19514   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19515   (exit $ac_status); }; }; then
19516   ac_cv_lib_m_tanf=yes
19517 else
19518   echo "$as_me: failed program was:" >&5
19519 sed 's/^/| /' conftest.$ac_ext >&5
19520
19521 ac_cv_lib_m_tanf=no
19522 fi
19523 rm -f conftest.err conftest.$ac_objext \
19524       conftest$ac_exeext conftest.$ac_ext
19525 LIBS=$ac_check_lib_save_LIBS
19526 fi
19527 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanf" >&5
19528 echo "${ECHO_T}$ac_cv_lib_m_tanf" >&6
19529 if test $ac_cv_lib_m_tanf = yes; then
19530
19531 cat >>confdefs.h <<\_ACEOF
19532 #define HAVE_TANF 1
19533 _ACEOF
19534
19535 fi
19536
19537 echo "$as_me:$LINENO: checking for tan in -lm" >&5
19538 echo $ECHO_N "checking for tan in -lm... $ECHO_C" >&6
19539 if test "${ac_cv_lib_m_tan+set}" = set; then
19540   echo $ECHO_N "(cached) $ECHO_C" >&6
19541 else
19542   ac_check_lib_save_LIBS=$LIBS
19543 LIBS="-lm  $LIBS"
19544 if test x$gcc_no_link = xyes; then
19545   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19546 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19547    { (exit 1); exit 1; }; }
19548 fi
19549 cat >conftest.$ac_ext <<_ACEOF
19550 /* confdefs.h.  */
19551 _ACEOF
19552 cat confdefs.h >>conftest.$ac_ext
19553 cat >>conftest.$ac_ext <<_ACEOF
19554 /* end confdefs.h.  */
19555
19556 /* Override any gcc2 internal prototype to avoid an error.  */
19557 #ifdef __cplusplus
19558 extern "C"
19559 #endif
19560 /* We use char because int might match the return type of a gcc2
19561    builtin and then its argument prototype would still apply.  */
19562 char tan ();
19563 int
19564 main ()
19565 {
19566 tan ();
19567   ;
19568   return 0;
19569 }
19570 _ACEOF
19571 rm -f conftest.$ac_objext conftest$ac_exeext
19572 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19573   (eval $ac_link) 2>conftest.er1
19574   ac_status=$?
19575   grep -v '^ *+' conftest.er1 >conftest.err
19576   rm -f conftest.er1
19577   cat conftest.err >&5
19578   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19579   (exit $ac_status); } &&
19580          { ac_try='test -z "$ac_c_werror_flag"
19581                          || test ! -s conftest.err'
19582   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19583   (eval $ac_try) 2>&5
19584   ac_status=$?
19585   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19586   (exit $ac_status); }; } &&
19587          { ac_try='test -s conftest$ac_exeext'
19588   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19589   (eval $ac_try) 2>&5
19590   ac_status=$?
19591   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19592   (exit $ac_status); }; }; then
19593   ac_cv_lib_m_tan=yes
19594 else
19595   echo "$as_me: failed program was:" >&5
19596 sed 's/^/| /' conftest.$ac_ext >&5
19597
19598 ac_cv_lib_m_tan=no
19599 fi
19600 rm -f conftest.err conftest.$ac_objext \
19601       conftest$ac_exeext conftest.$ac_ext
19602 LIBS=$ac_check_lib_save_LIBS
19603 fi
19604 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tan" >&5
19605 echo "${ECHO_T}$ac_cv_lib_m_tan" >&6
19606 if test $ac_cv_lib_m_tan = yes; then
19607
19608 cat >>confdefs.h <<\_ACEOF
19609 #define HAVE_TAN 1
19610 _ACEOF
19611
19612 fi
19613
19614 echo "$as_me:$LINENO: checking for tanl in -lm" >&5
19615 echo $ECHO_N "checking for tanl in -lm... $ECHO_C" >&6
19616 if test "${ac_cv_lib_m_tanl+set}" = set; then
19617   echo $ECHO_N "(cached) $ECHO_C" >&6
19618 else
19619   ac_check_lib_save_LIBS=$LIBS
19620 LIBS="-lm  $LIBS"
19621 if test x$gcc_no_link = xyes; then
19622   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19623 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19624    { (exit 1); exit 1; }; }
19625 fi
19626 cat >conftest.$ac_ext <<_ACEOF
19627 /* confdefs.h.  */
19628 _ACEOF
19629 cat confdefs.h >>conftest.$ac_ext
19630 cat >>conftest.$ac_ext <<_ACEOF
19631 /* end confdefs.h.  */
19632
19633 /* Override any gcc2 internal prototype to avoid an error.  */
19634 #ifdef __cplusplus
19635 extern "C"
19636 #endif
19637 /* We use char because int might match the return type of a gcc2
19638    builtin and then its argument prototype would still apply.  */
19639 char tanl ();
19640 int
19641 main ()
19642 {
19643 tanl ();
19644   ;
19645   return 0;
19646 }
19647 _ACEOF
19648 rm -f conftest.$ac_objext conftest$ac_exeext
19649 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19650   (eval $ac_link) 2>conftest.er1
19651   ac_status=$?
19652   grep -v '^ *+' conftest.er1 >conftest.err
19653   rm -f conftest.er1
19654   cat conftest.err >&5
19655   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19656   (exit $ac_status); } &&
19657          { ac_try='test -z "$ac_c_werror_flag"
19658                          || test ! -s conftest.err'
19659   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19660   (eval $ac_try) 2>&5
19661   ac_status=$?
19662   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19663   (exit $ac_status); }; } &&
19664          { ac_try='test -s conftest$ac_exeext'
19665   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19666   (eval $ac_try) 2>&5
19667   ac_status=$?
19668   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19669   (exit $ac_status); }; }; then
19670   ac_cv_lib_m_tanl=yes
19671 else
19672   echo "$as_me: failed program was:" >&5
19673 sed 's/^/| /' conftest.$ac_ext >&5
19674
19675 ac_cv_lib_m_tanl=no
19676 fi
19677 rm -f conftest.err conftest.$ac_objext \
19678       conftest$ac_exeext conftest.$ac_ext
19679 LIBS=$ac_check_lib_save_LIBS
19680 fi
19681 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanl" >&5
19682 echo "${ECHO_T}$ac_cv_lib_m_tanl" >&6
19683 if test $ac_cv_lib_m_tanl = yes; then
19684
19685 cat >>confdefs.h <<\_ACEOF
19686 #define HAVE_TANL 1
19687 _ACEOF
19688
19689 fi
19690
19691 echo "$as_me:$LINENO: checking for ctanf in -lm" >&5
19692 echo $ECHO_N "checking for ctanf in -lm... $ECHO_C" >&6
19693 if test "${ac_cv_lib_m_ctanf+set}" = set; then
19694   echo $ECHO_N "(cached) $ECHO_C" >&6
19695 else
19696   ac_check_lib_save_LIBS=$LIBS
19697 LIBS="-lm  $LIBS"
19698 if test x$gcc_no_link = xyes; then
19699   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19700 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19701    { (exit 1); exit 1; }; }
19702 fi
19703 cat >conftest.$ac_ext <<_ACEOF
19704 /* confdefs.h.  */
19705 _ACEOF
19706 cat confdefs.h >>conftest.$ac_ext
19707 cat >>conftest.$ac_ext <<_ACEOF
19708 /* end confdefs.h.  */
19709
19710 /* Override any gcc2 internal prototype to avoid an error.  */
19711 #ifdef __cplusplus
19712 extern "C"
19713 #endif
19714 /* We use char because int might match the return type of a gcc2
19715    builtin and then its argument prototype would still apply.  */
19716 char ctanf ();
19717 int
19718 main ()
19719 {
19720 ctanf ();
19721   ;
19722   return 0;
19723 }
19724 _ACEOF
19725 rm -f conftest.$ac_objext conftest$ac_exeext
19726 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19727   (eval $ac_link) 2>conftest.er1
19728   ac_status=$?
19729   grep -v '^ *+' conftest.er1 >conftest.err
19730   rm -f conftest.er1
19731   cat conftest.err >&5
19732   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19733   (exit $ac_status); } &&
19734          { ac_try='test -z "$ac_c_werror_flag"
19735                          || test ! -s conftest.err'
19736   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19737   (eval $ac_try) 2>&5
19738   ac_status=$?
19739   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19740   (exit $ac_status); }; } &&
19741          { ac_try='test -s conftest$ac_exeext'
19742   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19743   (eval $ac_try) 2>&5
19744   ac_status=$?
19745   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19746   (exit $ac_status); }; }; then
19747   ac_cv_lib_m_ctanf=yes
19748 else
19749   echo "$as_me: failed program was:" >&5
19750 sed 's/^/| /' conftest.$ac_ext >&5
19751
19752 ac_cv_lib_m_ctanf=no
19753 fi
19754 rm -f conftest.err conftest.$ac_objext \
19755       conftest$ac_exeext conftest.$ac_ext
19756 LIBS=$ac_check_lib_save_LIBS
19757 fi
19758 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanf" >&5
19759 echo "${ECHO_T}$ac_cv_lib_m_ctanf" >&6
19760 if test $ac_cv_lib_m_ctanf = yes; then
19761
19762 cat >>confdefs.h <<\_ACEOF
19763 #define HAVE_CTANF 1
19764 _ACEOF
19765
19766 fi
19767
19768 echo "$as_me:$LINENO: checking for ctan in -lm" >&5
19769 echo $ECHO_N "checking for ctan in -lm... $ECHO_C" >&6
19770 if test "${ac_cv_lib_m_ctan+set}" = set; then
19771   echo $ECHO_N "(cached) $ECHO_C" >&6
19772 else
19773   ac_check_lib_save_LIBS=$LIBS
19774 LIBS="-lm  $LIBS"
19775 if test x$gcc_no_link = xyes; then
19776   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19777 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19778    { (exit 1); exit 1; }; }
19779 fi
19780 cat >conftest.$ac_ext <<_ACEOF
19781 /* confdefs.h.  */
19782 _ACEOF
19783 cat confdefs.h >>conftest.$ac_ext
19784 cat >>conftest.$ac_ext <<_ACEOF
19785 /* end confdefs.h.  */
19786
19787 /* Override any gcc2 internal prototype to avoid an error.  */
19788 #ifdef __cplusplus
19789 extern "C"
19790 #endif
19791 /* We use char because int might match the return type of a gcc2
19792    builtin and then its argument prototype would still apply.  */
19793 char ctan ();
19794 int
19795 main ()
19796 {
19797 ctan ();
19798   ;
19799   return 0;
19800 }
19801 _ACEOF
19802 rm -f conftest.$ac_objext conftest$ac_exeext
19803 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19804   (eval $ac_link) 2>conftest.er1
19805   ac_status=$?
19806   grep -v '^ *+' conftest.er1 >conftest.err
19807   rm -f conftest.er1
19808   cat conftest.err >&5
19809   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19810   (exit $ac_status); } &&
19811          { ac_try='test -z "$ac_c_werror_flag"
19812                          || test ! -s conftest.err'
19813   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19814   (eval $ac_try) 2>&5
19815   ac_status=$?
19816   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19817   (exit $ac_status); }; } &&
19818          { ac_try='test -s conftest$ac_exeext'
19819   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19820   (eval $ac_try) 2>&5
19821   ac_status=$?
19822   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19823   (exit $ac_status); }; }; then
19824   ac_cv_lib_m_ctan=yes
19825 else
19826   echo "$as_me: failed program was:" >&5
19827 sed 's/^/| /' conftest.$ac_ext >&5
19828
19829 ac_cv_lib_m_ctan=no
19830 fi
19831 rm -f conftest.err conftest.$ac_objext \
19832       conftest$ac_exeext conftest.$ac_ext
19833 LIBS=$ac_check_lib_save_LIBS
19834 fi
19835 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctan" >&5
19836 echo "${ECHO_T}$ac_cv_lib_m_ctan" >&6
19837 if test $ac_cv_lib_m_ctan = yes; then
19838
19839 cat >>confdefs.h <<\_ACEOF
19840 #define HAVE_CTAN 1
19841 _ACEOF
19842
19843 fi
19844
19845 echo "$as_me:$LINENO: checking for ctanl in -lm" >&5
19846 echo $ECHO_N "checking for ctanl in -lm... $ECHO_C" >&6
19847 if test "${ac_cv_lib_m_ctanl+set}" = set; then
19848   echo $ECHO_N "(cached) $ECHO_C" >&6
19849 else
19850   ac_check_lib_save_LIBS=$LIBS
19851 LIBS="-lm  $LIBS"
19852 if test x$gcc_no_link = xyes; then
19853   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19854 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19855    { (exit 1); exit 1; }; }
19856 fi
19857 cat >conftest.$ac_ext <<_ACEOF
19858 /* confdefs.h.  */
19859 _ACEOF
19860 cat confdefs.h >>conftest.$ac_ext
19861 cat >>conftest.$ac_ext <<_ACEOF
19862 /* end confdefs.h.  */
19863
19864 /* Override any gcc2 internal prototype to avoid an error.  */
19865 #ifdef __cplusplus
19866 extern "C"
19867 #endif
19868 /* We use char because int might match the return type of a gcc2
19869    builtin and then its argument prototype would still apply.  */
19870 char ctanl ();
19871 int
19872 main ()
19873 {
19874 ctanl ();
19875   ;
19876   return 0;
19877 }
19878 _ACEOF
19879 rm -f conftest.$ac_objext conftest$ac_exeext
19880 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19881   (eval $ac_link) 2>conftest.er1
19882   ac_status=$?
19883   grep -v '^ *+' conftest.er1 >conftest.err
19884   rm -f conftest.er1
19885   cat conftest.err >&5
19886   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19887   (exit $ac_status); } &&
19888          { ac_try='test -z "$ac_c_werror_flag"
19889                          || test ! -s conftest.err'
19890   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19891   (eval $ac_try) 2>&5
19892   ac_status=$?
19893   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19894   (exit $ac_status); }; } &&
19895          { ac_try='test -s conftest$ac_exeext'
19896   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19897   (eval $ac_try) 2>&5
19898   ac_status=$?
19899   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19900   (exit $ac_status); }; }; then
19901   ac_cv_lib_m_ctanl=yes
19902 else
19903   echo "$as_me: failed program was:" >&5
19904 sed 's/^/| /' conftest.$ac_ext >&5
19905
19906 ac_cv_lib_m_ctanl=no
19907 fi
19908 rm -f conftest.err conftest.$ac_objext \
19909       conftest$ac_exeext conftest.$ac_ext
19910 LIBS=$ac_check_lib_save_LIBS
19911 fi
19912 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanl" >&5
19913 echo "${ECHO_T}$ac_cv_lib_m_ctanl" >&6
19914 if test $ac_cv_lib_m_ctanl = yes; then
19915
19916 cat >>confdefs.h <<\_ACEOF
19917 #define HAVE_CTANL 1
19918 _ACEOF
19919
19920 fi
19921
19922 echo "$as_me:$LINENO: checking for tanhf in -lm" >&5
19923 echo $ECHO_N "checking for tanhf in -lm... $ECHO_C" >&6
19924 if test "${ac_cv_lib_m_tanhf+set}" = set; then
19925   echo $ECHO_N "(cached) $ECHO_C" >&6
19926 else
19927   ac_check_lib_save_LIBS=$LIBS
19928 LIBS="-lm  $LIBS"
19929 if test x$gcc_no_link = xyes; then
19930   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19931 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19932    { (exit 1); exit 1; }; }
19933 fi
19934 cat >conftest.$ac_ext <<_ACEOF
19935 /* confdefs.h.  */
19936 _ACEOF
19937 cat confdefs.h >>conftest.$ac_ext
19938 cat >>conftest.$ac_ext <<_ACEOF
19939 /* end confdefs.h.  */
19940
19941 /* Override any gcc2 internal prototype to avoid an error.  */
19942 #ifdef __cplusplus
19943 extern "C"
19944 #endif
19945 /* We use char because int might match the return type of a gcc2
19946    builtin and then its argument prototype would still apply.  */
19947 char tanhf ();
19948 int
19949 main ()
19950 {
19951 tanhf ();
19952   ;
19953   return 0;
19954 }
19955 _ACEOF
19956 rm -f conftest.$ac_objext conftest$ac_exeext
19957 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19958   (eval $ac_link) 2>conftest.er1
19959   ac_status=$?
19960   grep -v '^ *+' conftest.er1 >conftest.err
19961   rm -f conftest.er1
19962   cat conftest.err >&5
19963   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19964   (exit $ac_status); } &&
19965          { ac_try='test -z "$ac_c_werror_flag"
19966                          || test ! -s conftest.err'
19967   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19968   (eval $ac_try) 2>&5
19969   ac_status=$?
19970   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19971   (exit $ac_status); }; } &&
19972          { ac_try='test -s conftest$ac_exeext'
19973   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19974   (eval $ac_try) 2>&5
19975   ac_status=$?
19976   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19977   (exit $ac_status); }; }; then
19978   ac_cv_lib_m_tanhf=yes
19979 else
19980   echo "$as_me: failed program was:" >&5
19981 sed 's/^/| /' conftest.$ac_ext >&5
19982
19983 ac_cv_lib_m_tanhf=no
19984 fi
19985 rm -f conftest.err conftest.$ac_objext \
19986       conftest$ac_exeext conftest.$ac_ext
19987 LIBS=$ac_check_lib_save_LIBS
19988 fi
19989 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanhf" >&5
19990 echo "${ECHO_T}$ac_cv_lib_m_tanhf" >&6
19991 if test $ac_cv_lib_m_tanhf = yes; then
19992
19993 cat >>confdefs.h <<\_ACEOF
19994 #define HAVE_TANHF 1
19995 _ACEOF
19996
19997 fi
19998
19999 echo "$as_me:$LINENO: checking for tanh in -lm" >&5
20000 echo $ECHO_N "checking for tanh in -lm... $ECHO_C" >&6
20001 if test "${ac_cv_lib_m_tanh+set}" = set; then
20002   echo $ECHO_N "(cached) $ECHO_C" >&6
20003 else
20004   ac_check_lib_save_LIBS=$LIBS
20005 LIBS="-lm  $LIBS"
20006 if test x$gcc_no_link = xyes; then
20007   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20008 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20009    { (exit 1); exit 1; }; }
20010 fi
20011 cat >conftest.$ac_ext <<_ACEOF
20012 /* confdefs.h.  */
20013 _ACEOF
20014 cat confdefs.h >>conftest.$ac_ext
20015 cat >>conftest.$ac_ext <<_ACEOF
20016 /* end confdefs.h.  */
20017
20018 /* Override any gcc2 internal prototype to avoid an error.  */
20019 #ifdef __cplusplus
20020 extern "C"
20021 #endif
20022 /* We use char because int might match the return type of a gcc2
20023    builtin and then its argument prototype would still apply.  */
20024 char tanh ();
20025 int
20026 main ()
20027 {
20028 tanh ();
20029   ;
20030   return 0;
20031 }
20032 _ACEOF
20033 rm -f conftest.$ac_objext conftest$ac_exeext
20034 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20035   (eval $ac_link) 2>conftest.er1
20036   ac_status=$?
20037   grep -v '^ *+' conftest.er1 >conftest.err
20038   rm -f conftest.er1
20039   cat conftest.err >&5
20040   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20041   (exit $ac_status); } &&
20042          { ac_try='test -z "$ac_c_werror_flag"
20043                          || test ! -s conftest.err'
20044   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20045   (eval $ac_try) 2>&5
20046   ac_status=$?
20047   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20048   (exit $ac_status); }; } &&
20049          { ac_try='test -s conftest$ac_exeext'
20050   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20051   (eval $ac_try) 2>&5
20052   ac_status=$?
20053   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20054   (exit $ac_status); }; }; then
20055   ac_cv_lib_m_tanh=yes
20056 else
20057   echo "$as_me: failed program was:" >&5
20058 sed 's/^/| /' conftest.$ac_ext >&5
20059
20060 ac_cv_lib_m_tanh=no
20061 fi
20062 rm -f conftest.err conftest.$ac_objext \
20063       conftest$ac_exeext conftest.$ac_ext
20064 LIBS=$ac_check_lib_save_LIBS
20065 fi
20066 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanh" >&5
20067 echo "${ECHO_T}$ac_cv_lib_m_tanh" >&6
20068 if test $ac_cv_lib_m_tanh = yes; then
20069
20070 cat >>confdefs.h <<\_ACEOF
20071 #define HAVE_TANH 1
20072 _ACEOF
20073
20074 fi
20075
20076 echo "$as_me:$LINENO: checking for tanhl in -lm" >&5
20077 echo $ECHO_N "checking for tanhl in -lm... $ECHO_C" >&6
20078 if test "${ac_cv_lib_m_tanhl+set}" = set; then
20079   echo $ECHO_N "(cached) $ECHO_C" >&6
20080 else
20081   ac_check_lib_save_LIBS=$LIBS
20082 LIBS="-lm  $LIBS"
20083 if test x$gcc_no_link = xyes; then
20084   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20085 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20086    { (exit 1); exit 1; }; }
20087 fi
20088 cat >conftest.$ac_ext <<_ACEOF
20089 /* confdefs.h.  */
20090 _ACEOF
20091 cat confdefs.h >>conftest.$ac_ext
20092 cat >>conftest.$ac_ext <<_ACEOF
20093 /* end confdefs.h.  */
20094
20095 /* Override any gcc2 internal prototype to avoid an error.  */
20096 #ifdef __cplusplus
20097 extern "C"
20098 #endif
20099 /* We use char because int might match the return type of a gcc2
20100    builtin and then its argument prototype would still apply.  */
20101 char tanhl ();
20102 int
20103 main ()
20104 {
20105 tanhl ();
20106   ;
20107   return 0;
20108 }
20109 _ACEOF
20110 rm -f conftest.$ac_objext conftest$ac_exeext
20111 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20112   (eval $ac_link) 2>conftest.er1
20113   ac_status=$?
20114   grep -v '^ *+' conftest.er1 >conftest.err
20115   rm -f conftest.er1
20116   cat conftest.err >&5
20117   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20118   (exit $ac_status); } &&
20119          { ac_try='test -z "$ac_c_werror_flag"
20120                          || test ! -s conftest.err'
20121   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20122   (eval $ac_try) 2>&5
20123   ac_status=$?
20124   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20125   (exit $ac_status); }; } &&
20126          { ac_try='test -s conftest$ac_exeext'
20127   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20128   (eval $ac_try) 2>&5
20129   ac_status=$?
20130   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20131   (exit $ac_status); }; }; then
20132   ac_cv_lib_m_tanhl=yes
20133 else
20134   echo "$as_me: failed program was:" >&5
20135 sed 's/^/| /' conftest.$ac_ext >&5
20136
20137 ac_cv_lib_m_tanhl=no
20138 fi
20139 rm -f conftest.err conftest.$ac_objext \
20140       conftest$ac_exeext conftest.$ac_ext
20141 LIBS=$ac_check_lib_save_LIBS
20142 fi
20143 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanhl" >&5
20144 echo "${ECHO_T}$ac_cv_lib_m_tanhl" >&6
20145 if test $ac_cv_lib_m_tanhl = yes; then
20146
20147 cat >>confdefs.h <<\_ACEOF
20148 #define HAVE_TANHL 1
20149 _ACEOF
20150
20151 fi
20152
20153 echo "$as_me:$LINENO: checking for ctanhf in -lm" >&5
20154 echo $ECHO_N "checking for ctanhf in -lm... $ECHO_C" >&6
20155 if test "${ac_cv_lib_m_ctanhf+set}" = set; then
20156   echo $ECHO_N "(cached) $ECHO_C" >&6
20157 else
20158   ac_check_lib_save_LIBS=$LIBS
20159 LIBS="-lm  $LIBS"
20160 if test x$gcc_no_link = xyes; then
20161   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20162 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20163    { (exit 1); exit 1; }; }
20164 fi
20165 cat >conftest.$ac_ext <<_ACEOF
20166 /* confdefs.h.  */
20167 _ACEOF
20168 cat confdefs.h >>conftest.$ac_ext
20169 cat >>conftest.$ac_ext <<_ACEOF
20170 /* end confdefs.h.  */
20171
20172 /* Override any gcc2 internal prototype to avoid an error.  */
20173 #ifdef __cplusplus
20174 extern "C"
20175 #endif
20176 /* We use char because int might match the return type of a gcc2
20177    builtin and then its argument prototype would still apply.  */
20178 char ctanhf ();
20179 int
20180 main ()
20181 {
20182 ctanhf ();
20183   ;
20184   return 0;
20185 }
20186 _ACEOF
20187 rm -f conftest.$ac_objext conftest$ac_exeext
20188 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20189   (eval $ac_link) 2>conftest.er1
20190   ac_status=$?
20191   grep -v '^ *+' conftest.er1 >conftest.err
20192   rm -f conftest.er1
20193   cat conftest.err >&5
20194   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20195   (exit $ac_status); } &&
20196          { ac_try='test -z "$ac_c_werror_flag"
20197                          || test ! -s conftest.err'
20198   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20199   (eval $ac_try) 2>&5
20200   ac_status=$?
20201   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20202   (exit $ac_status); }; } &&
20203          { ac_try='test -s conftest$ac_exeext'
20204   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20205   (eval $ac_try) 2>&5
20206   ac_status=$?
20207   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20208   (exit $ac_status); }; }; then
20209   ac_cv_lib_m_ctanhf=yes
20210 else
20211   echo "$as_me: failed program was:" >&5
20212 sed 's/^/| /' conftest.$ac_ext >&5
20213
20214 ac_cv_lib_m_ctanhf=no
20215 fi
20216 rm -f conftest.err conftest.$ac_objext \
20217       conftest$ac_exeext conftest.$ac_ext
20218 LIBS=$ac_check_lib_save_LIBS
20219 fi
20220 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanhf" >&5
20221 echo "${ECHO_T}$ac_cv_lib_m_ctanhf" >&6
20222 if test $ac_cv_lib_m_ctanhf = yes; then
20223
20224 cat >>confdefs.h <<\_ACEOF
20225 #define HAVE_CTANHF 1
20226 _ACEOF
20227
20228 fi
20229
20230 echo "$as_me:$LINENO: checking for ctanh in -lm" >&5
20231 echo $ECHO_N "checking for ctanh in -lm... $ECHO_C" >&6
20232 if test "${ac_cv_lib_m_ctanh+set}" = set; then
20233   echo $ECHO_N "(cached) $ECHO_C" >&6
20234 else
20235   ac_check_lib_save_LIBS=$LIBS
20236 LIBS="-lm  $LIBS"
20237 if test x$gcc_no_link = xyes; then
20238   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20239 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20240    { (exit 1); exit 1; }; }
20241 fi
20242 cat >conftest.$ac_ext <<_ACEOF
20243 /* confdefs.h.  */
20244 _ACEOF
20245 cat confdefs.h >>conftest.$ac_ext
20246 cat >>conftest.$ac_ext <<_ACEOF
20247 /* end confdefs.h.  */
20248
20249 /* Override any gcc2 internal prototype to avoid an error.  */
20250 #ifdef __cplusplus
20251 extern "C"
20252 #endif
20253 /* We use char because int might match the return type of a gcc2
20254    builtin and then its argument prototype would still apply.  */
20255 char ctanh ();
20256 int
20257 main ()
20258 {
20259 ctanh ();
20260   ;
20261   return 0;
20262 }
20263 _ACEOF
20264 rm -f conftest.$ac_objext conftest$ac_exeext
20265 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20266   (eval $ac_link) 2>conftest.er1
20267   ac_status=$?
20268   grep -v '^ *+' conftest.er1 >conftest.err
20269   rm -f conftest.er1
20270   cat conftest.err >&5
20271   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20272   (exit $ac_status); } &&
20273          { ac_try='test -z "$ac_c_werror_flag"
20274                          || test ! -s conftest.err'
20275   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20276   (eval $ac_try) 2>&5
20277   ac_status=$?
20278   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20279   (exit $ac_status); }; } &&
20280          { ac_try='test -s conftest$ac_exeext'
20281   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20282   (eval $ac_try) 2>&5
20283   ac_status=$?
20284   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20285   (exit $ac_status); }; }; then
20286   ac_cv_lib_m_ctanh=yes
20287 else
20288   echo "$as_me: failed program was:" >&5
20289 sed 's/^/| /' conftest.$ac_ext >&5
20290
20291 ac_cv_lib_m_ctanh=no
20292 fi
20293 rm -f conftest.err conftest.$ac_objext \
20294       conftest$ac_exeext conftest.$ac_ext
20295 LIBS=$ac_check_lib_save_LIBS
20296 fi
20297 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanh" >&5
20298 echo "${ECHO_T}$ac_cv_lib_m_ctanh" >&6
20299 if test $ac_cv_lib_m_ctanh = yes; then
20300
20301 cat >>confdefs.h <<\_ACEOF
20302 #define HAVE_CTANH 1
20303 _ACEOF
20304
20305 fi
20306
20307 echo "$as_me:$LINENO: checking for ctanhl in -lm" >&5
20308 echo $ECHO_N "checking for ctanhl in -lm... $ECHO_C" >&6
20309 if test "${ac_cv_lib_m_ctanhl+set}" = set; then
20310   echo $ECHO_N "(cached) $ECHO_C" >&6
20311 else
20312   ac_check_lib_save_LIBS=$LIBS
20313 LIBS="-lm  $LIBS"
20314 if test x$gcc_no_link = xyes; then
20315   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20316 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20317    { (exit 1); exit 1; }; }
20318 fi
20319 cat >conftest.$ac_ext <<_ACEOF
20320 /* confdefs.h.  */
20321 _ACEOF
20322 cat confdefs.h >>conftest.$ac_ext
20323 cat >>conftest.$ac_ext <<_ACEOF
20324 /* end confdefs.h.  */
20325
20326 /* Override any gcc2 internal prototype to avoid an error.  */
20327 #ifdef __cplusplus
20328 extern "C"
20329 #endif
20330 /* We use char because int might match the return type of a gcc2
20331    builtin and then its argument prototype would still apply.  */
20332 char ctanhl ();
20333 int
20334 main ()
20335 {
20336 ctanhl ();
20337   ;
20338   return 0;
20339 }
20340 _ACEOF
20341 rm -f conftest.$ac_objext conftest$ac_exeext
20342 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20343   (eval $ac_link) 2>conftest.er1
20344   ac_status=$?
20345   grep -v '^ *+' conftest.er1 >conftest.err
20346   rm -f conftest.er1
20347   cat conftest.err >&5
20348   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20349   (exit $ac_status); } &&
20350          { ac_try='test -z "$ac_c_werror_flag"
20351                          || test ! -s conftest.err'
20352   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20353   (eval $ac_try) 2>&5
20354   ac_status=$?
20355   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20356   (exit $ac_status); }; } &&
20357          { ac_try='test -s conftest$ac_exeext'
20358   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20359   (eval $ac_try) 2>&5
20360   ac_status=$?
20361   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20362   (exit $ac_status); }; }; then
20363   ac_cv_lib_m_ctanhl=yes
20364 else
20365   echo "$as_me: failed program was:" >&5
20366 sed 's/^/| /' conftest.$ac_ext >&5
20367
20368 ac_cv_lib_m_ctanhl=no
20369 fi
20370 rm -f conftest.err conftest.$ac_objext \
20371       conftest$ac_exeext conftest.$ac_ext
20372 LIBS=$ac_check_lib_save_LIBS
20373 fi
20374 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanhl" >&5
20375 echo "${ECHO_T}$ac_cv_lib_m_ctanhl" >&6
20376 if test $ac_cv_lib_m_ctanhl = yes; then
20377
20378 cat >>confdefs.h <<\_ACEOF
20379 #define HAVE_CTANHL 1
20380 _ACEOF
20381
20382 fi
20383
20384 echo "$as_me:$LINENO: checking for truncf in -lm" >&5
20385 echo $ECHO_N "checking for truncf in -lm... $ECHO_C" >&6
20386 if test "${ac_cv_lib_m_truncf+set}" = set; then
20387   echo $ECHO_N "(cached) $ECHO_C" >&6
20388 else
20389   ac_check_lib_save_LIBS=$LIBS
20390 LIBS="-lm  $LIBS"
20391 if test x$gcc_no_link = xyes; then
20392   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20393 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20394    { (exit 1); exit 1; }; }
20395 fi
20396 cat >conftest.$ac_ext <<_ACEOF
20397 /* confdefs.h.  */
20398 _ACEOF
20399 cat confdefs.h >>conftest.$ac_ext
20400 cat >>conftest.$ac_ext <<_ACEOF
20401 /* end confdefs.h.  */
20402
20403 /* Override any gcc2 internal prototype to avoid an error.  */
20404 #ifdef __cplusplus
20405 extern "C"
20406 #endif
20407 /* We use char because int might match the return type of a gcc2
20408    builtin and then its argument prototype would still apply.  */
20409 char truncf ();
20410 int
20411 main ()
20412 {
20413 truncf ();
20414   ;
20415   return 0;
20416 }
20417 _ACEOF
20418 rm -f conftest.$ac_objext conftest$ac_exeext
20419 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20420   (eval $ac_link) 2>conftest.er1
20421   ac_status=$?
20422   grep -v '^ *+' conftest.er1 >conftest.err
20423   rm -f conftest.er1
20424   cat conftest.err >&5
20425   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20426   (exit $ac_status); } &&
20427          { ac_try='test -z "$ac_c_werror_flag"
20428                          || test ! -s conftest.err'
20429   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20430   (eval $ac_try) 2>&5
20431   ac_status=$?
20432   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20433   (exit $ac_status); }; } &&
20434          { ac_try='test -s conftest$ac_exeext'
20435   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20436   (eval $ac_try) 2>&5
20437   ac_status=$?
20438   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20439   (exit $ac_status); }; }; then
20440   ac_cv_lib_m_truncf=yes
20441 else
20442   echo "$as_me: failed program was:" >&5
20443 sed 's/^/| /' conftest.$ac_ext >&5
20444
20445 ac_cv_lib_m_truncf=no
20446 fi
20447 rm -f conftest.err conftest.$ac_objext \
20448       conftest$ac_exeext conftest.$ac_ext
20449 LIBS=$ac_check_lib_save_LIBS
20450 fi
20451 echo "$as_me:$LINENO: result: $ac_cv_lib_m_truncf" >&5
20452 echo "${ECHO_T}$ac_cv_lib_m_truncf" >&6
20453 if test $ac_cv_lib_m_truncf = yes; then
20454
20455 cat >>confdefs.h <<\_ACEOF
20456 #define HAVE_TRUNCF 1
20457 _ACEOF
20458
20459 fi
20460
20461 echo "$as_me:$LINENO: checking for trunc in -lm" >&5
20462 echo $ECHO_N "checking for trunc in -lm... $ECHO_C" >&6
20463 if test "${ac_cv_lib_m_trunc+set}" = set; then
20464   echo $ECHO_N "(cached) $ECHO_C" >&6
20465 else
20466   ac_check_lib_save_LIBS=$LIBS
20467 LIBS="-lm  $LIBS"
20468 if test x$gcc_no_link = xyes; then
20469   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20470 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20471    { (exit 1); exit 1; }; }
20472 fi
20473 cat >conftest.$ac_ext <<_ACEOF
20474 /* confdefs.h.  */
20475 _ACEOF
20476 cat confdefs.h >>conftest.$ac_ext
20477 cat >>conftest.$ac_ext <<_ACEOF
20478 /* end confdefs.h.  */
20479
20480 /* Override any gcc2 internal prototype to avoid an error.  */
20481 #ifdef __cplusplus
20482 extern "C"
20483 #endif
20484 /* We use char because int might match the return type of a gcc2
20485    builtin and then its argument prototype would still apply.  */
20486 char trunc ();
20487 int
20488 main ()
20489 {
20490 trunc ();
20491   ;
20492   return 0;
20493 }
20494 _ACEOF
20495 rm -f conftest.$ac_objext conftest$ac_exeext
20496 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20497   (eval $ac_link) 2>conftest.er1
20498   ac_status=$?
20499   grep -v '^ *+' conftest.er1 >conftest.err
20500   rm -f conftest.er1
20501   cat conftest.err >&5
20502   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20503   (exit $ac_status); } &&
20504          { ac_try='test -z "$ac_c_werror_flag"
20505                          || test ! -s conftest.err'
20506   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20507   (eval $ac_try) 2>&5
20508   ac_status=$?
20509   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20510   (exit $ac_status); }; } &&
20511          { ac_try='test -s conftest$ac_exeext'
20512   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20513   (eval $ac_try) 2>&5
20514   ac_status=$?
20515   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20516   (exit $ac_status); }; }; then
20517   ac_cv_lib_m_trunc=yes
20518 else
20519   echo "$as_me: failed program was:" >&5
20520 sed 's/^/| /' conftest.$ac_ext >&5
20521
20522 ac_cv_lib_m_trunc=no
20523 fi
20524 rm -f conftest.err conftest.$ac_objext \
20525       conftest$ac_exeext conftest.$ac_ext
20526 LIBS=$ac_check_lib_save_LIBS
20527 fi
20528 echo "$as_me:$LINENO: result: $ac_cv_lib_m_trunc" >&5
20529 echo "${ECHO_T}$ac_cv_lib_m_trunc" >&6
20530 if test $ac_cv_lib_m_trunc = yes; then
20531
20532 cat >>confdefs.h <<\_ACEOF
20533 #define HAVE_TRUNC 1
20534 _ACEOF
20535
20536 fi
20537
20538 echo "$as_me:$LINENO: checking for truncl in -lm" >&5
20539 echo $ECHO_N "checking for truncl in -lm... $ECHO_C" >&6
20540 if test "${ac_cv_lib_m_truncl+set}" = set; then
20541   echo $ECHO_N "(cached) $ECHO_C" >&6
20542 else
20543   ac_check_lib_save_LIBS=$LIBS
20544 LIBS="-lm  $LIBS"
20545 if test x$gcc_no_link = xyes; then
20546   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20547 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20548    { (exit 1); exit 1; }; }
20549 fi
20550 cat >conftest.$ac_ext <<_ACEOF
20551 /* confdefs.h.  */
20552 _ACEOF
20553 cat confdefs.h >>conftest.$ac_ext
20554 cat >>conftest.$ac_ext <<_ACEOF
20555 /* end confdefs.h.  */
20556
20557 /* Override any gcc2 internal prototype to avoid an error.  */
20558 #ifdef __cplusplus
20559 extern "C"
20560 #endif
20561 /* We use char because int might match the return type of a gcc2
20562    builtin and then its argument prototype would still apply.  */
20563 char truncl ();
20564 int
20565 main ()
20566 {
20567 truncl ();
20568   ;
20569   return 0;
20570 }
20571 _ACEOF
20572 rm -f conftest.$ac_objext conftest$ac_exeext
20573 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20574   (eval $ac_link) 2>conftest.er1
20575   ac_status=$?
20576   grep -v '^ *+' conftest.er1 >conftest.err
20577   rm -f conftest.er1
20578   cat conftest.err >&5
20579   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20580   (exit $ac_status); } &&
20581          { ac_try='test -z "$ac_c_werror_flag"
20582                          || test ! -s conftest.err'
20583   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20584   (eval $ac_try) 2>&5
20585   ac_status=$?
20586   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20587   (exit $ac_status); }; } &&
20588          { ac_try='test -s conftest$ac_exeext'
20589   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20590   (eval $ac_try) 2>&5
20591   ac_status=$?
20592   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20593   (exit $ac_status); }; }; then
20594   ac_cv_lib_m_truncl=yes
20595 else
20596   echo "$as_me: failed program was:" >&5
20597 sed 's/^/| /' conftest.$ac_ext >&5
20598
20599 ac_cv_lib_m_truncl=no
20600 fi
20601 rm -f conftest.err conftest.$ac_objext \
20602       conftest$ac_exeext conftest.$ac_ext
20603 LIBS=$ac_check_lib_save_LIBS
20604 fi
20605 echo "$as_me:$LINENO: result: $ac_cv_lib_m_truncl" >&5
20606 echo "${ECHO_T}$ac_cv_lib_m_truncl" >&6
20607 if test $ac_cv_lib_m_truncl = yes; then
20608
20609 cat >>confdefs.h <<\_ACEOF
20610 #define HAVE_TRUNCL 1
20611 _ACEOF
20612
20613 fi
20614
20615 echo "$as_me:$LINENO: checking for erff in -lm" >&5
20616 echo $ECHO_N "checking for erff in -lm... $ECHO_C" >&6
20617 if test "${ac_cv_lib_m_erff+set}" = set; then
20618   echo $ECHO_N "(cached) $ECHO_C" >&6
20619 else
20620   ac_check_lib_save_LIBS=$LIBS
20621 LIBS="-lm  $LIBS"
20622 if test x$gcc_no_link = xyes; then
20623   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20624 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20625    { (exit 1); exit 1; }; }
20626 fi
20627 cat >conftest.$ac_ext <<_ACEOF
20628 /* confdefs.h.  */
20629 _ACEOF
20630 cat confdefs.h >>conftest.$ac_ext
20631 cat >>conftest.$ac_ext <<_ACEOF
20632 /* end confdefs.h.  */
20633
20634 /* Override any gcc2 internal prototype to avoid an error.  */
20635 #ifdef __cplusplus
20636 extern "C"
20637 #endif
20638 /* We use char because int might match the return type of a gcc2
20639    builtin and then its argument prototype would still apply.  */
20640 char erff ();
20641 int
20642 main ()
20643 {
20644 erff ();
20645   ;
20646   return 0;
20647 }
20648 _ACEOF
20649 rm -f conftest.$ac_objext conftest$ac_exeext
20650 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20651   (eval $ac_link) 2>conftest.er1
20652   ac_status=$?
20653   grep -v '^ *+' conftest.er1 >conftest.err
20654   rm -f conftest.er1
20655   cat conftest.err >&5
20656   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20657   (exit $ac_status); } &&
20658          { ac_try='test -z "$ac_c_werror_flag"
20659                          || test ! -s conftest.err'
20660   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20661   (eval $ac_try) 2>&5
20662   ac_status=$?
20663   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20664   (exit $ac_status); }; } &&
20665          { ac_try='test -s conftest$ac_exeext'
20666   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20667   (eval $ac_try) 2>&5
20668   ac_status=$?
20669   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20670   (exit $ac_status); }; }; then
20671   ac_cv_lib_m_erff=yes
20672 else
20673   echo "$as_me: failed program was:" >&5
20674 sed 's/^/| /' conftest.$ac_ext >&5
20675
20676 ac_cv_lib_m_erff=no
20677 fi
20678 rm -f conftest.err conftest.$ac_objext \
20679       conftest$ac_exeext conftest.$ac_ext
20680 LIBS=$ac_check_lib_save_LIBS
20681 fi
20682 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erff" >&5
20683 echo "${ECHO_T}$ac_cv_lib_m_erff" >&6
20684 if test $ac_cv_lib_m_erff = yes; then
20685
20686 cat >>confdefs.h <<\_ACEOF
20687 #define HAVE_ERFF 1
20688 _ACEOF
20689
20690 fi
20691
20692 echo "$as_me:$LINENO: checking for erf in -lm" >&5
20693 echo $ECHO_N "checking for erf in -lm... $ECHO_C" >&6
20694 if test "${ac_cv_lib_m_erf+set}" = set; then
20695   echo $ECHO_N "(cached) $ECHO_C" >&6
20696 else
20697   ac_check_lib_save_LIBS=$LIBS
20698 LIBS="-lm  $LIBS"
20699 if test x$gcc_no_link = xyes; then
20700   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20701 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20702    { (exit 1); exit 1; }; }
20703 fi
20704 cat >conftest.$ac_ext <<_ACEOF
20705 /* confdefs.h.  */
20706 _ACEOF
20707 cat confdefs.h >>conftest.$ac_ext
20708 cat >>conftest.$ac_ext <<_ACEOF
20709 /* end confdefs.h.  */
20710
20711 /* Override any gcc2 internal prototype to avoid an error.  */
20712 #ifdef __cplusplus
20713 extern "C"
20714 #endif
20715 /* We use char because int might match the return type of a gcc2
20716    builtin and then its argument prototype would still apply.  */
20717 char erf ();
20718 int
20719 main ()
20720 {
20721 erf ();
20722   ;
20723   return 0;
20724 }
20725 _ACEOF
20726 rm -f conftest.$ac_objext conftest$ac_exeext
20727 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20728   (eval $ac_link) 2>conftest.er1
20729   ac_status=$?
20730   grep -v '^ *+' conftest.er1 >conftest.err
20731   rm -f conftest.er1
20732   cat conftest.err >&5
20733   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20734   (exit $ac_status); } &&
20735          { ac_try='test -z "$ac_c_werror_flag"
20736                          || test ! -s conftest.err'
20737   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20738   (eval $ac_try) 2>&5
20739   ac_status=$?
20740   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20741   (exit $ac_status); }; } &&
20742          { ac_try='test -s conftest$ac_exeext'
20743   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20744   (eval $ac_try) 2>&5
20745   ac_status=$?
20746   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20747   (exit $ac_status); }; }; then
20748   ac_cv_lib_m_erf=yes
20749 else
20750   echo "$as_me: failed program was:" >&5
20751 sed 's/^/| /' conftest.$ac_ext >&5
20752
20753 ac_cv_lib_m_erf=no
20754 fi
20755 rm -f conftest.err conftest.$ac_objext \
20756       conftest$ac_exeext conftest.$ac_ext
20757 LIBS=$ac_check_lib_save_LIBS
20758 fi
20759 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erf" >&5
20760 echo "${ECHO_T}$ac_cv_lib_m_erf" >&6
20761 if test $ac_cv_lib_m_erf = yes; then
20762
20763 cat >>confdefs.h <<\_ACEOF
20764 #define HAVE_ERF 1
20765 _ACEOF
20766
20767 fi
20768
20769 echo "$as_me:$LINENO: checking for erfl in -lm" >&5
20770 echo $ECHO_N "checking for erfl in -lm... $ECHO_C" >&6
20771 if test "${ac_cv_lib_m_erfl+set}" = set; then
20772   echo $ECHO_N "(cached) $ECHO_C" >&6
20773 else
20774   ac_check_lib_save_LIBS=$LIBS
20775 LIBS="-lm  $LIBS"
20776 if test x$gcc_no_link = xyes; then
20777   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20778 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20779    { (exit 1); exit 1; }; }
20780 fi
20781 cat >conftest.$ac_ext <<_ACEOF
20782 /* confdefs.h.  */
20783 _ACEOF
20784 cat confdefs.h >>conftest.$ac_ext
20785 cat >>conftest.$ac_ext <<_ACEOF
20786 /* end confdefs.h.  */
20787
20788 /* Override any gcc2 internal prototype to avoid an error.  */
20789 #ifdef __cplusplus
20790 extern "C"
20791 #endif
20792 /* We use char because int might match the return type of a gcc2
20793    builtin and then its argument prototype would still apply.  */
20794 char erfl ();
20795 int
20796 main ()
20797 {
20798 erfl ();
20799   ;
20800   return 0;
20801 }
20802 _ACEOF
20803 rm -f conftest.$ac_objext conftest$ac_exeext
20804 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20805   (eval $ac_link) 2>conftest.er1
20806   ac_status=$?
20807   grep -v '^ *+' conftest.er1 >conftest.err
20808   rm -f conftest.er1
20809   cat conftest.err >&5
20810   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20811   (exit $ac_status); } &&
20812          { ac_try='test -z "$ac_c_werror_flag"
20813                          || test ! -s conftest.err'
20814   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20815   (eval $ac_try) 2>&5
20816   ac_status=$?
20817   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20818   (exit $ac_status); }; } &&
20819          { ac_try='test -s conftest$ac_exeext'
20820   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20821   (eval $ac_try) 2>&5
20822   ac_status=$?
20823   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20824   (exit $ac_status); }; }; then
20825   ac_cv_lib_m_erfl=yes
20826 else
20827   echo "$as_me: failed program was:" >&5
20828 sed 's/^/| /' conftest.$ac_ext >&5
20829
20830 ac_cv_lib_m_erfl=no
20831 fi
20832 rm -f conftest.err conftest.$ac_objext \
20833       conftest$ac_exeext conftest.$ac_ext
20834 LIBS=$ac_check_lib_save_LIBS
20835 fi
20836 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfl" >&5
20837 echo "${ECHO_T}$ac_cv_lib_m_erfl" >&6
20838 if test $ac_cv_lib_m_erfl = yes; then
20839
20840 cat >>confdefs.h <<\_ACEOF
20841 #define HAVE_ERFL 1
20842 _ACEOF
20843
20844 fi
20845
20846 echo "$as_me:$LINENO: checking for erfcf in -lm" >&5
20847 echo $ECHO_N "checking for erfcf in -lm... $ECHO_C" >&6
20848 if test "${ac_cv_lib_m_erfcf+set}" = set; then
20849   echo $ECHO_N "(cached) $ECHO_C" >&6
20850 else
20851   ac_check_lib_save_LIBS=$LIBS
20852 LIBS="-lm  $LIBS"
20853 if test x$gcc_no_link = xyes; then
20854   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20855 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20856    { (exit 1); exit 1; }; }
20857 fi
20858 cat >conftest.$ac_ext <<_ACEOF
20859 /* confdefs.h.  */
20860 _ACEOF
20861 cat confdefs.h >>conftest.$ac_ext
20862 cat >>conftest.$ac_ext <<_ACEOF
20863 /* end confdefs.h.  */
20864
20865 /* Override any gcc2 internal prototype to avoid an error.  */
20866 #ifdef __cplusplus
20867 extern "C"
20868 #endif
20869 /* We use char because int might match the return type of a gcc2
20870    builtin and then its argument prototype would still apply.  */
20871 char erfcf ();
20872 int
20873 main ()
20874 {
20875 erfcf ();
20876   ;
20877   return 0;
20878 }
20879 _ACEOF
20880 rm -f conftest.$ac_objext conftest$ac_exeext
20881 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20882   (eval $ac_link) 2>conftest.er1
20883   ac_status=$?
20884   grep -v '^ *+' conftest.er1 >conftest.err
20885   rm -f conftest.er1
20886   cat conftest.err >&5
20887   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20888   (exit $ac_status); } &&
20889          { ac_try='test -z "$ac_c_werror_flag"
20890                          || test ! -s conftest.err'
20891   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20892   (eval $ac_try) 2>&5
20893   ac_status=$?
20894   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20895   (exit $ac_status); }; } &&
20896          { ac_try='test -s conftest$ac_exeext'
20897   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20898   (eval $ac_try) 2>&5
20899   ac_status=$?
20900   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20901   (exit $ac_status); }; }; then
20902   ac_cv_lib_m_erfcf=yes
20903 else
20904   echo "$as_me: failed program was:" >&5
20905 sed 's/^/| /' conftest.$ac_ext >&5
20906
20907 ac_cv_lib_m_erfcf=no
20908 fi
20909 rm -f conftest.err conftest.$ac_objext \
20910       conftest$ac_exeext conftest.$ac_ext
20911 LIBS=$ac_check_lib_save_LIBS
20912 fi
20913 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfcf" >&5
20914 echo "${ECHO_T}$ac_cv_lib_m_erfcf" >&6
20915 if test $ac_cv_lib_m_erfcf = yes; then
20916
20917 cat >>confdefs.h <<\_ACEOF
20918 #define HAVE_ERFCF 1
20919 _ACEOF
20920
20921 fi
20922
20923 echo "$as_me:$LINENO: checking for erfc in -lm" >&5
20924 echo $ECHO_N "checking for erfc in -lm... $ECHO_C" >&6
20925 if test "${ac_cv_lib_m_erfc+set}" = set; then
20926   echo $ECHO_N "(cached) $ECHO_C" >&6
20927 else
20928   ac_check_lib_save_LIBS=$LIBS
20929 LIBS="-lm  $LIBS"
20930 if test x$gcc_no_link = xyes; then
20931   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20932 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20933    { (exit 1); exit 1; }; }
20934 fi
20935 cat >conftest.$ac_ext <<_ACEOF
20936 /* confdefs.h.  */
20937 _ACEOF
20938 cat confdefs.h >>conftest.$ac_ext
20939 cat >>conftest.$ac_ext <<_ACEOF
20940 /* end confdefs.h.  */
20941
20942 /* Override any gcc2 internal prototype to avoid an error.  */
20943 #ifdef __cplusplus
20944 extern "C"
20945 #endif
20946 /* We use char because int might match the return type of a gcc2
20947    builtin and then its argument prototype would still apply.  */
20948 char erfc ();
20949 int
20950 main ()
20951 {
20952 erfc ();
20953   ;
20954   return 0;
20955 }
20956 _ACEOF
20957 rm -f conftest.$ac_objext conftest$ac_exeext
20958 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20959   (eval $ac_link) 2>conftest.er1
20960   ac_status=$?
20961   grep -v '^ *+' conftest.er1 >conftest.err
20962   rm -f conftest.er1
20963   cat conftest.err >&5
20964   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20965   (exit $ac_status); } &&
20966          { ac_try='test -z "$ac_c_werror_flag"
20967                          || test ! -s conftest.err'
20968   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20969   (eval $ac_try) 2>&5
20970   ac_status=$?
20971   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20972   (exit $ac_status); }; } &&
20973          { ac_try='test -s conftest$ac_exeext'
20974   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20975   (eval $ac_try) 2>&5
20976   ac_status=$?
20977   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20978   (exit $ac_status); }; }; then
20979   ac_cv_lib_m_erfc=yes
20980 else
20981   echo "$as_me: failed program was:" >&5
20982 sed 's/^/| /' conftest.$ac_ext >&5
20983
20984 ac_cv_lib_m_erfc=no
20985 fi
20986 rm -f conftest.err conftest.$ac_objext \
20987       conftest$ac_exeext conftest.$ac_ext
20988 LIBS=$ac_check_lib_save_LIBS
20989 fi
20990 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfc" >&5
20991 echo "${ECHO_T}$ac_cv_lib_m_erfc" >&6
20992 if test $ac_cv_lib_m_erfc = yes; then
20993
20994 cat >>confdefs.h <<\_ACEOF
20995 #define HAVE_ERFC 1
20996 _ACEOF
20997
20998 fi
20999
21000 echo "$as_me:$LINENO: checking for erfcl in -lm" >&5
21001 echo $ECHO_N "checking for erfcl in -lm... $ECHO_C" >&6
21002 if test "${ac_cv_lib_m_erfcl+set}" = set; then
21003   echo $ECHO_N "(cached) $ECHO_C" >&6
21004 else
21005   ac_check_lib_save_LIBS=$LIBS
21006 LIBS="-lm  $LIBS"
21007 if test x$gcc_no_link = xyes; then
21008   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21009 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21010    { (exit 1); exit 1; }; }
21011 fi
21012 cat >conftest.$ac_ext <<_ACEOF
21013 /* confdefs.h.  */
21014 _ACEOF
21015 cat confdefs.h >>conftest.$ac_ext
21016 cat >>conftest.$ac_ext <<_ACEOF
21017 /* end confdefs.h.  */
21018
21019 /* Override any gcc2 internal prototype to avoid an error.  */
21020 #ifdef __cplusplus
21021 extern "C"
21022 #endif
21023 /* We use char because int might match the return type of a gcc2
21024    builtin and then its argument prototype would still apply.  */
21025 char erfcl ();
21026 int
21027 main ()
21028 {
21029 erfcl ();
21030   ;
21031   return 0;
21032 }
21033 _ACEOF
21034 rm -f conftest.$ac_objext conftest$ac_exeext
21035 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21036   (eval $ac_link) 2>conftest.er1
21037   ac_status=$?
21038   grep -v '^ *+' conftest.er1 >conftest.err
21039   rm -f conftest.er1
21040   cat conftest.err >&5
21041   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21042   (exit $ac_status); } &&
21043          { ac_try='test -z "$ac_c_werror_flag"
21044                          || test ! -s conftest.err'
21045   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21046   (eval $ac_try) 2>&5
21047   ac_status=$?
21048   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21049   (exit $ac_status); }; } &&
21050          { ac_try='test -s conftest$ac_exeext'
21051   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21052   (eval $ac_try) 2>&5
21053   ac_status=$?
21054   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21055   (exit $ac_status); }; }; then
21056   ac_cv_lib_m_erfcl=yes
21057 else
21058   echo "$as_me: failed program was:" >&5
21059 sed 's/^/| /' conftest.$ac_ext >&5
21060
21061 ac_cv_lib_m_erfcl=no
21062 fi
21063 rm -f conftest.err conftest.$ac_objext \
21064       conftest$ac_exeext conftest.$ac_ext
21065 LIBS=$ac_check_lib_save_LIBS
21066 fi
21067 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfcl" >&5
21068 echo "${ECHO_T}$ac_cv_lib_m_erfcl" >&6
21069 if test $ac_cv_lib_m_erfcl = yes; then
21070
21071 cat >>confdefs.h <<\_ACEOF
21072 #define HAVE_ERFCL 1
21073 _ACEOF
21074
21075 fi
21076
21077 echo "$as_me:$LINENO: checking for j0f in -lm" >&5
21078 echo $ECHO_N "checking for j0f in -lm... $ECHO_C" >&6
21079 if test "${ac_cv_lib_m_j0f+set}" = set; then
21080   echo $ECHO_N "(cached) $ECHO_C" >&6
21081 else
21082   ac_check_lib_save_LIBS=$LIBS
21083 LIBS="-lm  $LIBS"
21084 if test x$gcc_no_link = xyes; then
21085   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21086 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21087    { (exit 1); exit 1; }; }
21088 fi
21089 cat >conftest.$ac_ext <<_ACEOF
21090 /* confdefs.h.  */
21091 _ACEOF
21092 cat confdefs.h >>conftest.$ac_ext
21093 cat >>conftest.$ac_ext <<_ACEOF
21094 /* end confdefs.h.  */
21095
21096 /* Override any gcc2 internal prototype to avoid an error.  */
21097 #ifdef __cplusplus
21098 extern "C"
21099 #endif
21100 /* We use char because int might match the return type of a gcc2
21101    builtin and then its argument prototype would still apply.  */
21102 char j0f ();
21103 int
21104 main ()
21105 {
21106 j0f ();
21107   ;
21108   return 0;
21109 }
21110 _ACEOF
21111 rm -f conftest.$ac_objext conftest$ac_exeext
21112 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21113   (eval $ac_link) 2>conftest.er1
21114   ac_status=$?
21115   grep -v '^ *+' conftest.er1 >conftest.err
21116   rm -f conftest.er1
21117   cat conftest.err >&5
21118   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21119   (exit $ac_status); } &&
21120          { ac_try='test -z "$ac_c_werror_flag"
21121                          || test ! -s conftest.err'
21122   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21123   (eval $ac_try) 2>&5
21124   ac_status=$?
21125   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21126   (exit $ac_status); }; } &&
21127          { ac_try='test -s conftest$ac_exeext'
21128   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21129   (eval $ac_try) 2>&5
21130   ac_status=$?
21131   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21132   (exit $ac_status); }; }; then
21133   ac_cv_lib_m_j0f=yes
21134 else
21135   echo "$as_me: failed program was:" >&5
21136 sed 's/^/| /' conftest.$ac_ext >&5
21137
21138 ac_cv_lib_m_j0f=no
21139 fi
21140 rm -f conftest.err conftest.$ac_objext \
21141       conftest$ac_exeext conftest.$ac_ext
21142 LIBS=$ac_check_lib_save_LIBS
21143 fi
21144 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0f" >&5
21145 echo "${ECHO_T}$ac_cv_lib_m_j0f" >&6
21146 if test $ac_cv_lib_m_j0f = yes; then
21147
21148 cat >>confdefs.h <<\_ACEOF
21149 #define HAVE_J0F 1
21150 _ACEOF
21151
21152 fi
21153
21154 echo "$as_me:$LINENO: checking for j0 in -lm" >&5
21155 echo $ECHO_N "checking for j0 in -lm... $ECHO_C" >&6
21156 if test "${ac_cv_lib_m_j0+set}" = set; then
21157   echo $ECHO_N "(cached) $ECHO_C" >&6
21158 else
21159   ac_check_lib_save_LIBS=$LIBS
21160 LIBS="-lm  $LIBS"
21161 if test x$gcc_no_link = xyes; then
21162   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21163 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21164    { (exit 1); exit 1; }; }
21165 fi
21166 cat >conftest.$ac_ext <<_ACEOF
21167 /* confdefs.h.  */
21168 _ACEOF
21169 cat confdefs.h >>conftest.$ac_ext
21170 cat >>conftest.$ac_ext <<_ACEOF
21171 /* end confdefs.h.  */
21172
21173 /* Override any gcc2 internal prototype to avoid an error.  */
21174 #ifdef __cplusplus
21175 extern "C"
21176 #endif
21177 /* We use char because int might match the return type of a gcc2
21178    builtin and then its argument prototype would still apply.  */
21179 char j0 ();
21180 int
21181 main ()
21182 {
21183 j0 ();
21184   ;
21185   return 0;
21186 }
21187 _ACEOF
21188 rm -f conftest.$ac_objext conftest$ac_exeext
21189 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21190   (eval $ac_link) 2>conftest.er1
21191   ac_status=$?
21192   grep -v '^ *+' conftest.er1 >conftest.err
21193   rm -f conftest.er1
21194   cat conftest.err >&5
21195   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21196   (exit $ac_status); } &&
21197          { ac_try='test -z "$ac_c_werror_flag"
21198                          || test ! -s conftest.err'
21199   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21200   (eval $ac_try) 2>&5
21201   ac_status=$?
21202   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21203   (exit $ac_status); }; } &&
21204          { ac_try='test -s conftest$ac_exeext'
21205   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21206   (eval $ac_try) 2>&5
21207   ac_status=$?
21208   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21209   (exit $ac_status); }; }; then
21210   ac_cv_lib_m_j0=yes
21211 else
21212   echo "$as_me: failed program was:" >&5
21213 sed 's/^/| /' conftest.$ac_ext >&5
21214
21215 ac_cv_lib_m_j0=no
21216 fi
21217 rm -f conftest.err conftest.$ac_objext \
21218       conftest$ac_exeext conftest.$ac_ext
21219 LIBS=$ac_check_lib_save_LIBS
21220 fi
21221 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0" >&5
21222 echo "${ECHO_T}$ac_cv_lib_m_j0" >&6
21223 if test $ac_cv_lib_m_j0 = yes; then
21224
21225 cat >>confdefs.h <<\_ACEOF
21226 #define HAVE_J0 1
21227 _ACEOF
21228
21229 fi
21230
21231 echo "$as_me:$LINENO: checking for j0l in -lm" >&5
21232 echo $ECHO_N "checking for j0l in -lm... $ECHO_C" >&6
21233 if test "${ac_cv_lib_m_j0l+set}" = set; then
21234   echo $ECHO_N "(cached) $ECHO_C" >&6
21235 else
21236   ac_check_lib_save_LIBS=$LIBS
21237 LIBS="-lm  $LIBS"
21238 if test x$gcc_no_link = xyes; then
21239   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21240 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21241    { (exit 1); exit 1; }; }
21242 fi
21243 cat >conftest.$ac_ext <<_ACEOF
21244 /* confdefs.h.  */
21245 _ACEOF
21246 cat confdefs.h >>conftest.$ac_ext
21247 cat >>conftest.$ac_ext <<_ACEOF
21248 /* end confdefs.h.  */
21249
21250 /* Override any gcc2 internal prototype to avoid an error.  */
21251 #ifdef __cplusplus
21252 extern "C"
21253 #endif
21254 /* We use char because int might match the return type of a gcc2
21255    builtin and then its argument prototype would still apply.  */
21256 char j0l ();
21257 int
21258 main ()
21259 {
21260 j0l ();
21261   ;
21262   return 0;
21263 }
21264 _ACEOF
21265 rm -f conftest.$ac_objext conftest$ac_exeext
21266 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21267   (eval $ac_link) 2>conftest.er1
21268   ac_status=$?
21269   grep -v '^ *+' conftest.er1 >conftest.err
21270   rm -f conftest.er1
21271   cat conftest.err >&5
21272   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21273   (exit $ac_status); } &&
21274          { ac_try='test -z "$ac_c_werror_flag"
21275                          || test ! -s conftest.err'
21276   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21277   (eval $ac_try) 2>&5
21278   ac_status=$?
21279   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21280   (exit $ac_status); }; } &&
21281          { ac_try='test -s conftest$ac_exeext'
21282   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21283   (eval $ac_try) 2>&5
21284   ac_status=$?
21285   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21286   (exit $ac_status); }; }; then
21287   ac_cv_lib_m_j0l=yes
21288 else
21289   echo "$as_me: failed program was:" >&5
21290 sed 's/^/| /' conftest.$ac_ext >&5
21291
21292 ac_cv_lib_m_j0l=no
21293 fi
21294 rm -f conftest.err conftest.$ac_objext \
21295       conftest$ac_exeext conftest.$ac_ext
21296 LIBS=$ac_check_lib_save_LIBS
21297 fi
21298 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0l" >&5
21299 echo "${ECHO_T}$ac_cv_lib_m_j0l" >&6
21300 if test $ac_cv_lib_m_j0l = yes; then
21301
21302 cat >>confdefs.h <<\_ACEOF
21303 #define HAVE_J0L 1
21304 _ACEOF
21305
21306 fi
21307
21308 echo "$as_me:$LINENO: checking for j1f in -lm" >&5
21309 echo $ECHO_N "checking for j1f in -lm... $ECHO_C" >&6
21310 if test "${ac_cv_lib_m_j1f+set}" = set; then
21311   echo $ECHO_N "(cached) $ECHO_C" >&6
21312 else
21313   ac_check_lib_save_LIBS=$LIBS
21314 LIBS="-lm  $LIBS"
21315 if test x$gcc_no_link = xyes; then
21316   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21317 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21318    { (exit 1); exit 1; }; }
21319 fi
21320 cat >conftest.$ac_ext <<_ACEOF
21321 /* confdefs.h.  */
21322 _ACEOF
21323 cat confdefs.h >>conftest.$ac_ext
21324 cat >>conftest.$ac_ext <<_ACEOF
21325 /* end confdefs.h.  */
21326
21327 /* Override any gcc2 internal prototype to avoid an error.  */
21328 #ifdef __cplusplus
21329 extern "C"
21330 #endif
21331 /* We use char because int might match the return type of a gcc2
21332    builtin and then its argument prototype would still apply.  */
21333 char j1f ();
21334 int
21335 main ()
21336 {
21337 j1f ();
21338   ;
21339   return 0;
21340 }
21341 _ACEOF
21342 rm -f conftest.$ac_objext conftest$ac_exeext
21343 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21344   (eval $ac_link) 2>conftest.er1
21345   ac_status=$?
21346   grep -v '^ *+' conftest.er1 >conftest.err
21347   rm -f conftest.er1
21348   cat conftest.err >&5
21349   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21350   (exit $ac_status); } &&
21351          { ac_try='test -z "$ac_c_werror_flag"
21352                          || test ! -s conftest.err'
21353   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21354   (eval $ac_try) 2>&5
21355   ac_status=$?
21356   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21357   (exit $ac_status); }; } &&
21358          { ac_try='test -s conftest$ac_exeext'
21359   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21360   (eval $ac_try) 2>&5
21361   ac_status=$?
21362   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21363   (exit $ac_status); }; }; then
21364   ac_cv_lib_m_j1f=yes
21365 else
21366   echo "$as_me: failed program was:" >&5
21367 sed 's/^/| /' conftest.$ac_ext >&5
21368
21369 ac_cv_lib_m_j1f=no
21370 fi
21371 rm -f conftest.err conftest.$ac_objext \
21372       conftest$ac_exeext conftest.$ac_ext
21373 LIBS=$ac_check_lib_save_LIBS
21374 fi
21375 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1f" >&5
21376 echo "${ECHO_T}$ac_cv_lib_m_j1f" >&6
21377 if test $ac_cv_lib_m_j1f = yes; then
21378
21379 cat >>confdefs.h <<\_ACEOF
21380 #define HAVE_J1F 1
21381 _ACEOF
21382
21383 fi
21384
21385 echo "$as_me:$LINENO: checking for j1 in -lm" >&5
21386 echo $ECHO_N "checking for j1 in -lm... $ECHO_C" >&6
21387 if test "${ac_cv_lib_m_j1+set}" = set; then
21388   echo $ECHO_N "(cached) $ECHO_C" >&6
21389 else
21390   ac_check_lib_save_LIBS=$LIBS
21391 LIBS="-lm  $LIBS"
21392 if test x$gcc_no_link = xyes; then
21393   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21394 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21395    { (exit 1); exit 1; }; }
21396 fi
21397 cat >conftest.$ac_ext <<_ACEOF
21398 /* confdefs.h.  */
21399 _ACEOF
21400 cat confdefs.h >>conftest.$ac_ext
21401 cat >>conftest.$ac_ext <<_ACEOF
21402 /* end confdefs.h.  */
21403
21404 /* Override any gcc2 internal prototype to avoid an error.  */
21405 #ifdef __cplusplus
21406 extern "C"
21407 #endif
21408 /* We use char because int might match the return type of a gcc2
21409    builtin and then its argument prototype would still apply.  */
21410 char j1 ();
21411 int
21412 main ()
21413 {
21414 j1 ();
21415   ;
21416   return 0;
21417 }
21418 _ACEOF
21419 rm -f conftest.$ac_objext conftest$ac_exeext
21420 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21421   (eval $ac_link) 2>conftest.er1
21422   ac_status=$?
21423   grep -v '^ *+' conftest.er1 >conftest.err
21424   rm -f conftest.er1
21425   cat conftest.err >&5
21426   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21427   (exit $ac_status); } &&
21428          { ac_try='test -z "$ac_c_werror_flag"
21429                          || test ! -s conftest.err'
21430   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21431   (eval $ac_try) 2>&5
21432   ac_status=$?
21433   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21434   (exit $ac_status); }; } &&
21435          { ac_try='test -s conftest$ac_exeext'
21436   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21437   (eval $ac_try) 2>&5
21438   ac_status=$?
21439   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21440   (exit $ac_status); }; }; then
21441   ac_cv_lib_m_j1=yes
21442 else
21443   echo "$as_me: failed program was:" >&5
21444 sed 's/^/| /' conftest.$ac_ext >&5
21445
21446 ac_cv_lib_m_j1=no
21447 fi
21448 rm -f conftest.err conftest.$ac_objext \
21449       conftest$ac_exeext conftest.$ac_ext
21450 LIBS=$ac_check_lib_save_LIBS
21451 fi
21452 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1" >&5
21453 echo "${ECHO_T}$ac_cv_lib_m_j1" >&6
21454 if test $ac_cv_lib_m_j1 = yes; then
21455
21456 cat >>confdefs.h <<\_ACEOF
21457 #define HAVE_J1 1
21458 _ACEOF
21459
21460 fi
21461
21462 echo "$as_me:$LINENO: checking for j1l in -lm" >&5
21463 echo $ECHO_N "checking for j1l in -lm... $ECHO_C" >&6
21464 if test "${ac_cv_lib_m_j1l+set}" = set; then
21465   echo $ECHO_N "(cached) $ECHO_C" >&6
21466 else
21467   ac_check_lib_save_LIBS=$LIBS
21468 LIBS="-lm  $LIBS"
21469 if test x$gcc_no_link = xyes; then
21470   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21471 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21472    { (exit 1); exit 1; }; }
21473 fi
21474 cat >conftest.$ac_ext <<_ACEOF
21475 /* confdefs.h.  */
21476 _ACEOF
21477 cat confdefs.h >>conftest.$ac_ext
21478 cat >>conftest.$ac_ext <<_ACEOF
21479 /* end confdefs.h.  */
21480
21481 /* Override any gcc2 internal prototype to avoid an error.  */
21482 #ifdef __cplusplus
21483 extern "C"
21484 #endif
21485 /* We use char because int might match the return type of a gcc2
21486    builtin and then its argument prototype would still apply.  */
21487 char j1l ();
21488 int
21489 main ()
21490 {
21491 j1l ();
21492   ;
21493   return 0;
21494 }
21495 _ACEOF
21496 rm -f conftest.$ac_objext conftest$ac_exeext
21497 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21498   (eval $ac_link) 2>conftest.er1
21499   ac_status=$?
21500   grep -v '^ *+' conftest.er1 >conftest.err
21501   rm -f conftest.er1
21502   cat conftest.err >&5
21503   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21504   (exit $ac_status); } &&
21505          { ac_try='test -z "$ac_c_werror_flag"
21506                          || test ! -s conftest.err'
21507   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21508   (eval $ac_try) 2>&5
21509   ac_status=$?
21510   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21511   (exit $ac_status); }; } &&
21512          { ac_try='test -s conftest$ac_exeext'
21513   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21514   (eval $ac_try) 2>&5
21515   ac_status=$?
21516   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21517   (exit $ac_status); }; }; then
21518   ac_cv_lib_m_j1l=yes
21519 else
21520   echo "$as_me: failed program was:" >&5
21521 sed 's/^/| /' conftest.$ac_ext >&5
21522
21523 ac_cv_lib_m_j1l=no
21524 fi
21525 rm -f conftest.err conftest.$ac_objext \
21526       conftest$ac_exeext conftest.$ac_ext
21527 LIBS=$ac_check_lib_save_LIBS
21528 fi
21529 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1l" >&5
21530 echo "${ECHO_T}$ac_cv_lib_m_j1l" >&6
21531 if test $ac_cv_lib_m_j1l = yes; then
21532
21533 cat >>confdefs.h <<\_ACEOF
21534 #define HAVE_J1L 1
21535 _ACEOF
21536
21537 fi
21538
21539 echo "$as_me:$LINENO: checking for jnf in -lm" >&5
21540 echo $ECHO_N "checking for jnf in -lm... $ECHO_C" >&6
21541 if test "${ac_cv_lib_m_jnf+set}" = set; then
21542   echo $ECHO_N "(cached) $ECHO_C" >&6
21543 else
21544   ac_check_lib_save_LIBS=$LIBS
21545 LIBS="-lm  $LIBS"
21546 if test x$gcc_no_link = xyes; then
21547   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21548 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21549    { (exit 1); exit 1; }; }
21550 fi
21551 cat >conftest.$ac_ext <<_ACEOF
21552 /* confdefs.h.  */
21553 _ACEOF
21554 cat confdefs.h >>conftest.$ac_ext
21555 cat >>conftest.$ac_ext <<_ACEOF
21556 /* end confdefs.h.  */
21557
21558 /* Override any gcc2 internal prototype to avoid an error.  */
21559 #ifdef __cplusplus
21560 extern "C"
21561 #endif
21562 /* We use char because int might match the return type of a gcc2
21563    builtin and then its argument prototype would still apply.  */
21564 char jnf ();
21565 int
21566 main ()
21567 {
21568 jnf ();
21569   ;
21570   return 0;
21571 }
21572 _ACEOF
21573 rm -f conftest.$ac_objext conftest$ac_exeext
21574 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21575   (eval $ac_link) 2>conftest.er1
21576   ac_status=$?
21577   grep -v '^ *+' conftest.er1 >conftest.err
21578   rm -f conftest.er1
21579   cat conftest.err >&5
21580   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21581   (exit $ac_status); } &&
21582          { ac_try='test -z "$ac_c_werror_flag"
21583                          || test ! -s conftest.err'
21584   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21585   (eval $ac_try) 2>&5
21586   ac_status=$?
21587   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21588   (exit $ac_status); }; } &&
21589          { ac_try='test -s conftest$ac_exeext'
21590   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21591   (eval $ac_try) 2>&5
21592   ac_status=$?
21593   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21594   (exit $ac_status); }; }; then
21595   ac_cv_lib_m_jnf=yes
21596 else
21597   echo "$as_me: failed program was:" >&5
21598 sed 's/^/| /' conftest.$ac_ext >&5
21599
21600 ac_cv_lib_m_jnf=no
21601 fi
21602 rm -f conftest.err conftest.$ac_objext \
21603       conftest$ac_exeext conftest.$ac_ext
21604 LIBS=$ac_check_lib_save_LIBS
21605 fi
21606 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jnf" >&5
21607 echo "${ECHO_T}$ac_cv_lib_m_jnf" >&6
21608 if test $ac_cv_lib_m_jnf = yes; then
21609
21610 cat >>confdefs.h <<\_ACEOF
21611 #define HAVE_JNF 1
21612 _ACEOF
21613
21614 fi
21615
21616 echo "$as_me:$LINENO: checking for jn in -lm" >&5
21617 echo $ECHO_N "checking for jn in -lm... $ECHO_C" >&6
21618 if test "${ac_cv_lib_m_jn+set}" = set; then
21619   echo $ECHO_N "(cached) $ECHO_C" >&6
21620 else
21621   ac_check_lib_save_LIBS=$LIBS
21622 LIBS="-lm  $LIBS"
21623 if test x$gcc_no_link = xyes; then
21624   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21625 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21626    { (exit 1); exit 1; }; }
21627 fi
21628 cat >conftest.$ac_ext <<_ACEOF
21629 /* confdefs.h.  */
21630 _ACEOF
21631 cat confdefs.h >>conftest.$ac_ext
21632 cat >>conftest.$ac_ext <<_ACEOF
21633 /* end confdefs.h.  */
21634
21635 /* Override any gcc2 internal prototype to avoid an error.  */
21636 #ifdef __cplusplus
21637 extern "C"
21638 #endif
21639 /* We use char because int might match the return type of a gcc2
21640    builtin and then its argument prototype would still apply.  */
21641 char jn ();
21642 int
21643 main ()
21644 {
21645 jn ();
21646   ;
21647   return 0;
21648 }
21649 _ACEOF
21650 rm -f conftest.$ac_objext conftest$ac_exeext
21651 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21652   (eval $ac_link) 2>conftest.er1
21653   ac_status=$?
21654   grep -v '^ *+' conftest.er1 >conftest.err
21655   rm -f conftest.er1
21656   cat conftest.err >&5
21657   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21658   (exit $ac_status); } &&
21659          { ac_try='test -z "$ac_c_werror_flag"
21660                          || test ! -s conftest.err'
21661   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21662   (eval $ac_try) 2>&5
21663   ac_status=$?
21664   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21665   (exit $ac_status); }; } &&
21666          { ac_try='test -s conftest$ac_exeext'
21667   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21668   (eval $ac_try) 2>&5
21669   ac_status=$?
21670   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21671   (exit $ac_status); }; }; then
21672   ac_cv_lib_m_jn=yes
21673 else
21674   echo "$as_me: failed program was:" >&5
21675 sed 's/^/| /' conftest.$ac_ext >&5
21676
21677 ac_cv_lib_m_jn=no
21678 fi
21679 rm -f conftest.err conftest.$ac_objext \
21680       conftest$ac_exeext conftest.$ac_ext
21681 LIBS=$ac_check_lib_save_LIBS
21682 fi
21683 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jn" >&5
21684 echo "${ECHO_T}$ac_cv_lib_m_jn" >&6
21685 if test $ac_cv_lib_m_jn = yes; then
21686
21687 cat >>confdefs.h <<\_ACEOF
21688 #define HAVE_JN 1
21689 _ACEOF
21690
21691 fi
21692
21693 echo "$as_me:$LINENO: checking for jnl in -lm" >&5
21694 echo $ECHO_N "checking for jnl in -lm... $ECHO_C" >&6
21695 if test "${ac_cv_lib_m_jnl+set}" = set; then
21696   echo $ECHO_N "(cached) $ECHO_C" >&6
21697 else
21698   ac_check_lib_save_LIBS=$LIBS
21699 LIBS="-lm  $LIBS"
21700 if test x$gcc_no_link = xyes; then
21701   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21702 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21703    { (exit 1); exit 1; }; }
21704 fi
21705 cat >conftest.$ac_ext <<_ACEOF
21706 /* confdefs.h.  */
21707 _ACEOF
21708 cat confdefs.h >>conftest.$ac_ext
21709 cat >>conftest.$ac_ext <<_ACEOF
21710 /* end confdefs.h.  */
21711
21712 /* Override any gcc2 internal prototype to avoid an error.  */
21713 #ifdef __cplusplus
21714 extern "C"
21715 #endif
21716 /* We use char because int might match the return type of a gcc2
21717    builtin and then its argument prototype would still apply.  */
21718 char jnl ();
21719 int
21720 main ()
21721 {
21722 jnl ();
21723   ;
21724   return 0;
21725 }
21726 _ACEOF
21727 rm -f conftest.$ac_objext conftest$ac_exeext
21728 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21729   (eval $ac_link) 2>conftest.er1
21730   ac_status=$?
21731   grep -v '^ *+' conftest.er1 >conftest.err
21732   rm -f conftest.er1
21733   cat conftest.err >&5
21734   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21735   (exit $ac_status); } &&
21736          { ac_try='test -z "$ac_c_werror_flag"
21737                          || test ! -s conftest.err'
21738   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21739   (eval $ac_try) 2>&5
21740   ac_status=$?
21741   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21742   (exit $ac_status); }; } &&
21743          { ac_try='test -s conftest$ac_exeext'
21744   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21745   (eval $ac_try) 2>&5
21746   ac_status=$?
21747   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21748   (exit $ac_status); }; }; then
21749   ac_cv_lib_m_jnl=yes
21750 else
21751   echo "$as_me: failed program was:" >&5
21752 sed 's/^/| /' conftest.$ac_ext >&5
21753
21754 ac_cv_lib_m_jnl=no
21755 fi
21756 rm -f conftest.err conftest.$ac_objext \
21757       conftest$ac_exeext conftest.$ac_ext
21758 LIBS=$ac_check_lib_save_LIBS
21759 fi
21760 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jnl" >&5
21761 echo "${ECHO_T}$ac_cv_lib_m_jnl" >&6
21762 if test $ac_cv_lib_m_jnl = yes; then
21763
21764 cat >>confdefs.h <<\_ACEOF
21765 #define HAVE_JNL 1
21766 _ACEOF
21767
21768 fi
21769
21770 echo "$as_me:$LINENO: checking for y0f in -lm" >&5
21771 echo $ECHO_N "checking for y0f in -lm... $ECHO_C" >&6
21772 if test "${ac_cv_lib_m_y0f+set}" = set; then
21773   echo $ECHO_N "(cached) $ECHO_C" >&6
21774 else
21775   ac_check_lib_save_LIBS=$LIBS
21776 LIBS="-lm  $LIBS"
21777 if test x$gcc_no_link = xyes; then
21778   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21779 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21780    { (exit 1); exit 1; }; }
21781 fi
21782 cat >conftest.$ac_ext <<_ACEOF
21783 /* confdefs.h.  */
21784 _ACEOF
21785 cat confdefs.h >>conftest.$ac_ext
21786 cat >>conftest.$ac_ext <<_ACEOF
21787 /* end confdefs.h.  */
21788
21789 /* Override any gcc2 internal prototype to avoid an error.  */
21790 #ifdef __cplusplus
21791 extern "C"
21792 #endif
21793 /* We use char because int might match the return type of a gcc2
21794    builtin and then its argument prototype would still apply.  */
21795 char y0f ();
21796 int
21797 main ()
21798 {
21799 y0f ();
21800   ;
21801   return 0;
21802 }
21803 _ACEOF
21804 rm -f conftest.$ac_objext conftest$ac_exeext
21805 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21806   (eval $ac_link) 2>conftest.er1
21807   ac_status=$?
21808   grep -v '^ *+' conftest.er1 >conftest.err
21809   rm -f conftest.er1
21810   cat conftest.err >&5
21811   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21812   (exit $ac_status); } &&
21813          { ac_try='test -z "$ac_c_werror_flag"
21814                          || test ! -s conftest.err'
21815   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21816   (eval $ac_try) 2>&5
21817   ac_status=$?
21818   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21819   (exit $ac_status); }; } &&
21820          { ac_try='test -s conftest$ac_exeext'
21821   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21822   (eval $ac_try) 2>&5
21823   ac_status=$?
21824   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21825   (exit $ac_status); }; }; then
21826   ac_cv_lib_m_y0f=yes
21827 else
21828   echo "$as_me: failed program was:" >&5
21829 sed 's/^/| /' conftest.$ac_ext >&5
21830
21831 ac_cv_lib_m_y0f=no
21832 fi
21833 rm -f conftest.err conftest.$ac_objext \
21834       conftest$ac_exeext conftest.$ac_ext
21835 LIBS=$ac_check_lib_save_LIBS
21836 fi
21837 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0f" >&5
21838 echo "${ECHO_T}$ac_cv_lib_m_y0f" >&6
21839 if test $ac_cv_lib_m_y0f = yes; then
21840
21841 cat >>confdefs.h <<\_ACEOF
21842 #define HAVE_Y0F 1
21843 _ACEOF
21844
21845 fi
21846
21847 echo "$as_me:$LINENO: checking for y0 in -lm" >&5
21848 echo $ECHO_N "checking for y0 in -lm... $ECHO_C" >&6
21849 if test "${ac_cv_lib_m_y0+set}" = set; then
21850   echo $ECHO_N "(cached) $ECHO_C" >&6
21851 else
21852   ac_check_lib_save_LIBS=$LIBS
21853 LIBS="-lm  $LIBS"
21854 if test x$gcc_no_link = xyes; then
21855   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21856 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21857    { (exit 1); exit 1; }; }
21858 fi
21859 cat >conftest.$ac_ext <<_ACEOF
21860 /* confdefs.h.  */
21861 _ACEOF
21862 cat confdefs.h >>conftest.$ac_ext
21863 cat >>conftest.$ac_ext <<_ACEOF
21864 /* end confdefs.h.  */
21865
21866 /* Override any gcc2 internal prototype to avoid an error.  */
21867 #ifdef __cplusplus
21868 extern "C"
21869 #endif
21870 /* We use char because int might match the return type of a gcc2
21871    builtin and then its argument prototype would still apply.  */
21872 char y0 ();
21873 int
21874 main ()
21875 {
21876 y0 ();
21877   ;
21878   return 0;
21879 }
21880 _ACEOF
21881 rm -f conftest.$ac_objext conftest$ac_exeext
21882 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21883   (eval $ac_link) 2>conftest.er1
21884   ac_status=$?
21885   grep -v '^ *+' conftest.er1 >conftest.err
21886   rm -f conftest.er1
21887   cat conftest.err >&5
21888   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21889   (exit $ac_status); } &&
21890          { ac_try='test -z "$ac_c_werror_flag"
21891                          || test ! -s conftest.err'
21892   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21893   (eval $ac_try) 2>&5
21894   ac_status=$?
21895   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21896   (exit $ac_status); }; } &&
21897          { ac_try='test -s conftest$ac_exeext'
21898   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21899   (eval $ac_try) 2>&5
21900   ac_status=$?
21901   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21902   (exit $ac_status); }; }; then
21903   ac_cv_lib_m_y0=yes
21904 else
21905   echo "$as_me: failed program was:" >&5
21906 sed 's/^/| /' conftest.$ac_ext >&5
21907
21908 ac_cv_lib_m_y0=no
21909 fi
21910 rm -f conftest.err conftest.$ac_objext \
21911       conftest$ac_exeext conftest.$ac_ext
21912 LIBS=$ac_check_lib_save_LIBS
21913 fi
21914 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0" >&5
21915 echo "${ECHO_T}$ac_cv_lib_m_y0" >&6
21916 if test $ac_cv_lib_m_y0 = yes; then
21917
21918 cat >>confdefs.h <<\_ACEOF
21919 #define HAVE_Y0 1
21920 _ACEOF
21921
21922 fi
21923
21924 echo "$as_me:$LINENO: checking for y0l in -lm" >&5
21925 echo $ECHO_N "checking for y0l in -lm... $ECHO_C" >&6
21926 if test "${ac_cv_lib_m_y0l+set}" = set; then
21927   echo $ECHO_N "(cached) $ECHO_C" >&6
21928 else
21929   ac_check_lib_save_LIBS=$LIBS
21930 LIBS="-lm  $LIBS"
21931 if test x$gcc_no_link = xyes; then
21932   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21933 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21934    { (exit 1); exit 1; }; }
21935 fi
21936 cat >conftest.$ac_ext <<_ACEOF
21937 /* confdefs.h.  */
21938 _ACEOF
21939 cat confdefs.h >>conftest.$ac_ext
21940 cat >>conftest.$ac_ext <<_ACEOF
21941 /* end confdefs.h.  */
21942
21943 /* Override any gcc2 internal prototype to avoid an error.  */
21944 #ifdef __cplusplus
21945 extern "C"
21946 #endif
21947 /* We use char because int might match the return type of a gcc2
21948    builtin and then its argument prototype would still apply.  */
21949 char y0l ();
21950 int
21951 main ()
21952 {
21953 y0l ();
21954   ;
21955   return 0;
21956 }
21957 _ACEOF
21958 rm -f conftest.$ac_objext conftest$ac_exeext
21959 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21960   (eval $ac_link) 2>conftest.er1
21961   ac_status=$?
21962   grep -v '^ *+' conftest.er1 >conftest.err
21963   rm -f conftest.er1
21964   cat conftest.err >&5
21965   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21966   (exit $ac_status); } &&
21967          { ac_try='test -z "$ac_c_werror_flag"
21968                          || test ! -s conftest.err'
21969   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21970   (eval $ac_try) 2>&5
21971   ac_status=$?
21972   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21973   (exit $ac_status); }; } &&
21974          { ac_try='test -s conftest$ac_exeext'
21975   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21976   (eval $ac_try) 2>&5
21977   ac_status=$?
21978   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21979   (exit $ac_status); }; }; then
21980   ac_cv_lib_m_y0l=yes
21981 else
21982   echo "$as_me: failed program was:" >&5
21983 sed 's/^/| /' conftest.$ac_ext >&5
21984
21985 ac_cv_lib_m_y0l=no
21986 fi
21987 rm -f conftest.err conftest.$ac_objext \
21988       conftest$ac_exeext conftest.$ac_ext
21989 LIBS=$ac_check_lib_save_LIBS
21990 fi
21991 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0l" >&5
21992 echo "${ECHO_T}$ac_cv_lib_m_y0l" >&6
21993 if test $ac_cv_lib_m_y0l = yes; then
21994
21995 cat >>confdefs.h <<\_ACEOF
21996 #define HAVE_Y0L 1
21997 _ACEOF
21998
21999 fi
22000
22001 echo "$as_me:$LINENO: checking for y1f in -lm" >&5
22002 echo $ECHO_N "checking for y1f in -lm... $ECHO_C" >&6
22003 if test "${ac_cv_lib_m_y1f+set}" = set; then
22004   echo $ECHO_N "(cached) $ECHO_C" >&6
22005 else
22006   ac_check_lib_save_LIBS=$LIBS
22007 LIBS="-lm  $LIBS"
22008 if test x$gcc_no_link = xyes; then
22009   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22010 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22011    { (exit 1); exit 1; }; }
22012 fi
22013 cat >conftest.$ac_ext <<_ACEOF
22014 /* confdefs.h.  */
22015 _ACEOF
22016 cat confdefs.h >>conftest.$ac_ext
22017 cat >>conftest.$ac_ext <<_ACEOF
22018 /* end confdefs.h.  */
22019
22020 /* Override any gcc2 internal prototype to avoid an error.  */
22021 #ifdef __cplusplus
22022 extern "C"
22023 #endif
22024 /* We use char because int might match the return type of a gcc2
22025    builtin and then its argument prototype would still apply.  */
22026 char y1f ();
22027 int
22028 main ()
22029 {
22030 y1f ();
22031   ;
22032   return 0;
22033 }
22034 _ACEOF
22035 rm -f conftest.$ac_objext conftest$ac_exeext
22036 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22037   (eval $ac_link) 2>conftest.er1
22038   ac_status=$?
22039   grep -v '^ *+' conftest.er1 >conftest.err
22040   rm -f conftest.er1
22041   cat conftest.err >&5
22042   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22043   (exit $ac_status); } &&
22044          { ac_try='test -z "$ac_c_werror_flag"
22045                          || test ! -s conftest.err'
22046   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22047   (eval $ac_try) 2>&5
22048   ac_status=$?
22049   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22050   (exit $ac_status); }; } &&
22051          { ac_try='test -s conftest$ac_exeext'
22052   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22053   (eval $ac_try) 2>&5
22054   ac_status=$?
22055   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22056   (exit $ac_status); }; }; then
22057   ac_cv_lib_m_y1f=yes
22058 else
22059   echo "$as_me: failed program was:" >&5
22060 sed 's/^/| /' conftest.$ac_ext >&5
22061
22062 ac_cv_lib_m_y1f=no
22063 fi
22064 rm -f conftest.err conftest.$ac_objext \
22065       conftest$ac_exeext conftest.$ac_ext
22066 LIBS=$ac_check_lib_save_LIBS
22067 fi
22068 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1f" >&5
22069 echo "${ECHO_T}$ac_cv_lib_m_y1f" >&6
22070 if test $ac_cv_lib_m_y1f = yes; then
22071
22072 cat >>confdefs.h <<\_ACEOF
22073 #define HAVE_Y1F 1
22074 _ACEOF
22075
22076 fi
22077
22078 echo "$as_me:$LINENO: checking for y1 in -lm" >&5
22079 echo $ECHO_N "checking for y1 in -lm... $ECHO_C" >&6
22080 if test "${ac_cv_lib_m_y1+set}" = set; then
22081   echo $ECHO_N "(cached) $ECHO_C" >&6
22082 else
22083   ac_check_lib_save_LIBS=$LIBS
22084 LIBS="-lm  $LIBS"
22085 if test x$gcc_no_link = xyes; then
22086   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22087 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22088    { (exit 1); exit 1; }; }
22089 fi
22090 cat >conftest.$ac_ext <<_ACEOF
22091 /* confdefs.h.  */
22092 _ACEOF
22093 cat confdefs.h >>conftest.$ac_ext
22094 cat >>conftest.$ac_ext <<_ACEOF
22095 /* end confdefs.h.  */
22096
22097 /* Override any gcc2 internal prototype to avoid an error.  */
22098 #ifdef __cplusplus
22099 extern "C"
22100 #endif
22101 /* We use char because int might match the return type of a gcc2
22102    builtin and then its argument prototype would still apply.  */
22103 char y1 ();
22104 int
22105 main ()
22106 {
22107 y1 ();
22108   ;
22109   return 0;
22110 }
22111 _ACEOF
22112 rm -f conftest.$ac_objext conftest$ac_exeext
22113 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22114   (eval $ac_link) 2>conftest.er1
22115   ac_status=$?
22116   grep -v '^ *+' conftest.er1 >conftest.err
22117   rm -f conftest.er1
22118   cat conftest.err >&5
22119   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22120   (exit $ac_status); } &&
22121          { ac_try='test -z "$ac_c_werror_flag"
22122                          || test ! -s conftest.err'
22123   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22124   (eval $ac_try) 2>&5
22125   ac_status=$?
22126   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22127   (exit $ac_status); }; } &&
22128          { ac_try='test -s conftest$ac_exeext'
22129   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22130   (eval $ac_try) 2>&5
22131   ac_status=$?
22132   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22133   (exit $ac_status); }; }; then
22134   ac_cv_lib_m_y1=yes
22135 else
22136   echo "$as_me: failed program was:" >&5
22137 sed 's/^/| /' conftest.$ac_ext >&5
22138
22139 ac_cv_lib_m_y1=no
22140 fi
22141 rm -f conftest.err conftest.$ac_objext \
22142       conftest$ac_exeext conftest.$ac_ext
22143 LIBS=$ac_check_lib_save_LIBS
22144 fi
22145 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1" >&5
22146 echo "${ECHO_T}$ac_cv_lib_m_y1" >&6
22147 if test $ac_cv_lib_m_y1 = yes; then
22148
22149 cat >>confdefs.h <<\_ACEOF
22150 #define HAVE_Y1 1
22151 _ACEOF
22152
22153 fi
22154
22155 echo "$as_me:$LINENO: checking for y1l in -lm" >&5
22156 echo $ECHO_N "checking for y1l in -lm... $ECHO_C" >&6
22157 if test "${ac_cv_lib_m_y1l+set}" = set; then
22158   echo $ECHO_N "(cached) $ECHO_C" >&6
22159 else
22160   ac_check_lib_save_LIBS=$LIBS
22161 LIBS="-lm  $LIBS"
22162 if test x$gcc_no_link = xyes; then
22163   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22164 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22165    { (exit 1); exit 1; }; }
22166 fi
22167 cat >conftest.$ac_ext <<_ACEOF
22168 /* confdefs.h.  */
22169 _ACEOF
22170 cat confdefs.h >>conftest.$ac_ext
22171 cat >>conftest.$ac_ext <<_ACEOF
22172 /* end confdefs.h.  */
22173
22174 /* Override any gcc2 internal prototype to avoid an error.  */
22175 #ifdef __cplusplus
22176 extern "C"
22177 #endif
22178 /* We use char because int might match the return type of a gcc2
22179    builtin and then its argument prototype would still apply.  */
22180 char y1l ();
22181 int
22182 main ()
22183 {
22184 y1l ();
22185   ;
22186   return 0;
22187 }
22188 _ACEOF
22189 rm -f conftest.$ac_objext conftest$ac_exeext
22190 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22191   (eval $ac_link) 2>conftest.er1
22192   ac_status=$?
22193   grep -v '^ *+' conftest.er1 >conftest.err
22194   rm -f conftest.er1
22195   cat conftest.err >&5
22196   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22197   (exit $ac_status); } &&
22198          { ac_try='test -z "$ac_c_werror_flag"
22199                          || test ! -s conftest.err'
22200   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22201   (eval $ac_try) 2>&5
22202   ac_status=$?
22203   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22204   (exit $ac_status); }; } &&
22205          { ac_try='test -s conftest$ac_exeext'
22206   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22207   (eval $ac_try) 2>&5
22208   ac_status=$?
22209   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22210   (exit $ac_status); }; }; then
22211   ac_cv_lib_m_y1l=yes
22212 else
22213   echo "$as_me: failed program was:" >&5
22214 sed 's/^/| /' conftest.$ac_ext >&5
22215
22216 ac_cv_lib_m_y1l=no
22217 fi
22218 rm -f conftest.err conftest.$ac_objext \
22219       conftest$ac_exeext conftest.$ac_ext
22220 LIBS=$ac_check_lib_save_LIBS
22221 fi
22222 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1l" >&5
22223 echo "${ECHO_T}$ac_cv_lib_m_y1l" >&6
22224 if test $ac_cv_lib_m_y1l = yes; then
22225
22226 cat >>confdefs.h <<\_ACEOF
22227 #define HAVE_Y1L 1
22228 _ACEOF
22229
22230 fi
22231
22232 echo "$as_me:$LINENO: checking for ynf in -lm" >&5
22233 echo $ECHO_N "checking for ynf in -lm... $ECHO_C" >&6
22234 if test "${ac_cv_lib_m_ynf+set}" = set; then
22235   echo $ECHO_N "(cached) $ECHO_C" >&6
22236 else
22237   ac_check_lib_save_LIBS=$LIBS
22238 LIBS="-lm  $LIBS"
22239 if test x$gcc_no_link = xyes; then
22240   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22241 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22242    { (exit 1); exit 1; }; }
22243 fi
22244 cat >conftest.$ac_ext <<_ACEOF
22245 /* confdefs.h.  */
22246 _ACEOF
22247 cat confdefs.h >>conftest.$ac_ext
22248 cat >>conftest.$ac_ext <<_ACEOF
22249 /* end confdefs.h.  */
22250
22251 /* Override any gcc2 internal prototype to avoid an error.  */
22252 #ifdef __cplusplus
22253 extern "C"
22254 #endif
22255 /* We use char because int might match the return type of a gcc2
22256    builtin and then its argument prototype would still apply.  */
22257 char ynf ();
22258 int
22259 main ()
22260 {
22261 ynf ();
22262   ;
22263   return 0;
22264 }
22265 _ACEOF
22266 rm -f conftest.$ac_objext conftest$ac_exeext
22267 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22268   (eval $ac_link) 2>conftest.er1
22269   ac_status=$?
22270   grep -v '^ *+' conftest.er1 >conftest.err
22271   rm -f conftest.er1
22272   cat conftest.err >&5
22273   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22274   (exit $ac_status); } &&
22275          { ac_try='test -z "$ac_c_werror_flag"
22276                          || test ! -s conftest.err'
22277   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22278   (eval $ac_try) 2>&5
22279   ac_status=$?
22280   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22281   (exit $ac_status); }; } &&
22282          { ac_try='test -s conftest$ac_exeext'
22283   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22284   (eval $ac_try) 2>&5
22285   ac_status=$?
22286   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22287   (exit $ac_status); }; }; then
22288   ac_cv_lib_m_ynf=yes
22289 else
22290   echo "$as_me: failed program was:" >&5
22291 sed 's/^/| /' conftest.$ac_ext >&5
22292
22293 ac_cv_lib_m_ynf=no
22294 fi
22295 rm -f conftest.err conftest.$ac_objext \
22296       conftest$ac_exeext conftest.$ac_ext
22297 LIBS=$ac_check_lib_save_LIBS
22298 fi
22299 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ynf" >&5
22300 echo "${ECHO_T}$ac_cv_lib_m_ynf" >&6
22301 if test $ac_cv_lib_m_ynf = yes; then
22302
22303 cat >>confdefs.h <<\_ACEOF
22304 #define HAVE_YNF 1
22305 _ACEOF
22306
22307 fi
22308
22309 echo "$as_me:$LINENO: checking for yn in -lm" >&5
22310 echo $ECHO_N "checking for yn in -lm... $ECHO_C" >&6
22311 if test "${ac_cv_lib_m_yn+set}" = set; then
22312   echo $ECHO_N "(cached) $ECHO_C" >&6
22313 else
22314   ac_check_lib_save_LIBS=$LIBS
22315 LIBS="-lm  $LIBS"
22316 if test x$gcc_no_link = xyes; then
22317   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22318 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22319    { (exit 1); exit 1; }; }
22320 fi
22321 cat >conftest.$ac_ext <<_ACEOF
22322 /* confdefs.h.  */
22323 _ACEOF
22324 cat confdefs.h >>conftest.$ac_ext
22325 cat >>conftest.$ac_ext <<_ACEOF
22326 /* end confdefs.h.  */
22327
22328 /* Override any gcc2 internal prototype to avoid an error.  */
22329 #ifdef __cplusplus
22330 extern "C"
22331 #endif
22332 /* We use char because int might match the return type of a gcc2
22333    builtin and then its argument prototype would still apply.  */
22334 char yn ();
22335 int
22336 main ()
22337 {
22338 yn ();
22339   ;
22340   return 0;
22341 }
22342 _ACEOF
22343 rm -f conftest.$ac_objext conftest$ac_exeext
22344 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22345   (eval $ac_link) 2>conftest.er1
22346   ac_status=$?
22347   grep -v '^ *+' conftest.er1 >conftest.err
22348   rm -f conftest.er1
22349   cat conftest.err >&5
22350   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22351   (exit $ac_status); } &&
22352          { ac_try='test -z "$ac_c_werror_flag"
22353                          || test ! -s conftest.err'
22354   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22355   (eval $ac_try) 2>&5
22356   ac_status=$?
22357   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22358   (exit $ac_status); }; } &&
22359          { ac_try='test -s conftest$ac_exeext'
22360   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22361   (eval $ac_try) 2>&5
22362   ac_status=$?
22363   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22364   (exit $ac_status); }; }; then
22365   ac_cv_lib_m_yn=yes
22366 else
22367   echo "$as_me: failed program was:" >&5
22368 sed 's/^/| /' conftest.$ac_ext >&5
22369
22370 ac_cv_lib_m_yn=no
22371 fi
22372 rm -f conftest.err conftest.$ac_objext \
22373       conftest$ac_exeext conftest.$ac_ext
22374 LIBS=$ac_check_lib_save_LIBS
22375 fi
22376 echo "$as_me:$LINENO: result: $ac_cv_lib_m_yn" >&5
22377 echo "${ECHO_T}$ac_cv_lib_m_yn" >&6
22378 if test $ac_cv_lib_m_yn = yes; then
22379
22380 cat >>confdefs.h <<\_ACEOF
22381 #define HAVE_YN 1
22382 _ACEOF
22383
22384 fi
22385
22386 echo "$as_me:$LINENO: checking for ynl in -lm" >&5
22387 echo $ECHO_N "checking for ynl in -lm... $ECHO_C" >&6
22388 if test "${ac_cv_lib_m_ynl+set}" = set; then
22389   echo $ECHO_N "(cached) $ECHO_C" >&6
22390 else
22391   ac_check_lib_save_LIBS=$LIBS
22392 LIBS="-lm  $LIBS"
22393 if test x$gcc_no_link = xyes; then
22394   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22395 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22396    { (exit 1); exit 1; }; }
22397 fi
22398 cat >conftest.$ac_ext <<_ACEOF
22399 /* confdefs.h.  */
22400 _ACEOF
22401 cat confdefs.h >>conftest.$ac_ext
22402 cat >>conftest.$ac_ext <<_ACEOF
22403 /* end confdefs.h.  */
22404
22405 /* Override any gcc2 internal prototype to avoid an error.  */
22406 #ifdef __cplusplus
22407 extern "C"
22408 #endif
22409 /* We use char because int might match the return type of a gcc2
22410    builtin and then its argument prototype would still apply.  */
22411 char ynl ();
22412 int
22413 main ()
22414 {
22415 ynl ();
22416   ;
22417   return 0;
22418 }
22419 _ACEOF
22420 rm -f conftest.$ac_objext conftest$ac_exeext
22421 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22422   (eval $ac_link) 2>conftest.er1
22423   ac_status=$?
22424   grep -v '^ *+' conftest.er1 >conftest.err
22425   rm -f conftest.er1
22426   cat conftest.err >&5
22427   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22428   (exit $ac_status); } &&
22429          { ac_try='test -z "$ac_c_werror_flag"
22430                          || test ! -s conftest.err'
22431   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22432   (eval $ac_try) 2>&5
22433   ac_status=$?
22434   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22435   (exit $ac_status); }; } &&
22436          { ac_try='test -s conftest$ac_exeext'
22437   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22438   (eval $ac_try) 2>&5
22439   ac_status=$?
22440   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22441   (exit $ac_status); }; }; then
22442   ac_cv_lib_m_ynl=yes
22443 else
22444   echo "$as_me: failed program was:" >&5
22445 sed 's/^/| /' conftest.$ac_ext >&5
22446
22447 ac_cv_lib_m_ynl=no
22448 fi
22449 rm -f conftest.err conftest.$ac_objext \
22450       conftest$ac_exeext conftest.$ac_ext
22451 LIBS=$ac_check_lib_save_LIBS
22452 fi
22453 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ynl" >&5
22454 echo "${ECHO_T}$ac_cv_lib_m_ynl" >&6
22455 if test $ac_cv_lib_m_ynl = yes; then
22456
22457 cat >>confdefs.h <<\_ACEOF
22458 #define HAVE_YNL 1
22459 _ACEOF
22460
22461 fi
22462
22463
22464 # On AIX, clog is present in libm as __clog
22465 echo "$as_me:$LINENO: checking for __clog in -lm" >&5
22466 echo $ECHO_N "checking for __clog in -lm... $ECHO_C" >&6
22467 if test "${ac_cv_lib_m___clog+set}" = set; then
22468   echo $ECHO_N "(cached) $ECHO_C" >&6
22469 else
22470   ac_check_lib_save_LIBS=$LIBS
22471 LIBS="-lm  $LIBS"
22472 if test x$gcc_no_link = xyes; then
22473   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22474 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22475    { (exit 1); exit 1; }; }
22476 fi
22477 cat >conftest.$ac_ext <<_ACEOF
22478 /* confdefs.h.  */
22479 _ACEOF
22480 cat confdefs.h >>conftest.$ac_ext
22481 cat >>conftest.$ac_ext <<_ACEOF
22482 /* end confdefs.h.  */
22483
22484 /* Override any gcc2 internal prototype to avoid an error.  */
22485 #ifdef __cplusplus
22486 extern "C"
22487 #endif
22488 /* We use char because int might match the return type of a gcc2
22489    builtin and then its argument prototype would still apply.  */
22490 char __clog ();
22491 int
22492 main ()
22493 {
22494 __clog ();
22495   ;
22496   return 0;
22497 }
22498 _ACEOF
22499 rm -f conftest.$ac_objext conftest$ac_exeext
22500 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22501   (eval $ac_link) 2>conftest.er1
22502   ac_status=$?
22503   grep -v '^ *+' conftest.er1 >conftest.err
22504   rm -f conftest.er1
22505   cat conftest.err >&5
22506   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22507   (exit $ac_status); } &&
22508          { ac_try='test -z "$ac_c_werror_flag"
22509                          || test ! -s conftest.err'
22510   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22511   (eval $ac_try) 2>&5
22512   ac_status=$?
22513   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22514   (exit $ac_status); }; } &&
22515          { ac_try='test -s conftest$ac_exeext'
22516   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22517   (eval $ac_try) 2>&5
22518   ac_status=$?
22519   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22520   (exit $ac_status); }; }; then
22521   ac_cv_lib_m___clog=yes
22522 else
22523   echo "$as_me: failed program was:" >&5
22524 sed 's/^/| /' conftest.$ac_ext >&5
22525
22526 ac_cv_lib_m___clog=no
22527 fi
22528 rm -f conftest.err conftest.$ac_objext \
22529       conftest$ac_exeext conftest.$ac_ext
22530 LIBS=$ac_check_lib_save_LIBS
22531 fi
22532 echo "$as_me:$LINENO: result: $ac_cv_lib_m___clog" >&5
22533 echo "${ECHO_T}$ac_cv_lib_m___clog" >&6
22534 if test $ac_cv_lib_m___clog = yes; then
22535
22536 cat >>confdefs.h <<\_ACEOF
22537 #define HAVE_CLOG 1
22538 _ACEOF
22539
22540 fi
22541
22542
22543 # Check for a isfinite macro that works on long doubles.
22544
22545   echo "$as_me:$LINENO: checking whether isfinite is broken" >&5
22546 echo $ECHO_N "checking whether isfinite is broken... $ECHO_C" >&6
22547 if test "${have_broken_isfinite+set}" = set; then
22548   echo $ECHO_N "(cached) $ECHO_C" >&6
22549 else
22550
22551   libgfor_check_for_broken_isfinite_save_LIBS=$LIBS
22552   LIBS="$LIBS -lm"
22553   if test "$cross_compiling" = yes; then
22554
22555 case "${target}" in
22556   hppa*-*-hpux*) have_broken_isfinite=yes ;;
22557   *) have_broken_isfinite=no ;;
22558 esac
22559 else
22560   cat >conftest.$ac_ext <<_ACEOF
22561 /* confdefs.h.  */
22562 _ACEOF
22563 cat confdefs.h >>conftest.$ac_ext
22564 cat >>conftest.$ac_ext <<_ACEOF
22565 /* end confdefs.h.  */
22566
22567 #ifdef HAVE_MATH_H
22568 #include <math.h>
22569 #endif
22570 #include <float.h>
22571 int main ()
22572 {
22573 #ifdef isfinite
22574 #ifdef LDBL_MAX
22575   if (!isfinite(LDBL_MAX)) return 1;
22576 #endif
22577 #ifdef DBL_MAX
22578   if (!isfinite(DBL_MAX)) return 1;
22579 #endif
22580 #endif
22581 return 0;
22582 }
22583 _ACEOF
22584 rm -f conftest$ac_exeext
22585 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22586   (eval $ac_link) 2>&5
22587   ac_status=$?
22588   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22589   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
22590   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22591   (eval $ac_try) 2>&5
22592   ac_status=$?
22593   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22594   (exit $ac_status); }; }; then
22595   have_broken_isfinite=no
22596 else
22597   echo "$as_me: program exited with status $ac_status" >&5
22598 echo "$as_me: failed program was:" >&5
22599 sed 's/^/| /' conftest.$ac_ext >&5
22600
22601 ( exit $ac_status )
22602 have_broken_isfinite=yes
22603 fi
22604 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
22605 fi
22606   LIBS=$libgfor_check_for_broken_isfinite_save_LIBS
22607 fi
22608 echo "$as_me:$LINENO: result: $have_broken_isfinite" >&5
22609 echo "${ECHO_T}$have_broken_isfinite" >&6
22610 if test x"$have_broken_isfinite" = xyes; then
22611
22612 cat >>confdefs.h <<\_ACEOF
22613 #define HAVE_BROKEN_ISFINITE 1
22614 _ACEOF
22615
22616 fi
22617
22618 # Check for a isnan macro that works on long doubles.
22619
22620   echo "$as_me:$LINENO: checking whether isnan is broken" >&5
22621 echo $ECHO_N "checking whether isnan is broken... $ECHO_C" >&6
22622 if test "${have_broken_isnan+set}" = set; then
22623   echo $ECHO_N "(cached) $ECHO_C" >&6
22624 else
22625
22626   libgfor_check_for_broken_isnan_save_LIBS=$LIBS
22627   LIBS="$LIBS -lm"
22628   if test "$cross_compiling" = yes; then
22629
22630 case "${target}" in
22631   hppa*-*-hpux*) have_broken_isnan=yes ;;
22632   *) have_broken_isnan=no ;;
22633 esac
22634 else
22635   cat >conftest.$ac_ext <<_ACEOF
22636 /* confdefs.h.  */
22637 _ACEOF
22638 cat confdefs.h >>conftest.$ac_ext
22639 cat >>conftest.$ac_ext <<_ACEOF
22640 /* end confdefs.h.  */
22641
22642 #ifdef HAVE_MATH_H
22643 #include <math.h>
22644 #endif
22645 #include <float.h>
22646 int main ()
22647 {
22648 #ifdef isnan
22649 #ifdef LDBL_MAX
22650   {
22651     long double x;
22652     x = __builtin_nanl ("");
22653     if (!isnan(x)) return 1;
22654     if (isnan(LDBL_MAX)) return 1;
22655 #ifdef NAN
22656     x = (long double) NAN;
22657     if (!isnan(x)) return 1;
22658 #endif
22659   }
22660 #endif
22661 #ifdef DBL_MAX
22662   {
22663     double y;
22664     y = __builtin_nan ("");
22665     if (!isnan(y)) return 1;
22666     if (isnan(DBL_MAX)) return 1;
22667 #ifdef NAN
22668     y = (double) NAN;
22669     if (!isnan(y)) return 1;
22670 #endif
22671   }
22672 #endif
22673 #endif
22674 return 0;
22675 }
22676 _ACEOF
22677 rm -f conftest$ac_exeext
22678 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22679   (eval $ac_link) 2>&5
22680   ac_status=$?
22681   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22682   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
22683   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22684   (eval $ac_try) 2>&5
22685   ac_status=$?
22686   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22687   (exit $ac_status); }; }; then
22688   have_broken_isnan=no
22689 else
22690   echo "$as_me: program exited with status $ac_status" >&5
22691 echo "$as_me: failed program was:" >&5
22692 sed 's/^/| /' conftest.$ac_ext >&5
22693
22694 ( exit $ac_status )
22695 have_broken_isnan=yes
22696 fi
22697 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
22698 fi
22699   LIBS=$libgfor_check_for_broken_isnan_save_LIBS
22700 fi
22701 echo "$as_me:$LINENO: result: $have_broken_isnan" >&5
22702 echo "${ECHO_T}$have_broken_isnan" >&6
22703 if test x"$have_broken_isnan" = xyes; then
22704
22705 cat >>confdefs.h <<\_ACEOF
22706 #define HAVE_BROKEN_ISNAN 1
22707 _ACEOF
22708
22709 fi
22710
22711 # Check for a fpclassify macro that works on long doubles.
22712
22713   echo "$as_me:$LINENO: checking whether fpclassify is broken" >&5
22714 echo $ECHO_N "checking whether fpclassify is broken... $ECHO_C" >&6
22715 if test "${have_broken_fpclassify+set}" = set; then
22716   echo $ECHO_N "(cached) $ECHO_C" >&6
22717 else
22718
22719   libgfor_check_for_broken_fpclassify_save_LIBS=$LIBS
22720   LIBS="$LIBS -lm"
22721   if test "$cross_compiling" = yes; then
22722
22723 case "${target}" in
22724   hppa*-*-hpux*) have_broken_fpclassify=yes ;;
22725   *) have_broken_fpclassify=no ;;
22726 esac
22727 else
22728   cat >conftest.$ac_ext <<_ACEOF
22729 /* confdefs.h.  */
22730 _ACEOF
22731 cat confdefs.h >>conftest.$ac_ext
22732 cat >>conftest.$ac_ext <<_ACEOF
22733 /* end confdefs.h.  */
22734
22735 #ifdef HAVE_MATH_H
22736 #include <math.h>
22737 #endif
22738 #include <float.h>
22739 int main ()
22740 {
22741 #ifdef fpclassify
22742 #ifdef LDBL_MAX
22743         if (fpclassify(LDBL_MAX) == FP_NAN
22744             || fpclassify(LDBL_MAX) == FP_INFINITE) return 1;
22745 #endif
22746 #ifdef DBL_MAX
22747         if (fpclassify(DBL_MAX) == FP_NAN
22748             || fpclassify(DBL_MAX) == FP_INFINITE) return 1;
22749 #endif
22750 #endif
22751 return 0;
22752 }
22753 _ACEOF
22754 rm -f conftest$ac_exeext
22755 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22756   (eval $ac_link) 2>&5
22757   ac_status=$?
22758   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22759   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
22760   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22761   (eval $ac_try) 2>&5
22762   ac_status=$?
22763   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22764   (exit $ac_status); }; }; then
22765   have_broken_fpclassify=no
22766 else
22767   echo "$as_me: program exited with status $ac_status" >&5
22768 echo "$as_me: failed program was:" >&5
22769 sed 's/^/| /' conftest.$ac_ext >&5
22770
22771 ( exit $ac_status )
22772 have_broken_fpclassify=yes
22773 fi
22774 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
22775 fi
22776   LIBS=$libgfor_check_for_broken_fpclassify_save_LIBS
22777 fi
22778 echo "$as_me:$LINENO: result: $have_broken_fpclassify" >&5
22779 echo "${ECHO_T}$have_broken_fpclassify" >&6
22780 if test x"$have_broken_fpclassify" = xyes; then
22781
22782 cat >>confdefs.h <<\_ACEOF
22783 #define HAVE_BROKEN_FPCLASSIFY 1
22784 _ACEOF
22785
22786 fi
22787
22788 # Check whether the system has a working stat()
22789
22790   echo "$as_me:$LINENO: checking whether the target stat is reliable" >&5
22791 echo $ECHO_N "checking whether the target stat is reliable... $ECHO_C" >&6
22792 if test "${have_working_stat+set}" = set; then
22793   echo $ECHO_N "(cached) $ECHO_C" >&6
22794 else
22795
22796   if test "$cross_compiling" = yes; then
22797
22798 case "${target}" in
22799   *mingw*) have_working_stat=no ;;
22800   *) have_working_stat=yes;;
22801 esac
22802 else
22803   cat >conftest.$ac_ext <<_ACEOF
22804 /* confdefs.h.  */
22805 _ACEOF
22806 cat confdefs.h >>conftest.$ac_ext
22807 cat >>conftest.$ac_ext <<_ACEOF
22808 /* end confdefs.h.  */
22809
22810 #include <stdio.h>
22811 #include <sys/types.h>
22812 #include <sys/stat.h>
22813 #include <unistd.h>
22814
22815 int main ()
22816 {
22817   FILE *f, *g;
22818   struct stat st1, st2;
22819
22820   f = fopen ("foo", "w");
22821   g = fopen ("bar", "w");
22822   if (stat ("foo", &st1) != 0 || stat ("bar", &st2))
22823     return 1;
22824   if (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino)
22825     return 1;
22826   fclose(f);
22827   fclose(g);
22828   return 0;
22829 }
22830 _ACEOF
22831 rm -f conftest$ac_exeext
22832 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22833   (eval $ac_link) 2>&5
22834   ac_status=$?
22835   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22836   (exit $ac_status); } && { ac_try='./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   have_working_stat=yes
22843 else
22844   echo "$as_me: program exited with status $ac_status" >&5
22845 echo "$as_me: failed program was:" >&5
22846 sed 's/^/| /' conftest.$ac_ext >&5
22847
22848 ( exit $ac_status )
22849 have_working_stat=no
22850 fi
22851 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
22852 fi
22853 fi
22854 echo "$as_me:$LINENO: result: $have_working_stat" >&5
22855 echo "${ECHO_T}$have_working_stat" >&6
22856 if test x"$have_working_stat" = xyes; then
22857
22858 cat >>confdefs.h <<\_ACEOF
22859 #define HAVE_WORKING_STAT 1
22860 _ACEOF
22861
22862 fi
22863
22864 # Fallback in case isfinite is not available.
22865 echo "$as_me:$LINENO: checking for finite in -lm" >&5
22866 echo $ECHO_N "checking for finite in -lm... $ECHO_C" >&6
22867 if test "${ac_cv_lib_m_finite+set}" = set; then
22868   echo $ECHO_N "(cached) $ECHO_C" >&6
22869 else
22870   ac_check_lib_save_LIBS=$LIBS
22871 LIBS="-lm  $LIBS"
22872 if test x$gcc_no_link = xyes; then
22873   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22874 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22875    { (exit 1); exit 1; }; }
22876 fi
22877 cat >conftest.$ac_ext <<_ACEOF
22878 /* confdefs.h.  */
22879 _ACEOF
22880 cat confdefs.h >>conftest.$ac_ext
22881 cat >>conftest.$ac_ext <<_ACEOF
22882 /* end confdefs.h.  */
22883
22884 /* Override any gcc2 internal prototype to avoid an error.  */
22885 #ifdef __cplusplus
22886 extern "C"
22887 #endif
22888 /* We use char because int might match the return type of a gcc2
22889    builtin and then its argument prototype would still apply.  */
22890 char finite ();
22891 int
22892 main ()
22893 {
22894 finite ();
22895   ;
22896   return 0;
22897 }
22898 _ACEOF
22899 rm -f conftest.$ac_objext conftest$ac_exeext
22900 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22901   (eval $ac_link) 2>conftest.er1
22902   ac_status=$?
22903   grep -v '^ *+' conftest.er1 >conftest.err
22904   rm -f conftest.er1
22905   cat conftest.err >&5
22906   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22907   (exit $ac_status); } &&
22908          { ac_try='test -z "$ac_c_werror_flag"
22909                          || test ! -s conftest.err'
22910   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22911   (eval $ac_try) 2>&5
22912   ac_status=$?
22913   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22914   (exit $ac_status); }; } &&
22915          { ac_try='test -s conftest$ac_exeext'
22916   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22917   (eval $ac_try) 2>&5
22918   ac_status=$?
22919   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22920   (exit $ac_status); }; }; then
22921   ac_cv_lib_m_finite=yes
22922 else
22923   echo "$as_me: failed program was:" >&5
22924 sed 's/^/| /' conftest.$ac_ext >&5
22925
22926 ac_cv_lib_m_finite=no
22927 fi
22928 rm -f conftest.err conftest.$ac_objext \
22929       conftest$ac_exeext conftest.$ac_ext
22930 LIBS=$ac_check_lib_save_LIBS
22931 fi
22932 echo "$as_me:$LINENO: result: $ac_cv_lib_m_finite" >&5
22933 echo "${ECHO_T}$ac_cv_lib_m_finite" >&6
22934 if test $ac_cv_lib_m_finite = yes; then
22935
22936 cat >>confdefs.h <<\_ACEOF
22937 #define HAVE_FINITE 1
22938 _ACEOF
22939
22940 fi
22941
22942
22943 # Check for GNU libc feenableexcept
22944 echo "$as_me:$LINENO: checking for feenableexcept in -lm" >&5
22945 echo $ECHO_N "checking for feenableexcept in -lm... $ECHO_C" >&6
22946 if test "${ac_cv_lib_m_feenableexcept+set}" = set; then
22947   echo $ECHO_N "(cached) $ECHO_C" >&6
22948 else
22949   ac_check_lib_save_LIBS=$LIBS
22950 LIBS="-lm  $LIBS"
22951 if test x$gcc_no_link = xyes; then
22952   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22953 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22954    { (exit 1); exit 1; }; }
22955 fi
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 /* Override any gcc2 internal prototype to avoid an error.  */
22964 #ifdef __cplusplus
22965 extern "C"
22966 #endif
22967 /* We use char because int might match the return type of a gcc2
22968    builtin and then its argument prototype would still apply.  */
22969 char feenableexcept ();
22970 int
22971 main ()
22972 {
22973 feenableexcept ();
22974   ;
22975   return 0;
22976 }
22977 _ACEOF
22978 rm -f conftest.$ac_objext conftest$ac_exeext
22979 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22980   (eval $ac_link) 2>conftest.er1
22981   ac_status=$?
22982   grep -v '^ *+' conftest.er1 >conftest.err
22983   rm -f conftest.er1
22984   cat conftest.err >&5
22985   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22986   (exit $ac_status); } &&
22987          { ac_try='test -z "$ac_c_werror_flag"
22988                          || test ! -s conftest.err'
22989   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22990   (eval $ac_try) 2>&5
22991   ac_status=$?
22992   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22993   (exit $ac_status); }; } &&
22994          { ac_try='test -s conftest$ac_exeext'
22995   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22996   (eval $ac_try) 2>&5
22997   ac_status=$?
22998   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22999   (exit $ac_status); }; }; then
23000   ac_cv_lib_m_feenableexcept=yes
23001 else
23002   echo "$as_me: failed program was:" >&5
23003 sed 's/^/| /' conftest.$ac_ext >&5
23004
23005 ac_cv_lib_m_feenableexcept=no
23006 fi
23007 rm -f conftest.err conftest.$ac_objext \
23008       conftest$ac_exeext conftest.$ac_ext
23009 LIBS=$ac_check_lib_save_LIBS
23010 fi
23011 echo "$as_me:$LINENO: result: $ac_cv_lib_m_feenableexcept" >&5
23012 echo "${ECHO_T}$ac_cv_lib_m_feenableexcept" >&6
23013 if test $ac_cv_lib_m_feenableexcept = yes; then
23014   have_feenableexcept=yes
23015 cat >>confdefs.h <<\_ACEOF
23016 #define HAVE_FEENABLEEXCEPT 1
23017 _ACEOF
23018
23019 fi
23020
23021
23022 # Check for SysV fpsetmask
23023
23024   echo "$as_me:$LINENO: checking whether fpsetmask is present" >&5
23025 echo $ECHO_N "checking whether fpsetmask is present... $ECHO_C" >&6
23026 if test "${have_fpsetmask+set}" = set; then
23027   echo $ECHO_N "(cached) $ECHO_C" >&6
23028 else
23029
23030     if test x$gcc_no_link = xyes; then
23031   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23032 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23033    { (exit 1); exit 1; }; }
23034 fi
23035 cat >conftest.$ac_ext <<_ACEOF
23036 /* confdefs.h.  */
23037 _ACEOF
23038 cat confdefs.h >>conftest.$ac_ext
23039 cat >>conftest.$ac_ext <<_ACEOF
23040 /* end confdefs.h.  */
23041
23042 #if HAVE_FLOATINGPOINT_H
23043 # include <floatingpoint.h>
23044 #endif /* HAVE_FLOATINGPOINT_H */
23045 #if HAVE_IEEEFP_H
23046 # include <ieeefp.h>
23047 #endif /* HAVE_IEEEFP_H */
23048 int
23049 main ()
23050 {
23051 fpsetmask(0);
23052   ;
23053   return 0;
23054 }
23055 _ACEOF
23056 rm -f conftest.$ac_objext conftest$ac_exeext
23057 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23058   (eval $ac_link) 2>conftest.er1
23059   ac_status=$?
23060   grep -v '^ *+' conftest.er1 >conftest.err
23061   rm -f conftest.er1
23062   cat conftest.err >&5
23063   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23064   (exit $ac_status); } &&
23065          { ac_try='test -z "$ac_c_werror_flag"
23066                          || test ! -s conftest.err'
23067   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23068   (eval $ac_try) 2>&5
23069   ac_status=$?
23070   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23071   (exit $ac_status); }; } &&
23072          { ac_try='test -s conftest$ac_exeext'
23073   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23074   (eval $ac_try) 2>&5
23075   ac_status=$?
23076   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23077   (exit $ac_status); }; }; then
23078   eval "have_fpsetmask=yes"
23079 else
23080   echo "$as_me: failed program was:" >&5
23081 sed 's/^/| /' conftest.$ac_ext >&5
23082
23083 eval "have_fpsetmask=no"
23084 fi
23085 rm -f conftest.err conftest.$ac_objext \
23086       conftest$ac_exeext conftest.$ac_ext
23087
23088 fi
23089 echo "$as_me:$LINENO: result: $have_fpsetmask" >&5
23090 echo "${ECHO_T}$have_fpsetmask" >&6
23091   if test x"$have_fpsetmask" = xyes; then
23092
23093 cat >>confdefs.h <<\_ACEOF
23094 #define HAVE_FPSETMASK 1
23095 _ACEOF
23096
23097   fi
23098
23099
23100 # Check for AIX fp_trap and fp_enable
23101 echo "$as_me:$LINENO: checking for fp_trap" >&5
23102 echo $ECHO_N "checking for fp_trap... $ECHO_C" >&6
23103 if test "${ac_cv_func_fp_trap+set}" = set; then
23104   echo $ECHO_N "(cached) $ECHO_C" >&6
23105 else
23106   if test x$gcc_no_link = xyes; then
23107   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23108 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23109    { (exit 1); exit 1; }; }
23110 fi
23111 cat >conftest.$ac_ext <<_ACEOF
23112 /* confdefs.h.  */
23113 _ACEOF
23114 cat confdefs.h >>conftest.$ac_ext
23115 cat >>conftest.$ac_ext <<_ACEOF
23116 /* end confdefs.h.  */
23117 /* Define fp_trap to an innocuous variant, in case <limits.h> declares fp_trap.
23118    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
23119 #define fp_trap innocuous_fp_trap
23120
23121 /* System header to define __stub macros and hopefully few prototypes,
23122     which can conflict with char fp_trap (); below.
23123     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
23124     <limits.h> exists even on freestanding compilers.  */
23125
23126 #ifdef __STDC__
23127 # include <limits.h>
23128 #else
23129 # include <assert.h>
23130 #endif
23131
23132 #undef fp_trap
23133
23134 /* Override any gcc2 internal prototype to avoid an error.  */
23135 #ifdef __cplusplus
23136 extern "C"
23137 {
23138 #endif
23139 /* We use char because int might match the return type of a gcc2
23140    builtin and then its argument prototype would still apply.  */
23141 char fp_trap ();
23142 /* The GNU C library defines this for functions which it implements
23143     to always fail with ENOSYS.  Some functions are actually named
23144     something starting with __ and the normal name is an alias.  */
23145 #if defined (__stub_fp_trap) || defined (__stub___fp_trap)
23146 choke me
23147 #else
23148 char (*f) () = fp_trap;
23149 #endif
23150 #ifdef __cplusplus
23151 }
23152 #endif
23153
23154 int
23155 main ()
23156 {
23157 return f != fp_trap;
23158   ;
23159   return 0;
23160 }
23161 _ACEOF
23162 rm -f conftest.$ac_objext conftest$ac_exeext
23163 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23164   (eval $ac_link) 2>conftest.er1
23165   ac_status=$?
23166   grep -v '^ *+' conftest.er1 >conftest.err
23167   rm -f conftest.er1
23168   cat conftest.err >&5
23169   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23170   (exit $ac_status); } &&
23171          { ac_try='test -z "$ac_c_werror_flag"
23172                          || test ! -s conftest.err'
23173   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23174   (eval $ac_try) 2>&5
23175   ac_status=$?
23176   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23177   (exit $ac_status); }; } &&
23178          { ac_try='test -s conftest$ac_exeext'
23179   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23180   (eval $ac_try) 2>&5
23181   ac_status=$?
23182   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23183   (exit $ac_status); }; }; then
23184   ac_cv_func_fp_trap=yes
23185 else
23186   echo "$as_me: failed program was:" >&5
23187 sed 's/^/| /' conftest.$ac_ext >&5
23188
23189 ac_cv_func_fp_trap=no
23190 fi
23191 rm -f conftest.err conftest.$ac_objext \
23192       conftest$ac_exeext conftest.$ac_ext
23193 fi
23194 echo "$as_me:$LINENO: result: $ac_cv_func_fp_trap" >&5
23195 echo "${ECHO_T}$ac_cv_func_fp_trap" >&6
23196 if test $ac_cv_func_fp_trap = yes; then
23197   have_fp_trap=yes
23198 cat >>confdefs.h <<\_ACEOF
23199 #define HAVE_FP_TRAP 1
23200 _ACEOF
23201
23202 fi
23203
23204 echo "$as_me:$LINENO: checking for fp_enable" >&5
23205 echo $ECHO_N "checking for fp_enable... $ECHO_C" >&6
23206 if test "${ac_cv_func_fp_enable+set}" = set; then
23207   echo $ECHO_N "(cached) $ECHO_C" >&6
23208 else
23209   if test x$gcc_no_link = xyes; then
23210   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23211 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23212    { (exit 1); exit 1; }; }
23213 fi
23214 cat >conftest.$ac_ext <<_ACEOF
23215 /* confdefs.h.  */
23216 _ACEOF
23217 cat confdefs.h >>conftest.$ac_ext
23218 cat >>conftest.$ac_ext <<_ACEOF
23219 /* end confdefs.h.  */
23220 /* Define fp_enable to an innocuous variant, in case <limits.h> declares fp_enable.
23221    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
23222 #define fp_enable innocuous_fp_enable
23223
23224 /* System header to define __stub macros and hopefully few prototypes,
23225     which can conflict with char fp_enable (); below.
23226     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
23227     <limits.h> exists even on freestanding compilers.  */
23228
23229 #ifdef __STDC__
23230 # include <limits.h>
23231 #else
23232 # include <assert.h>
23233 #endif
23234
23235 #undef fp_enable
23236
23237 /* Override any gcc2 internal prototype to avoid an error.  */
23238 #ifdef __cplusplus
23239 extern "C"
23240 {
23241 #endif
23242 /* We use char because int might match the return type of a gcc2
23243    builtin and then its argument prototype would still apply.  */
23244 char fp_enable ();
23245 /* The GNU C library defines this for functions which it implements
23246     to always fail with ENOSYS.  Some functions are actually named
23247     something starting with __ and the normal name is an alias.  */
23248 #if defined (__stub_fp_enable) || defined (__stub___fp_enable)
23249 choke me
23250 #else
23251 char (*f) () = fp_enable;
23252 #endif
23253 #ifdef __cplusplus
23254 }
23255 #endif
23256
23257 int
23258 main ()
23259 {
23260 return f != fp_enable;
23261   ;
23262   return 0;
23263 }
23264 _ACEOF
23265 rm -f conftest.$ac_objext conftest$ac_exeext
23266 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23267   (eval $ac_link) 2>conftest.er1
23268   ac_status=$?
23269   grep -v '^ *+' conftest.er1 >conftest.err
23270   rm -f conftest.er1
23271   cat conftest.err >&5
23272   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23273   (exit $ac_status); } &&
23274          { ac_try='test -z "$ac_c_werror_flag"
23275                          || test ! -s conftest.err'
23276   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23277   (eval $ac_try) 2>&5
23278   ac_status=$?
23279   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23280   (exit $ac_status); }; } &&
23281          { ac_try='test -s conftest$ac_exeext'
23282   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23283   (eval $ac_try) 2>&5
23284   ac_status=$?
23285   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23286   (exit $ac_status); }; }; then
23287   ac_cv_func_fp_enable=yes
23288 else
23289   echo "$as_me: failed program was:" >&5
23290 sed 's/^/| /' conftest.$ac_ext >&5
23291
23292 ac_cv_func_fp_enable=no
23293 fi
23294 rm -f conftest.err conftest.$ac_objext \
23295       conftest$ac_exeext conftest.$ac_ext
23296 fi
23297 echo "$as_me:$LINENO: result: $ac_cv_func_fp_enable" >&5
23298 echo "${ECHO_T}$ac_cv_func_fp_enable" >&6
23299 if test $ac_cv_func_fp_enable = yes; then
23300   have_fp_enable=yes
23301 cat >>confdefs.h <<\_ACEOF
23302 #define HAVE_FP_ENABLE 1
23303 _ACEOF
23304
23305 fi
23306
23307
23308 # Runs configure.host to set up necessary host-dependent shell variables.
23309 # We then display a message about it, and propagate them through the
23310 # build chain.
23311 . ${srcdir}/configure.host
23312 { echo "$as_me:$LINENO: FPU dependent file will be ${fpu_host}.h" >&5
23313 echo "$as_me: FPU dependent file will be ${fpu_host}.h" >&6;}
23314 FPU_HOST_HEADER=config/${fpu_host}.h
23315
23316
23317 # The standard autoconf HAVE_STRUCT_TIMEZONE doesn't actually check
23318 # for struct timezone, as you might think.  We also need to check how
23319 # to call gettimeofday if we have it.
23320 echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
23321 echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
23322 if test "${ac_cv_header_time+set}" = set; then
23323   echo $ECHO_N "(cached) $ECHO_C" >&6
23324 else
23325   cat >conftest.$ac_ext <<_ACEOF
23326 /* confdefs.h.  */
23327 _ACEOF
23328 cat confdefs.h >>conftest.$ac_ext
23329 cat >>conftest.$ac_ext <<_ACEOF
23330 /* end confdefs.h.  */
23331 #include <sys/types.h>
23332 #include <sys/time.h>
23333 #include <time.h>
23334
23335 int
23336 main ()
23337 {
23338 if ((struct tm *) 0)
23339 return 0;
23340   ;
23341   return 0;
23342 }
23343 _ACEOF
23344 rm -f conftest.$ac_objext
23345 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
23346   (eval $ac_compile) 2>conftest.er1
23347   ac_status=$?
23348   grep -v '^ *+' conftest.er1 >conftest.err
23349   rm -f conftest.er1
23350   cat conftest.err >&5
23351   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23352   (exit $ac_status); } &&
23353          { ac_try='test -z "$ac_c_werror_flag"
23354                          || test ! -s conftest.err'
23355   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23356   (eval $ac_try) 2>&5
23357   ac_status=$?
23358   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23359   (exit $ac_status); }; } &&
23360          { ac_try='test -s conftest.$ac_objext'
23361   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23362   (eval $ac_try) 2>&5
23363   ac_status=$?
23364   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23365   (exit $ac_status); }; }; then
23366   ac_cv_header_time=yes
23367 else
23368   echo "$as_me: failed program was:" >&5
23369 sed 's/^/| /' conftest.$ac_ext >&5
23370
23371 ac_cv_header_time=no
23372 fi
23373 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
23374 fi
23375 echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
23376 echo "${ECHO_T}$ac_cv_header_time" >&6
23377 if test $ac_cv_header_time = yes; then
23378
23379 cat >>confdefs.h <<\_ACEOF
23380 #define TIME_WITH_SYS_TIME 1
23381 _ACEOF
23382
23383 fi
23384
23385
23386
23387 for ac_func in gettimeofday
23388 do
23389 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
23390 echo "$as_me:$LINENO: checking for $ac_func" >&5
23391 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
23392 if eval "test \"\${$as_ac_var+set}\" = set"; then
23393   echo $ECHO_N "(cached) $ECHO_C" >&6
23394 else
23395   if test x$gcc_no_link = xyes; then
23396   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23397 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23398    { (exit 1); exit 1; }; }
23399 fi
23400 cat >conftest.$ac_ext <<_ACEOF
23401 /* confdefs.h.  */
23402 _ACEOF
23403 cat confdefs.h >>conftest.$ac_ext
23404 cat >>conftest.$ac_ext <<_ACEOF
23405 /* end confdefs.h.  */
23406 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
23407    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
23408 #define $ac_func innocuous_$ac_func
23409
23410 /* System header to define __stub macros and hopefully few prototypes,
23411     which can conflict with char $ac_func (); below.
23412     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
23413     <limits.h> exists even on freestanding compilers.  */
23414
23415 #ifdef __STDC__
23416 # include <limits.h>
23417 #else
23418 # include <assert.h>
23419 #endif
23420
23421 #undef $ac_func
23422
23423 /* Override any gcc2 internal prototype to avoid an error.  */
23424 #ifdef __cplusplus
23425 extern "C"
23426 {
23427 #endif
23428 /* We use char because int might match the return type of a gcc2
23429    builtin and then its argument prototype would still apply.  */
23430 char $ac_func ();
23431 /* The GNU C library defines this for functions which it implements
23432     to always fail with ENOSYS.  Some functions are actually named
23433     something starting with __ and the normal name is an alias.  */
23434 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
23435 choke me
23436 #else
23437 char (*f) () = $ac_func;
23438 #endif
23439 #ifdef __cplusplus
23440 }
23441 #endif
23442
23443 int
23444 main ()
23445 {
23446 return f != $ac_func;
23447   ;
23448   return 0;
23449 }
23450 _ACEOF
23451 rm -f conftest.$ac_objext conftest$ac_exeext
23452 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23453   (eval $ac_link) 2>conftest.er1
23454   ac_status=$?
23455   grep -v '^ *+' conftest.er1 >conftest.err
23456   rm -f conftest.er1
23457   cat conftest.err >&5
23458   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23459   (exit $ac_status); } &&
23460          { ac_try='test -z "$ac_c_werror_flag"
23461                          || test ! -s conftest.err'
23462   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23463   (eval $ac_try) 2>&5
23464   ac_status=$?
23465   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23466   (exit $ac_status); }; } &&
23467          { ac_try='test -s conftest$ac_exeext'
23468   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23469   (eval $ac_try) 2>&5
23470   ac_status=$?
23471   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23472   (exit $ac_status); }; }; then
23473   eval "$as_ac_var=yes"
23474 else
23475   echo "$as_me: failed program was:" >&5
23476 sed 's/^/| /' conftest.$ac_ext >&5
23477
23478 eval "$as_ac_var=no"
23479 fi
23480 rm -f conftest.err conftest.$ac_objext \
23481       conftest$ac_exeext conftest.$ac_ext
23482 fi
23483 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
23484 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
23485 if test `eval echo '${'$as_ac_var'}'` = yes; then
23486   cat >>confdefs.h <<_ACEOF
23487 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
23488 _ACEOF
23489
23490 fi
23491 done
23492
23493   if test "$ac_cv_func_gettimeofday" = yes; then
23494     echo "$as_me:$LINENO: checking for struct timezone" >&5
23495 echo $ECHO_N "checking for struct timezone... $ECHO_C" >&6
23496 if test "${gfor_cv_struct_timezone+set}" = set; then
23497   echo $ECHO_N "(cached) $ECHO_C" >&6
23498 else
23499   cat >conftest.$ac_ext <<_ACEOF
23500 /* confdefs.h.  */
23501 _ACEOF
23502 cat confdefs.h >>conftest.$ac_ext
23503 cat >>conftest.$ac_ext <<_ACEOF
23504 /* end confdefs.h.  */
23505 #include <sys/time.h>
23506 int
23507 main ()
23508 {
23509 struct timezone tz;
23510   ;
23511   return 0;
23512 }
23513 _ACEOF
23514 rm -f conftest.$ac_objext
23515 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
23516   (eval $ac_compile) 2>conftest.er1
23517   ac_status=$?
23518   grep -v '^ *+' conftest.er1 >conftest.err
23519   rm -f conftest.er1
23520   cat conftest.err >&5
23521   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23522   (exit $ac_status); } &&
23523          { ac_try='test -z "$ac_c_werror_flag"
23524                          || test ! -s conftest.err'
23525   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23526   (eval $ac_try) 2>&5
23527   ac_status=$?
23528   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23529   (exit $ac_status); }; } &&
23530          { ac_try='test -s conftest.$ac_objext'
23531   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23532   (eval $ac_try) 2>&5
23533   ac_status=$?
23534   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23535   (exit $ac_status); }; }; then
23536   gfor_cv_struct_timezone=yes
23537 else
23538   echo "$as_me: failed program was:" >&5
23539 sed 's/^/| /' conftest.$ac_ext >&5
23540
23541 gfor_cv_struct_timezone=no
23542 fi
23543 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
23544 fi
23545 echo "$as_me:$LINENO: result: $gfor_cv_struct_timezone" >&5
23546 echo "${ECHO_T}$gfor_cv_struct_timezone" >&6
23547     if test $gfor_cv_struct_timezone = yes; then
23548                   if test "$cross_compiling" = yes; then
23549   gfor_have_struct_timezone=yes
23550 else
23551   cat >conftest.$ac_ext <<_ACEOF
23552 /* confdefs.h.  */
23553 _ACEOF
23554 cat confdefs.h >>conftest.$ac_ext
23555 cat >>conftest.$ac_ext <<_ACEOF
23556 /* end confdefs.h.  */
23557
23558 #ifdef TIME_WITH_SYS_TIME
23559 #include <sys/time.h>
23560 #include <time.h>
23561 #else
23562 #ifdef HAVE_SYS_TIME_H
23563 #include <sys/time.h>
23564 #else
23565 #include <time.h>
23566 #endif
23567 #endif
23568 main ()
23569 {
23570   struct timeval time;
23571   struct timezone dummy;
23572   if (gettimeofday (&time, &dummy))
23573     exit (1);
23574   else
23575     exit (0);
23576 }
23577 _ACEOF
23578 rm -f conftest$ac_exeext
23579 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23580   (eval $ac_link) 2>&5
23581   ac_status=$?
23582   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23583   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
23584   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23585   (eval $ac_try) 2>&5
23586   ac_status=$?
23587   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23588   (exit $ac_status); }; }; then
23589   gfor_have_struct_timezone=yes
23590 else
23591   echo "$as_me: program exited with status $ac_status" >&5
23592 echo "$as_me: failed program was:" >&5
23593 sed 's/^/| /' conftest.$ac_ext >&5
23594
23595 ( exit $ac_status )
23596 gfor_have_struct_timezone=no
23597 fi
23598 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23599 fi
23600       if test $gfor_have_struct_timezone = yes; then
23601
23602 cat >>confdefs.h <<\_ACEOF
23603 #define HAVE_TIMEZONE 1
23604 _ACEOF
23605
23606       fi
23607     fi
23608
23609     echo "$as_me:$LINENO: checking whether gettimeofday can accept two arguments" >&5
23610 echo $ECHO_N "checking whether gettimeofday can accept two arguments... $ECHO_C" >&6
23611 if test "${emacs_cv_gettimeofday_two_arguments+set}" = set; then
23612   echo $ECHO_N "(cached) $ECHO_C" >&6
23613 else
23614   if test x$gcc_no_link = xyes; then
23615   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23616 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23617    { (exit 1); exit 1; }; }
23618 fi
23619 cat >conftest.$ac_ext <<_ACEOF
23620 /* confdefs.h.  */
23621 _ACEOF
23622 cat confdefs.h >>conftest.$ac_ext
23623 cat >>conftest.$ac_ext <<_ACEOF
23624 /* end confdefs.h.  */
23625
23626 #ifdef TIME_WITH_SYS_TIME
23627 #include <sys/time.h>
23628 #include <time.h>
23629 #else
23630 #ifdef HAVE_SYS_TIME_H
23631 #include <sys/time.h>
23632 #else
23633 #include <time.h>
23634 #endif
23635 #endif
23636
23637 int
23638 main ()
23639 {
23640
23641       struct timeval time;
23642 #ifdef HAVE_TIMEZONE
23643       struct timezone dummy;
23644 #define DUMMY &dummy
23645 #else
23646 #define DUMMY NULL
23647 #endif
23648       gettimeofday (&time, DUMMY);
23649   ;
23650   return 0;
23651 }
23652 _ACEOF
23653 rm -f conftest.$ac_objext conftest$ac_exeext
23654 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23655   (eval $ac_link) 2>conftest.er1
23656   ac_status=$?
23657   grep -v '^ *+' conftest.er1 >conftest.err
23658   rm -f conftest.er1
23659   cat conftest.err >&5
23660   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23661   (exit $ac_status); } &&
23662          { ac_try='test -z "$ac_c_werror_flag"
23663                          || test ! -s conftest.err'
23664   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23665   (eval $ac_try) 2>&5
23666   ac_status=$?
23667   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23668   (exit $ac_status); }; } &&
23669          { ac_try='test -s conftest$ac_exeext'
23670   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23671   (eval $ac_try) 2>&5
23672   ac_status=$?
23673   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23674   (exit $ac_status); }; }; then
23675   emacs_cv_gettimeofday_two_arguments=yes
23676 else
23677   echo "$as_me: failed program was:" >&5
23678 sed 's/^/| /' conftest.$ac_ext >&5
23679
23680 emacs_cv_gettimeofday_two_arguments=no
23681 fi
23682 rm -f conftest.err conftest.$ac_objext \
23683       conftest$ac_exeext conftest.$ac_ext
23684 fi
23685 echo "$as_me:$LINENO: result: $emacs_cv_gettimeofday_two_arguments" >&5
23686 echo "${ECHO_T}$emacs_cv_gettimeofday_two_arguments" >&6
23687     if test $emacs_cv_gettimeofday_two_arguments = no; then
23688
23689 cat >>confdefs.h <<\_ACEOF
23690 #define GETTIMEOFDAY_ONE_ARGUMENT 1
23691 _ACEOF
23692
23693     fi
23694   fi
23695
23696 # Attempt to assert that the target is of common type in case we don't
23697 # have C99 integer types at all.
23698
23699   echo "$as_me:$LINENO: checking whether the target is ILP32" >&5
23700 echo $ECHO_N "checking whether the target is ILP32... $ECHO_C" >&6
23701 if test "${target_ilp32+set}" = set; then
23702   echo $ECHO_N "(cached) $ECHO_C" >&6
23703 else
23704
23705   save_CFLAGS="$CFLAGS"
23706   CFLAGS="-O2"
23707   if test x$gcc_no_link = xyes; then
23708   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23709 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23710    { (exit 1); exit 1; }; }
23711 fi
23712 cat >conftest.$ac_ext <<_ACEOF
23713 /* confdefs.h.  */
23714 _ACEOF
23715 cat confdefs.h >>conftest.$ac_ext
23716 cat >>conftest.$ac_ext <<_ACEOF
23717 /* end confdefs.h.  */
23718
23719 int
23720 main ()
23721 {
23722
23723 if (sizeof(int) == 4 && sizeof(long) == 4 && sizeof(void *) == 4)
23724   ;
23725 else
23726   undefined_function ();
23727
23728   ;
23729   return 0;
23730 }
23731 _ACEOF
23732 rm -f conftest.$ac_objext conftest$ac_exeext
23733 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23734   (eval $ac_link) 2>conftest.er1
23735   ac_status=$?
23736   grep -v '^ *+' conftest.er1 >conftest.err
23737   rm -f conftest.er1
23738   cat conftest.err >&5
23739   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23740   (exit $ac_status); } &&
23741          { ac_try='test -z "$ac_c_werror_flag"
23742                          || test ! -s conftest.err'
23743   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23744   (eval $ac_try) 2>&5
23745   ac_status=$?
23746   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23747   (exit $ac_status); }; } &&
23748          { ac_try='test -s conftest$ac_exeext'
23749   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23750   (eval $ac_try) 2>&5
23751   ac_status=$?
23752   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23753   (exit $ac_status); }; }; then
23754   target_ilp32=yes
23755 else
23756   echo "$as_me: failed program was:" >&5
23757 sed 's/^/| /' conftest.$ac_ext >&5
23758
23759 target_ilp32=no
23760 fi
23761 rm -f conftest.err conftest.$ac_objext \
23762       conftest$ac_exeext conftest.$ac_ext
23763   CFLAGS="$save_CFLAGS"
23764 fi
23765 echo "$as_me:$LINENO: result: $target_ilp32" >&5
23766 echo "${ECHO_T}$target_ilp32" >&6
23767   if test $target_ilp32 = yes; then
23768
23769 cat >>confdefs.h <<\_ACEOF
23770 #define TARGET_ILP32 1
23771 _ACEOF
23772
23773   fi
23774
23775
23776 # Check out attribute support.
23777
23778   echo "$as_me:$LINENO: checking whether the target supports hidden visibility" >&5
23779 echo $ECHO_N "checking whether the target supports hidden visibility... $ECHO_C" >&6
23780 if test "${have_attribute_visibility+set}" = set; then
23781   echo $ECHO_N "(cached) $ECHO_C" >&6
23782 else
23783
23784   save_CFLAGS="$CFLAGS"
23785   CFLAGS="$CFLAGS -Werror"
23786   cat >conftest.$ac_ext <<_ACEOF
23787 /* confdefs.h.  */
23788 _ACEOF
23789 cat confdefs.h >>conftest.$ac_ext
23790 cat >>conftest.$ac_ext <<_ACEOF
23791 /* end confdefs.h.  */
23792 void __attribute__((visibility("hidden"))) foo(void) { }
23793 int
23794 main ()
23795 {
23796
23797   ;
23798   return 0;
23799 }
23800 _ACEOF
23801 rm -f conftest.$ac_objext
23802 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
23803   (eval $ac_compile) 2>conftest.er1
23804   ac_status=$?
23805   grep -v '^ *+' conftest.er1 >conftest.err
23806   rm -f conftest.er1
23807   cat conftest.err >&5
23808   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23809   (exit $ac_status); } &&
23810          { ac_try='test -z "$ac_c_werror_flag"
23811                          || test ! -s conftest.err'
23812   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23813   (eval $ac_try) 2>&5
23814   ac_status=$?
23815   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23816   (exit $ac_status); }; } &&
23817          { ac_try='test -s conftest.$ac_objext'
23818   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23819   (eval $ac_try) 2>&5
23820   ac_status=$?
23821   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23822   (exit $ac_status); }; }; then
23823   have_attribute_visibility=yes
23824 else
23825   echo "$as_me: failed program was:" >&5
23826 sed 's/^/| /' conftest.$ac_ext >&5
23827
23828 have_attribute_visibility=no
23829 fi
23830 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
23831   CFLAGS="$save_CFLAGS"
23832 fi
23833 echo "$as_me:$LINENO: result: $have_attribute_visibility" >&5
23834 echo "${ECHO_T}$have_attribute_visibility" >&6
23835   if test $have_attribute_visibility = yes; then
23836
23837 cat >>confdefs.h <<\_ACEOF
23838 #define HAVE_ATTRIBUTE_VISIBILITY 1
23839 _ACEOF
23840
23841   fi
23842
23843   echo "$as_me:$LINENO: checking whether the target supports dllexport" >&5
23844 echo $ECHO_N "checking whether the target supports dllexport... $ECHO_C" >&6
23845 if test "${have_attribute_dllexport+set}" = set; then
23846   echo $ECHO_N "(cached) $ECHO_C" >&6
23847 else
23848
23849   save_CFLAGS="$CFLAGS"
23850   CFLAGS="$CFLAGS -Werror"
23851   cat >conftest.$ac_ext <<_ACEOF
23852 /* confdefs.h.  */
23853 _ACEOF
23854 cat confdefs.h >>conftest.$ac_ext
23855 cat >>conftest.$ac_ext <<_ACEOF
23856 /* end confdefs.h.  */
23857 void __attribute__((dllexport)) foo(void) { }
23858 int
23859 main ()
23860 {
23861
23862   ;
23863   return 0;
23864 }
23865 _ACEOF
23866 rm -f conftest.$ac_objext
23867 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
23868   (eval $ac_compile) 2>conftest.er1
23869   ac_status=$?
23870   grep -v '^ *+' conftest.er1 >conftest.err
23871   rm -f conftest.er1
23872   cat conftest.err >&5
23873   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23874   (exit $ac_status); } &&
23875          { ac_try='test -z "$ac_c_werror_flag"
23876                          || test ! -s conftest.err'
23877   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23878   (eval $ac_try) 2>&5
23879   ac_status=$?
23880   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23881   (exit $ac_status); }; } &&
23882          { ac_try='test -s conftest.$ac_objext'
23883   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23884   (eval $ac_try) 2>&5
23885   ac_status=$?
23886   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23887   (exit $ac_status); }; }; then
23888   have_attribute_dllexport=yes
23889 else
23890   echo "$as_me: failed program was:" >&5
23891 sed 's/^/| /' conftest.$ac_ext >&5
23892
23893 have_attribute_dllexport=no
23894 fi
23895 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
23896   CFLAGS="$save_CFLAGS"
23897 fi
23898 echo "$as_me:$LINENO: result: $have_attribute_dllexport" >&5
23899 echo "${ECHO_T}$have_attribute_dllexport" >&6
23900   if test $have_attribute_dllexport = yes; then
23901
23902 cat >>confdefs.h <<\_ACEOF
23903 #define HAVE_ATTRIBUTE_DLLEXPORT 1
23904 _ACEOF
23905
23906   fi
23907
23908   echo "$as_me:$LINENO: checking whether the target supports symbol aliases" >&5
23909 echo $ECHO_N "checking whether the target supports symbol aliases... $ECHO_C" >&6
23910 if test "${have_attribute_alias+set}" = set; then
23911   echo $ECHO_N "(cached) $ECHO_C" >&6
23912 else
23913
23914   if test x$gcc_no_link = xyes; then
23915   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23916 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23917    { (exit 1); exit 1; }; }
23918 fi
23919 cat >conftest.$ac_ext <<_ACEOF
23920 /* confdefs.h.  */
23921 _ACEOF
23922 cat confdefs.h >>conftest.$ac_ext
23923 cat >>conftest.$ac_ext <<_ACEOF
23924 /* end confdefs.h.  */
23925
23926 void foo(void) { }
23927 extern void bar(void) __attribute__((alias("foo")));
23928 int
23929 main ()
23930 {
23931 bar();
23932   ;
23933   return 0;
23934 }
23935 _ACEOF
23936 rm -f conftest.$ac_objext conftest$ac_exeext
23937 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23938   (eval $ac_link) 2>conftest.er1
23939   ac_status=$?
23940   grep -v '^ *+' conftest.er1 >conftest.err
23941   rm -f conftest.er1
23942   cat conftest.err >&5
23943   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23944   (exit $ac_status); } &&
23945          { ac_try='test -z "$ac_c_werror_flag"
23946                          || test ! -s conftest.err'
23947   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23948   (eval $ac_try) 2>&5
23949   ac_status=$?
23950   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23951   (exit $ac_status); }; } &&
23952          { ac_try='test -s conftest$ac_exeext'
23953   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23954   (eval $ac_try) 2>&5
23955   ac_status=$?
23956   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23957   (exit $ac_status); }; }; then
23958   have_attribute_alias=yes
23959 else
23960   echo "$as_me: failed program was:" >&5
23961 sed 's/^/| /' conftest.$ac_ext >&5
23962
23963 have_attribute_alias=no
23964 fi
23965 rm -f conftest.err conftest.$ac_objext \
23966       conftest$ac_exeext conftest.$ac_ext
23967 fi
23968 echo "$as_me:$LINENO: result: $have_attribute_alias" >&5
23969 echo "${ECHO_T}$have_attribute_alias" >&6
23970   if test $have_attribute_alias = yes; then
23971
23972 cat >>confdefs.h <<\_ACEOF
23973 #define HAVE_ATTRIBUTE_ALIAS 1
23974 _ACEOF
23975
23976   fi
23977
23978 # Check out sync builtins support.
23979
23980   echo "$as_me:$LINENO: checking whether the target supports __sync_fetch_and_add" >&5
23981 echo $ECHO_N "checking whether the target supports __sync_fetch_and_add... $ECHO_C" >&6
23982 if test "${have_sync_fetch_and_add+set}" = set; then
23983   echo $ECHO_N "(cached) $ECHO_C" >&6
23984 else
23985
23986   if test x$gcc_no_link = xyes; then
23987   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23988 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23989    { (exit 1); exit 1; }; }
23990 fi
23991 cat >conftest.$ac_ext <<_ACEOF
23992 /* confdefs.h.  */
23993 _ACEOF
23994 cat confdefs.h >>conftest.$ac_ext
23995 cat >>conftest.$ac_ext <<_ACEOF
23996 /* end confdefs.h.  */
23997 int foovar = 0;
23998 int
23999 main ()
24000 {
24001
24002 if (foovar <= 0) return __sync_fetch_and_add (&foovar, 1);
24003 if (foovar > 10) return __sync_add_and_fetch (&foovar, -1);
24004   ;
24005   return 0;
24006 }
24007 _ACEOF
24008 rm -f conftest.$ac_objext conftest$ac_exeext
24009 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
24010   (eval $ac_link) 2>conftest.er1
24011   ac_status=$?
24012   grep -v '^ *+' conftest.er1 >conftest.err
24013   rm -f conftest.er1
24014   cat conftest.err >&5
24015   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24016   (exit $ac_status); } &&
24017          { ac_try='test -z "$ac_c_werror_flag"
24018                          || test ! -s conftest.err'
24019   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24020   (eval $ac_try) 2>&5
24021   ac_status=$?
24022   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24023   (exit $ac_status); }; } &&
24024          { ac_try='test -s conftest$ac_exeext'
24025   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24026   (eval $ac_try) 2>&5
24027   ac_status=$?
24028   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24029   (exit $ac_status); }; }; then
24030   have_sync_fetch_and_add=yes
24031 else
24032   echo "$as_me: failed program was:" >&5
24033 sed 's/^/| /' conftest.$ac_ext >&5
24034
24035 have_sync_fetch_and_add=no
24036 fi
24037 rm -f conftest.err conftest.$ac_objext \
24038       conftest$ac_exeext conftest.$ac_ext
24039 fi
24040 echo "$as_me:$LINENO: result: $have_sync_fetch_and_add" >&5
24041 echo "${ECHO_T}$have_sync_fetch_and_add" >&6
24042   if test $have_sync_fetch_and_add = yes; then
24043
24044 cat >>confdefs.h <<\_ACEOF
24045 #define HAVE_SYNC_FETCH_AND_ADD 1
24046 _ACEOF
24047
24048   fi
24049
24050 # Check out thread support.
24051
24052   echo "$as_me:$LINENO: checking configured target thread model" >&5
24053 echo $ECHO_N "checking configured target thread model... $ECHO_C" >&6
24054 if test "${target_thread_file+set}" = set; then
24055   echo $ECHO_N "(cached) $ECHO_C" >&6
24056 else
24057
24058 target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`
24059 fi
24060 echo "$as_me:$LINENO: result: $target_thread_file" >&5
24061 echo "${ECHO_T}$target_thread_file" >&6
24062
24063   if test $target_thread_file != single; then
24064
24065 cat >>confdefs.h <<\_ACEOF
24066 #define HAVE_GTHR_DEFAULT 1
24067 _ACEOF
24068
24069   fi
24070
24071 # Check out #pragma weak.
24072
24073   echo "$as_me:$LINENO: checking whether pragma weak works" >&5
24074 echo $ECHO_N "checking whether pragma weak works... $ECHO_C" >&6
24075 if test "${have_pragma_weak+set}" = set; then
24076   echo $ECHO_N "(cached) $ECHO_C" >&6
24077 else
24078
24079   gfor_save_CFLAGS="$CFLAGS"
24080   CFLAGS="$CFLAGS -Wunknown-pragmas"
24081   cat >conftest.$ac_ext <<_ACEOF
24082 /* confdefs.h.  */
24083 _ACEOF
24084 cat confdefs.h >>conftest.$ac_ext
24085 cat >>conftest.$ac_ext <<_ACEOF
24086 /* end confdefs.h.  */
24087 void foo (void);
24088 #pragma weak foo
24089 int
24090 main ()
24091 {
24092 if (foo) foo ();
24093   ;
24094   return 0;
24095 }
24096 _ACEOF
24097 rm -f conftest.$ac_objext
24098 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
24099   (eval $ac_compile) 2>conftest.er1
24100   ac_status=$?
24101   grep -v '^ *+' conftest.er1 >conftest.err
24102   rm -f conftest.er1
24103   cat conftest.err >&5
24104   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24105   (exit $ac_status); } &&
24106          { ac_try='test -z "$ac_c_werror_flag"
24107                          || test ! -s conftest.err'
24108   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24109   (eval $ac_try) 2>&5
24110   ac_status=$?
24111   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24112   (exit $ac_status); }; } &&
24113          { ac_try='test -s conftest.$ac_objext'
24114   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24115   (eval $ac_try) 2>&5
24116   ac_status=$?
24117   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24118   (exit $ac_status); }; }; then
24119   have_pragma_weak=yes
24120 else
24121   echo "$as_me: failed program was:" >&5
24122 sed 's/^/| /' conftest.$ac_ext >&5
24123
24124 have_pragma_weak=no
24125 fi
24126 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
24127 fi
24128 echo "$as_me:$LINENO: result: $have_pragma_weak" >&5
24129 echo "${ECHO_T}$have_pragma_weak" >&6
24130   if test $have_pragma_weak = yes; then
24131
24132 cat >>confdefs.h <<\_ACEOF
24133 #define SUPPORTS_WEAK 1
24134 _ACEOF
24135
24136   fi
24137   case "$host" in
24138     *-*-darwin* | *-*-hpux* | *-*-cygwin*)
24139
24140 cat >>confdefs.h <<\_ACEOF
24141 #define GTHREAD_USE_WEAK 0
24142 _ACEOF
24143
24144       ;;
24145   esac
24146
24147 # Various other checks on target
24148
24149   echo "$as_me:$LINENO: checking whether the target can unlink an open file" >&5
24150 echo $ECHO_N "checking whether the target can unlink an open file... $ECHO_C" >&6
24151 if test "${have_unlink_open_file+set}" = set; then
24152   echo $ECHO_N "(cached) $ECHO_C" >&6
24153 else
24154
24155   if test "$cross_compiling" = yes; then
24156
24157 case "${target}" in
24158   *mingw*) have_unlink_open_file=no ;;
24159   *) have_unlink_open_file=yes;;
24160 esac
24161 else
24162   cat >conftest.$ac_ext <<_ACEOF
24163 /* confdefs.h.  */
24164 _ACEOF
24165 cat confdefs.h >>conftest.$ac_ext
24166 cat >>conftest.$ac_ext <<_ACEOF
24167 /* end confdefs.h.  */
24168
24169 #include <errno.h>
24170 #include <fcntl.h>
24171 #include <unistd.h>
24172 #include <sys/stat.h>
24173
24174 int main ()
24175 {
24176   int fd;
24177
24178   fd = open ("testfile", O_RDWR | O_CREAT, S_IWRITE | S_IREAD);
24179   if (fd <= 0)
24180     return 0;
24181   if (unlink ("testfile") == -1)
24182     return 1;
24183   write (fd, "This is a test\n", 15);
24184   close (fd);
24185
24186   if (open ("testfile", O_RDONLY, S_IWRITE | S_IREAD) == -1 && errno == ENOENT)
24187     return 0;
24188   else
24189     return 1;
24190 }
24191 _ACEOF
24192 rm -f conftest$ac_exeext
24193 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
24194   (eval $ac_link) 2>&5
24195   ac_status=$?
24196   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24197   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
24198   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24199   (eval $ac_try) 2>&5
24200   ac_status=$?
24201   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24202   (exit $ac_status); }; }; then
24203   have_unlink_open_file=yes
24204 else
24205   echo "$as_me: program exited with status $ac_status" >&5
24206 echo "$as_me: failed program was:" >&5
24207 sed 's/^/| /' conftest.$ac_ext >&5
24208
24209 ( exit $ac_status )
24210 have_unlink_open_file=no
24211 fi
24212 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
24213 fi
24214 fi
24215 echo "$as_me:$LINENO: result: $have_unlink_open_file" >&5
24216 echo "${ECHO_T}$have_unlink_open_file" >&6
24217 if test x"$have_unlink_open_file" = xyes; then
24218
24219 cat >>confdefs.h <<\_ACEOF
24220 #define HAVE_UNLINK_OPEN_FILE 1
24221 _ACEOF
24222
24223 fi
24224
24225 # Check whether line terminator is LF or CRLF
24226
24227   echo "$as_me:$LINENO: checking whether the target has CRLF as line terminator" >&5
24228 echo $ECHO_N "checking whether the target has CRLF as line terminator... $ECHO_C" >&6
24229 if test "${have_crlf+set}" = set; then
24230   echo $ECHO_N "(cached) $ECHO_C" >&6
24231 else
24232
24233   if test "$cross_compiling" = yes; then
24234
24235 case "${target}" in
24236   *mingw*) have_crlf=yes ;;
24237   *) have_crlf=no;;
24238 esac
24239 else
24240   cat >conftest.$ac_ext <<_ACEOF
24241 /* confdefs.h.  */
24242 _ACEOF
24243 cat confdefs.h >>conftest.$ac_ext
24244 cat >>conftest.$ac_ext <<_ACEOF
24245 /* end confdefs.h.  */
24246
24247 /* This test program should exit with status 0 if system uses a CRLF as
24248    line terminator, and status 1 otherwise.
24249    Since it is used to check for mingw systems, and should return 0 in any
24250    other case, in case of a failure we will not use CRLF.  */
24251 #include <sys/stat.h>
24252 #include <stdlib.h>
24253 #include <fcntl.h>
24254 #include <stdio.h>
24255
24256 int main ()
24257 {
24258 #ifndef O_BINARY
24259   exit(1);
24260 #else
24261   int fd, bytes;
24262   char buff[5];
24263
24264   fd = open ("foo", O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
24265   if (fd < 0)
24266     exit(1);
24267   if (write (fd, "\n", 1) < 0)
24268     perror ("write");
24269
24270   close (fd);
24271
24272   if ((fd = open ("foo", O_RDONLY | O_BINARY, S_IRWXU)) < 0)
24273     exit(1);
24274   bytes = read (fd, buff, 5);
24275   if (bytes == 2 && buff[0] == '\r' && buff[1] == '\n')
24276     exit(0);
24277   else
24278     exit(1);
24279 #endif
24280 }
24281 _ACEOF
24282 rm -f conftest$ac_exeext
24283 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
24284   (eval $ac_link) 2>&5
24285   ac_status=$?
24286   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24287   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
24288   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24289   (eval $ac_try) 2>&5
24290   ac_status=$?
24291   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24292   (exit $ac_status); }; }; then
24293   have_crlf=yes
24294 else
24295   echo "$as_me: program exited with status $ac_status" >&5
24296 echo "$as_me: failed program was:" >&5
24297 sed 's/^/| /' conftest.$ac_ext >&5
24298
24299 ( exit $ac_status )
24300 have_crlf=no
24301 fi
24302 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
24303 fi
24304 fi
24305 echo "$as_me:$LINENO: result: $have_crlf" >&5
24306 echo "${ECHO_T}$have_crlf" >&6
24307 if test x"$have_crlf" = xyes; then
24308
24309 cat >>confdefs.h <<\_ACEOF
24310 #define HAVE_CRLF 1
24311 _ACEOF
24312
24313 fi
24314
24315 cat >confcache <<\_ACEOF
24316 # This file is a shell script that caches the results of configure
24317 # tests run on this system so they can be shared between configure
24318 # scripts and configure runs, see configure's option --config-cache.
24319 # It is not useful on other systems.  If it contains results you don't
24320 # want to keep, you may remove or edit it.
24321 #
24322 # config.status only pays attention to the cache file if you give it
24323 # the --recheck option to rerun configure.
24324 #
24325 # `ac_cv_env_foo' variables (set or unset) will be overridden when
24326 # loading this file, other *unset* `ac_cv_foo' will be assigned the
24327 # following values.
24328
24329 _ACEOF
24330
24331 # The following way of writing the cache mishandles newlines in values,
24332 # but we know of no workaround that is simple, portable, and efficient.
24333 # So, don't put newlines in cache variables' values.
24334 # Ultrix sh set writes to stderr and can't be redirected directly,
24335 # and sets the high bit in the cache file unless we assign to the vars.
24336 {
24337   (set) 2>&1 |
24338     case `(ac_space=' '; set | grep ac_space) 2>&1` in
24339     *ac_space=\ *)
24340       # `set' does not quote correctly, so add quotes (double-quote
24341       # substitution turns \\\\ into \\, and sed turns \\ into \).
24342       sed -n \
24343         "s/'/'\\\\''/g;
24344           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
24345       ;;
24346     *)
24347       # `set' quotes correctly as required by POSIX, so do not add quotes.
24348       sed -n \
24349         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
24350       ;;
24351     esac;
24352 } |
24353   sed '
24354      t clear
24355      : clear
24356      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
24357      t end
24358      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
24359      : end' >>confcache
24360 if diff $cache_file confcache >/dev/null 2>&1; then :; else
24361   if test -w $cache_file; then
24362     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
24363     cat confcache >$cache_file
24364   else
24365     echo "not updating unwritable cache $cache_file"
24366   fi
24367 fi
24368 rm -f confcache
24369
24370 if test ${multilib} = yes; then
24371   multilib_arg="--enable-multilib"
24372 else
24373   multilib_arg=
24374 fi
24375
24376 # Write our Makefile.
24377           ac_config_files="$ac_config_files Makefile"
24378
24379 cat >confcache <<\_ACEOF
24380 # This file is a shell script that caches the results of configure
24381 # tests run on this system so they can be shared between configure
24382 # scripts and configure runs, see configure's option --config-cache.
24383 # It is not useful on other systems.  If it contains results you don't
24384 # want to keep, you may remove or edit it.
24385 #
24386 # config.status only pays attention to the cache file if you give it
24387 # the --recheck option to rerun configure.
24388 #
24389 # `ac_cv_env_foo' variables (set or unset) will be overridden when
24390 # loading this file, other *unset* `ac_cv_foo' will be assigned the
24391 # following values.
24392
24393 _ACEOF
24394
24395 # The following way of writing the cache mishandles newlines in values,
24396 # but we know of no workaround that is simple, portable, and efficient.
24397 # So, don't put newlines in cache variables' values.
24398 # Ultrix sh set writes to stderr and can't be redirected directly,
24399 # and sets the high bit in the cache file unless we assign to the vars.
24400 {
24401   (set) 2>&1 |
24402     case `(ac_space=' '; set | grep ac_space) 2>&1` in
24403     *ac_space=\ *)
24404       # `set' does not quote correctly, so add quotes (double-quote
24405       # substitution turns \\\\ into \\, and sed turns \\ into \).
24406       sed -n \
24407         "s/'/'\\\\''/g;
24408           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
24409       ;;
24410     *)
24411       # `set' quotes correctly as required by POSIX, so do not add quotes.
24412       sed -n \
24413         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
24414       ;;
24415     esac;
24416 } |
24417   sed '
24418      t clear
24419      : clear
24420      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
24421      t end
24422      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
24423      : end' >>confcache
24424 if diff $cache_file confcache >/dev/null 2>&1; then :; else
24425   if test -w $cache_file; then
24426     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
24427     cat confcache >$cache_file
24428   else
24429     echo "not updating unwritable cache $cache_file"
24430   fi
24431 fi
24432 rm -f confcache
24433
24434 test "x$prefix" = xNONE && prefix=$ac_default_prefix
24435 # Let make expand exec_prefix.
24436 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
24437
24438 # VPATH may cause trouble with some makes, so we remove $(srcdir),
24439 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
24440 # trailing colons and then remove the whole line if VPATH becomes empty
24441 # (actually we leave an empty line to preserve line numbers).
24442 if test "x$srcdir" = x.; then
24443   ac_vpsub='/^[  ]*VPATH[        ]*=/{
24444 s/:*\$(srcdir):*/:/;
24445 s/:*\${srcdir}:*/:/;
24446 s/:*@srcdir@:*/:/;
24447 s/^\([^=]*=[     ]*\):*/\1/;
24448 s/:*$//;
24449 s/^[^=]*=[       ]*$//;
24450 }'
24451 fi
24452
24453 DEFS=-DHAVE_CONFIG_H
24454
24455 ac_libobjs=
24456 ac_ltlibobjs=
24457 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
24458   # 1. Remove the extension, and $U if already installed.
24459   ac_i=`echo "$ac_i" |
24460          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
24461   # 2. Add them.
24462   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
24463   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
24464 done
24465 LIBOBJS=$ac_libobjs
24466
24467 LTLIBOBJS=$ac_ltlibobjs
24468
24469
24470 if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then
24471   { { echo "$as_me:$LINENO: error: conditional \"MAINTAINER_MODE\" was never defined.
24472 Usually this means the macro was only invoked conditionally." >&5
24473 echo "$as_me: error: conditional \"MAINTAINER_MODE\" was never defined.
24474 Usually this means the macro was only invoked conditionally." >&2;}
24475    { (exit 1); exit 1; }; }
24476 fi
24477 if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
24478   { { echo "$as_me:$LINENO: error: conditional \"AMDEP\" was never defined.
24479 Usually this means the macro was only invoked conditionally." >&5
24480 echo "$as_me: error: conditional \"AMDEP\" was never defined.
24481 Usually this means the macro was only invoked conditionally." >&2;}
24482    { (exit 1); exit 1; }; }
24483 fi
24484 if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
24485   { { echo "$as_me:$LINENO: error: conditional \"am__fastdepCC\" was never defined.
24486 Usually this means the macro was only invoked conditionally." >&5
24487 echo "$as_me: error: conditional \"am__fastdepCC\" was never defined.
24488 Usually this means the macro was only invoked conditionally." >&2;}
24489    { (exit 1); exit 1; }; }
24490 fi
24491
24492 : ${CONFIG_STATUS=./config.status}
24493 ac_clean_files_save=$ac_clean_files
24494 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
24495 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
24496 echo "$as_me: creating $CONFIG_STATUS" >&6;}
24497 cat >$CONFIG_STATUS <<_ACEOF
24498 #! $SHELL
24499 # Generated by $as_me.
24500 # Run this file to recreate the current configuration.
24501 # Compiler output produced by configure, useful for debugging
24502 # configure, is in config.log if it exists.
24503
24504 debug=false
24505 ac_cs_recheck=false
24506 ac_cs_silent=false
24507 SHELL=\${CONFIG_SHELL-$SHELL}
24508 _ACEOF
24509
24510 cat >>$CONFIG_STATUS <<\_ACEOF
24511 ## --------------------- ##
24512 ## M4sh Initialization.  ##
24513 ## --------------------- ##
24514
24515 # Be Bourne compatible
24516 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
24517   emulate sh
24518   NULLCMD=:
24519   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
24520   # is contrary to our usage.  Disable this feature.
24521   alias -g '${1+"$@"}'='"$@"'
24522 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
24523   set -o posix
24524 fi
24525 DUALCASE=1; export DUALCASE # for MKS sh
24526
24527 # Support unset when possible.
24528 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
24529   as_unset=unset
24530 else
24531   as_unset=false
24532 fi
24533
24534
24535 # Work around bugs in pre-3.0 UWIN ksh.
24536 $as_unset ENV MAIL MAILPATH
24537 PS1='$ '
24538 PS2='> '
24539 PS4='+ '
24540
24541 # NLS nuisances.
24542 for as_var in \
24543   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
24544   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
24545   LC_TELEPHONE LC_TIME
24546 do
24547   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
24548     eval $as_var=C; export $as_var
24549   else
24550     $as_unset $as_var
24551   fi
24552 done
24553
24554 # Required to use basename.
24555 if expr a : '\(a\)' >/dev/null 2>&1; then
24556   as_expr=expr
24557 else
24558   as_expr=false
24559 fi
24560
24561 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
24562   as_basename=basename
24563 else
24564   as_basename=false
24565 fi
24566
24567
24568 # Name of the executable.
24569 as_me=`$as_basename "$0" ||
24570 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
24571          X"$0" : 'X\(//\)$' \| \
24572          X"$0" : 'X\(/\)$' \| \
24573          .     : '\(.\)' 2>/dev/null ||
24574 echo X/"$0" |
24575     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
24576           /^X\/\(\/\/\)$/{ s//\1/; q; }
24577           /^X\/\(\/\).*/{ s//\1/; q; }
24578           s/.*/./; q'`
24579
24580
24581 # PATH needs CR, and LINENO needs CR and PATH.
24582 # Avoid depending upon Character Ranges.
24583 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
24584 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
24585 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
24586 as_cr_digits='0123456789'
24587 as_cr_alnum=$as_cr_Letters$as_cr_digits
24588
24589 # The user is always right.
24590 if test "${PATH_SEPARATOR+set}" != set; then
24591   echo "#! /bin/sh" >conf$$.sh
24592   echo  "exit 0"   >>conf$$.sh
24593   chmod +x conf$$.sh
24594   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
24595     PATH_SEPARATOR=';'
24596   else
24597     PATH_SEPARATOR=:
24598   fi
24599   rm -f conf$$.sh
24600 fi
24601
24602
24603   as_lineno_1=$LINENO
24604   as_lineno_2=$LINENO
24605   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
24606   test "x$as_lineno_1" != "x$as_lineno_2" &&
24607   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
24608   # Find who we are.  Look in the path if we contain no path at all
24609   # relative or not.
24610   case $0 in
24611     *[\\/]* ) as_myself=$0 ;;
24612     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24613 for as_dir in $PATH
24614 do
24615   IFS=$as_save_IFS
24616   test -z "$as_dir" && as_dir=.
24617   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
24618 done
24619
24620        ;;
24621   esac
24622   # We did not find ourselves, most probably we were run as `sh COMMAND'
24623   # in which case we are not to be found in the path.
24624   if test "x$as_myself" = x; then
24625     as_myself=$0
24626   fi
24627   if test ! -f "$as_myself"; then
24628     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
24629 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
24630    { (exit 1); exit 1; }; }
24631   fi
24632   case $CONFIG_SHELL in
24633   '')
24634     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24635 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
24636 do
24637   IFS=$as_save_IFS
24638   test -z "$as_dir" && as_dir=.
24639   for as_base in sh bash ksh sh5; do
24640          case $as_dir in
24641          /*)
24642            if ("$as_dir/$as_base" -c '
24643   as_lineno_1=$LINENO
24644   as_lineno_2=$LINENO
24645   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
24646   test "x$as_lineno_1" != "x$as_lineno_2" &&
24647   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
24648              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
24649              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
24650              CONFIG_SHELL=$as_dir/$as_base
24651              export CONFIG_SHELL
24652              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
24653            fi;;
24654          esac
24655        done
24656 done
24657 ;;
24658   esac
24659
24660   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
24661   # uniformly replaced by the line number.  The first 'sed' inserts a
24662   # line-number line before each line; the second 'sed' does the real
24663   # work.  The second script uses 'N' to pair each line-number line
24664   # with the numbered line, and appends trailing '-' during
24665   # substitution so that $LINENO is not a special case at line end.
24666   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
24667   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
24668   sed '=' <$as_myself |
24669     sed '
24670       N
24671       s,$,-,
24672       : loop
24673       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
24674       t loop
24675       s,-$,,
24676       s,^['$as_cr_digits']*\n,,
24677     ' >$as_me.lineno &&
24678   chmod +x $as_me.lineno ||
24679     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
24680 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
24681    { (exit 1); exit 1; }; }
24682
24683   # Don't try to exec as it changes $[0], causing all sort of problems
24684   # (the dirname of $[0] is not the place where we might find the
24685   # original and so on.  Autoconf is especially sensible to this).
24686   . ./$as_me.lineno
24687   # Exit status is that of the last command.
24688   exit
24689 }
24690
24691
24692 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
24693   *c*,-n*) ECHO_N= ECHO_C='
24694 ' ECHO_T='      ' ;;
24695   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
24696   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
24697 esac
24698
24699 if expr a : '\(a\)' >/dev/null 2>&1; then
24700   as_expr=expr
24701 else
24702   as_expr=false
24703 fi
24704
24705 rm -f conf$$ conf$$.exe conf$$.file
24706 echo >conf$$.file
24707 if ln -s conf$$.file conf$$ 2>/dev/null; then
24708   # We could just check for DJGPP; but this test a) works b) is more generic
24709   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
24710   if test -f conf$$.exe; then
24711     # Don't use ln at all; we don't have any links
24712     as_ln_s='cp -p'
24713   else
24714     as_ln_s='ln -s'
24715   fi
24716 elif ln conf$$.file conf$$ 2>/dev/null; then
24717   as_ln_s=ln
24718 else
24719   as_ln_s='cp -p'
24720 fi
24721 rm -f conf$$ conf$$.exe conf$$.file
24722
24723 if mkdir -p . 2>/dev/null; then
24724   as_mkdir_p=:
24725 else
24726   test -d ./-p && rmdir ./-p
24727   as_mkdir_p=false
24728 fi
24729
24730 as_executable_p="test -f"
24731
24732 # Sed expression to map a string onto a valid CPP name.
24733 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
24734
24735 # Sed expression to map a string onto a valid variable name.
24736 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
24737
24738
24739 # IFS
24740 # We need space, tab and new line, in precisely that order.
24741 as_nl='
24742 '
24743 IFS="   $as_nl"
24744
24745 # CDPATH.
24746 $as_unset CDPATH
24747
24748 exec 6>&1
24749
24750 # Open the log real soon, to keep \$[0] and so on meaningful, and to
24751 # report actual input values of CONFIG_FILES etc. instead of their
24752 # values after options handling.  Logging --version etc. is OK.
24753 exec 5>>config.log
24754 {
24755   echo
24756   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
24757 ## Running $as_me. ##
24758 _ASBOX
24759 } >&5
24760 cat >&5 <<_CSEOF
24761
24762 This file was extended by GNU Fortran Runtime Library $as_me 0.3, which was
24763 generated by GNU Autoconf 2.59.  Invocation command line was
24764
24765   CONFIG_FILES    = $CONFIG_FILES
24766   CONFIG_HEADERS  = $CONFIG_HEADERS
24767   CONFIG_LINKS    = $CONFIG_LINKS
24768   CONFIG_COMMANDS = $CONFIG_COMMANDS
24769   $ $0 $@
24770
24771 _CSEOF
24772 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
24773 echo >&5
24774 _ACEOF
24775
24776 # Files that config.status was made for.
24777 if test -n "$ac_config_files"; then
24778   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
24779 fi
24780
24781 if test -n "$ac_config_headers"; then
24782   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
24783 fi
24784
24785 if test -n "$ac_config_links"; then
24786   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
24787 fi
24788
24789 if test -n "$ac_config_commands"; then
24790   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
24791 fi
24792
24793 cat >>$CONFIG_STATUS <<\_ACEOF
24794
24795 ac_cs_usage="\
24796 \`$as_me' instantiates files from templates according to the
24797 current configuration.
24798
24799 Usage: $0 [OPTIONS] [FILE]...
24800
24801   -h, --help       print this help, then exit
24802   -V, --version    print version number, then exit
24803   -q, --quiet      do not print progress messages
24804   -d, --debug      don't remove temporary files
24805       --recheck    update $as_me by reconfiguring in the same conditions
24806   --file=FILE[:TEMPLATE]
24807                    instantiate the configuration file FILE
24808   --header=FILE[:TEMPLATE]
24809                    instantiate the configuration header FILE
24810
24811 Configuration files:
24812 $config_files
24813
24814 Configuration headers:
24815 $config_headers
24816
24817 Configuration commands:
24818 $config_commands
24819
24820 Report bugs to <bug-autoconf@gnu.org>."
24821 _ACEOF
24822
24823 cat >>$CONFIG_STATUS <<_ACEOF
24824 ac_cs_version="\\
24825 GNU Fortran Runtime Library config.status 0.3
24826 configured by $0, generated by GNU Autoconf 2.59,
24827   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
24828
24829 Copyright (C) 2003 Free Software Foundation, Inc.
24830 This config.status script is free software; the Free Software Foundation
24831 gives unlimited permission to copy, distribute and modify it."
24832 srcdir=$srcdir
24833 INSTALL="$INSTALL"
24834 _ACEOF
24835
24836 cat >>$CONFIG_STATUS <<\_ACEOF
24837 # If no file are specified by the user, then we need to provide default
24838 # value.  By we need to know if files were specified by the user.
24839 ac_need_defaults=:
24840 while test $# != 0
24841 do
24842   case $1 in
24843   --*=*)
24844     ac_option=`expr "x$1" : 'x\([^=]*\)='`
24845     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
24846     ac_shift=:
24847     ;;
24848   -*)
24849     ac_option=$1
24850     ac_optarg=$2
24851     ac_shift=shift
24852     ;;
24853   *) # This is not an option, so the user has probably given explicit
24854      # arguments.
24855      ac_option=$1
24856      ac_need_defaults=false;;
24857   esac
24858
24859   case $ac_option in
24860   # Handling of the options.
24861 _ACEOF
24862 cat >>$CONFIG_STATUS <<\_ACEOF
24863   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
24864     ac_cs_recheck=: ;;
24865   --version | --vers* | -V )
24866     echo "$ac_cs_version"; exit 0 ;;
24867   --he | --h)
24868     # Conflict between --help and --header
24869     { { echo "$as_me:$LINENO: error: ambiguous option: $1
24870 Try \`$0 --help' for more information." >&5
24871 echo "$as_me: error: ambiguous option: $1
24872 Try \`$0 --help' for more information." >&2;}
24873    { (exit 1); exit 1; }; };;
24874   --help | --hel | -h )
24875     echo "$ac_cs_usage"; exit 0 ;;
24876   --debug | --d* | -d )
24877     debug=: ;;
24878   --file | --fil | --fi | --f )
24879     $ac_shift
24880     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
24881     ac_need_defaults=false;;
24882   --header | --heade | --head | --hea )
24883     $ac_shift
24884     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
24885     ac_need_defaults=false;;
24886   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
24887   | -silent | --silent | --silen | --sile | --sil | --si | --s)
24888     ac_cs_silent=: ;;
24889
24890   # This is an error.
24891   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
24892 Try \`$0 --help' for more information." >&5
24893 echo "$as_me: error: unrecognized option: $1
24894 Try \`$0 --help' for more information." >&2;}
24895    { (exit 1); exit 1; }; } ;;
24896
24897   *) ac_config_targets="$ac_config_targets $1" ;;
24898
24899   esac
24900   shift
24901 done
24902
24903 ac_configure_extra_args=
24904
24905 if $ac_cs_silent; then
24906   exec 6>/dev/null
24907   ac_configure_extra_args="$ac_configure_extra_args --silent"
24908 fi
24909
24910 _ACEOF
24911 cat >>$CONFIG_STATUS <<_ACEOF
24912 if \$ac_cs_recheck; then
24913   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
24914   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
24915 fi
24916
24917 _ACEOF
24918
24919 cat >>$CONFIG_STATUS <<_ACEOF
24920 #
24921 # INIT-COMMANDS section.
24922 #
24923
24924
24925 srcdir="$srcdir"
24926 host="$host"
24927 target="$target"
24928 with_multisubdir="$with_multisubdir"
24929 with_multisrctop="$with_multisrctop"
24930 with_target_subdir="$with_target_subdir"
24931 ac_configure_args="${multilib_arg} ${ac_configure_args}"
24932 multi_basedir="$multi_basedir"
24933 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
24934 CC="$CC"
24935 AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
24936
24937 GCC="$GCC"
24938 CC="$CC"
24939 acx_cv_header_stdint="$acx_cv_header_stdint"
24940 acx_cv_type_int8_t="$acx_cv_type_int8_t"
24941 acx_cv_type_int16_t="$acx_cv_type_int16_t"
24942 acx_cv_type_int32_t="$acx_cv_type_int32_t"
24943 acx_cv_type_int64_t="$acx_cv_type_int64_t"
24944 acx_cv_type_intptr_t="$acx_cv_type_intptr_t"
24945 ac_cv_type_uintmax_t="$ac_cv_type_uintmax_t"
24946 ac_cv_type_uintptr_t="$ac_cv_type_uintptr_t"
24947 ac_cv_type_uint64_t="$ac_cv_type_uint64_t"
24948 ac_cv_type_u_int64_t="$ac_cv_type_u_int64_t"
24949 ac_cv_type_u_int32_t="$ac_cv_type_u_int32_t"
24950 ac_cv_type_int_least32_t="$ac_cv_type_int_least32_t"
24951 ac_cv_type_int_fast32_t="$ac_cv_type_int_fast32_t"
24952 ac_cv_sizeof_void_p="$ac_cv_sizeof_void_p"
24953
24954
24955 _ACEOF
24956
24957
24958
24959 cat >>$CONFIG_STATUS <<\_ACEOF
24960 for ac_config_target in $ac_config_targets
24961 do
24962   case "$ac_config_target" in
24963   # Handling of arguments.
24964   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
24965   "default-1" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default-1" ;;
24966   "depfiles" ) CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
24967   "gstdint.h" ) CONFIG_COMMANDS="$CONFIG_COMMANDS gstdint.h" ;;
24968   "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
24969   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
24970 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
24971    { (exit 1); exit 1; }; };;
24972   esac
24973 done
24974
24975 # If the user did not use the arguments to specify the items to instantiate,
24976 # then the envvar interface is used.  Set only those that are not.
24977 # We use the long form for the default assignment because of an extremely
24978 # bizarre bug on SunOS 4.1.3.
24979 if $ac_need_defaults; then
24980   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
24981   test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
24982   test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
24983 fi
24984
24985 # Have a temporary directory for convenience.  Make it in the build tree
24986 # simply because there is no reason to put it here, and in addition,
24987 # creating and moving files from /tmp can sometimes cause problems.
24988 # Create a temporary directory, and hook for its removal unless debugging.
24989 $debug ||
24990 {
24991   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
24992   trap '{ (exit 1); exit 1; }' 1 2 13 15
24993 }
24994
24995 # Create a (secure) tmp directory for tmp files.
24996
24997 {
24998   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
24999   test -n "$tmp" && test -d "$tmp"
25000 }  ||
25001 {
25002   tmp=./confstat$$-$RANDOM
25003   (umask 077 && mkdir $tmp)
25004 } ||
25005 {
25006    echo "$me: cannot create a temporary directory in ." >&2
25007    { (exit 1); exit 1; }
25008 }
25009
25010 _ACEOF
25011
25012 cat >>$CONFIG_STATUS <<_ACEOF
25013
25014 #
25015 # CONFIG_FILES section.
25016 #
25017
25018 # No need to generate the scripts if there are no CONFIG_FILES.
25019 # This happens for instance when ./config.status config.h
25020 if test -n "\$CONFIG_FILES"; then
25021   # Protect against being on the right side of a sed subst in config.status.
25022   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
25023    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
25024 s,@SHELL@,$SHELL,;t t
25025 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
25026 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
25027 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
25028 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
25029 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
25030 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
25031 s,@exec_prefix@,$exec_prefix,;t t
25032 s,@prefix@,$prefix,;t t
25033 s,@program_transform_name@,$program_transform_name,;t t
25034 s,@bindir@,$bindir,;t t
25035 s,@sbindir@,$sbindir,;t t
25036 s,@libexecdir@,$libexecdir,;t t
25037 s,@datadir@,$datadir,;t t
25038 s,@sysconfdir@,$sysconfdir,;t t
25039 s,@sharedstatedir@,$sharedstatedir,;t t
25040 s,@localstatedir@,$localstatedir,;t t
25041 s,@libdir@,$libdir,;t t
25042 s,@includedir@,$includedir,;t t
25043 s,@oldincludedir@,$oldincludedir,;t t
25044 s,@infodir@,$infodir,;t t
25045 s,@mandir@,$mandir,;t t
25046 s,@build_alias@,$build_alias,;t t
25047 s,@host_alias@,$host_alias,;t t
25048 s,@target_alias@,$target_alias,;t t
25049 s,@DEFS@,$DEFS,;t t
25050 s,@ECHO_C@,$ECHO_C,;t t
25051 s,@ECHO_N@,$ECHO_N,;t t
25052 s,@ECHO_T@,$ECHO_T,;t t
25053 s,@LIBS@,$LIBS,;t t
25054 s,@build@,$build,;t t
25055 s,@build_cpu@,$build_cpu,;t t
25056 s,@build_vendor@,$build_vendor,;t t
25057 s,@build_os@,$build_os,;t t
25058 s,@build_libsubdir@,$build_libsubdir,;t t
25059 s,@build_subdir@,$build_subdir,;t t
25060 s,@host_subdir@,$host_subdir,;t t
25061 s,@target_subdir@,$target_subdir,;t t
25062 s,@host@,$host,;t t
25063 s,@host_cpu@,$host_cpu,;t t
25064 s,@host_vendor@,$host_vendor,;t t
25065 s,@host_os@,$host_os,;t t
25066 s,@target@,$target,;t t
25067 s,@target_cpu@,$target_cpu,;t t
25068 s,@target_vendor@,$target_vendor,;t t
25069 s,@target_os@,$target_os,;t t
25070 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
25071 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
25072 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
25073 s,@CYGPATH_W@,$CYGPATH_W,;t t
25074 s,@PACKAGE@,$PACKAGE,;t t
25075 s,@VERSION@,$VERSION,;t t
25076 s,@ACLOCAL@,$ACLOCAL,;t t
25077 s,@AUTOCONF@,$AUTOCONF,;t t
25078 s,@AUTOMAKE@,$AUTOMAKE,;t t
25079 s,@AUTOHEADER@,$AUTOHEADER,;t t
25080 s,@MAKEINFO@,$MAKEINFO,;t t
25081 s,@install_sh@,$install_sh,;t t
25082 s,@STRIP@,$STRIP,;t t
25083 s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t
25084 s,@INSTALL_STRIP_PROGRAM@,$INSTALL_STRIP_PROGRAM,;t t
25085 s,@mkdir_p@,$mkdir_p,;t t
25086 s,@AWK@,$AWK,;t t
25087 s,@SET_MAKE@,$SET_MAKE,;t t
25088 s,@am__leading_dot@,$am__leading_dot,;t t
25089 s,@AMTAR@,$AMTAR,;t t
25090 s,@am__tar@,$am__tar,;t t
25091 s,@am__untar@,$am__untar,;t t
25092 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
25093 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
25094 s,@MAINT@,$MAINT,;t t
25095 s,@multi_basedir@,$multi_basedir,;t t
25096 s,@toolexecdir@,$toolexecdir,;t t
25097 s,@toolexeclibdir@,$toolexeclibdir,;t t
25098 s,@CC@,$CC,;t t
25099 s,@ac_ct_CC@,$ac_ct_CC,;t t
25100 s,@EXEEXT@,$EXEEXT,;t t
25101 s,@OBJEXT@,$OBJEXT,;t t
25102 s,@DEPDIR@,$DEPDIR,;t t
25103 s,@am__include@,$am__include,;t t
25104 s,@am__quote@,$am__quote,;t t
25105 s,@AMDEP_TRUE@,$AMDEP_TRUE,;t t
25106 s,@AMDEP_FALSE@,$AMDEP_FALSE,;t t
25107 s,@AMDEPBACKSLASH@,$AMDEPBACKSLASH,;t t
25108 s,@CCDEPMODE@,$CCDEPMODE,;t t
25109 s,@am__fastdepCC_TRUE@,$am__fastdepCC_TRUE,;t t
25110 s,@am__fastdepCC_FALSE@,$am__fastdepCC_FALSE,;t t
25111 s,@AM_FCFLAGS@,$AM_FCFLAGS,;t t
25112 s,@AM_CFLAGS@,$AM_CFLAGS,;t t
25113 s,@AS@,$AS,;t t
25114 s,@ac_ct_AS@,$ac_ct_AS,;t t
25115 s,@AR@,$AR,;t t
25116 s,@ac_ct_AR@,$ac_ct_AR,;t t
25117 s,@RANLIB@,$RANLIB,;t t
25118 s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
25119 s,@LN_S@,$LN_S,;t t
25120 s,@LIBTOOL@,$LIBTOOL,;t t
25121 s,@enable_shared@,$enable_shared,;t t
25122 s,@enable_static@,$enable_static,;t t
25123 s,@FC@,$FC,;t t
25124 s,@FCFLAGS@,$FCFLAGS,;t t
25125 s,@LDFLAGS@,$LDFLAGS,;t t
25126 s,@ac_ct_FC@,$ac_ct_FC,;t t
25127 s,@extra_ldflags_libgfortran@,$extra_ldflags_libgfortran,;t t
25128 s,@CPP@,$CPP,;t t
25129 s,@CPPFLAGS@,$CPPFLAGS,;t t
25130 s,@EGREP@,$EGREP,;t t
25131 s,@FPU_HOST_HEADER@,$FPU_HOST_HEADER,;t t
25132 s,@LIBOBJS@,$LIBOBJS,;t t
25133 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
25134 CEOF
25135
25136 _ACEOF
25137
25138   cat >>$CONFIG_STATUS <<\_ACEOF
25139   # Split the substitutions into bite-sized pieces for seds with
25140   # small command number limits, like on Digital OSF/1 and HP-UX.
25141   ac_max_sed_lines=48
25142   ac_sed_frag=1 # Number of current file.
25143   ac_beg=1 # First line for current file.
25144   ac_end=$ac_max_sed_lines # Line after last line for current file.
25145   ac_more_lines=:
25146   ac_sed_cmds=
25147   while $ac_more_lines; do
25148     if test $ac_beg -gt 1; then
25149       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
25150     else
25151       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
25152     fi
25153     if test ! -s $tmp/subs.frag; then
25154       ac_more_lines=false
25155     else
25156       # The purpose of the label and of the branching condition is to
25157       # speed up the sed processing (if there are no `@' at all, there
25158       # is no need to browse any of the substitutions).
25159       # These are the two extra sed commands mentioned above.
25160       (echo ':t
25161   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
25162       if test -z "$ac_sed_cmds"; then
25163         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
25164       else
25165         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
25166       fi
25167       ac_sed_frag=`expr $ac_sed_frag + 1`
25168       ac_beg=$ac_end
25169       ac_end=`expr $ac_end + $ac_max_sed_lines`
25170     fi
25171   done
25172   if test -z "$ac_sed_cmds"; then
25173     ac_sed_cmds=cat
25174   fi
25175 fi # test -n "$CONFIG_FILES"
25176
25177 _ACEOF
25178 cat >>$CONFIG_STATUS <<\_ACEOF
25179 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
25180   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
25181   case $ac_file in
25182   - | *:- | *:-:* ) # input from stdin
25183         cat >$tmp/stdin
25184         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25185         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25186   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25187         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25188   * )   ac_file_in=$ac_file.in ;;
25189   esac
25190
25191   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
25192   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
25193 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25194          X"$ac_file" : 'X\(//\)[^/]' \| \
25195          X"$ac_file" : 'X\(//\)$' \| \
25196          X"$ac_file" : 'X\(/\)' \| \
25197          .     : '\(.\)' 2>/dev/null ||
25198 echo X"$ac_file" |
25199     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25200           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25201           /^X\(\/\/\)$/{ s//\1/; q; }
25202           /^X\(\/\).*/{ s//\1/; q; }
25203           s/.*/./; q'`
25204   { if $as_mkdir_p; then
25205     mkdir -p "$ac_dir"
25206   else
25207     as_dir="$ac_dir"
25208     as_dirs=
25209     while test ! -d "$as_dir"; do
25210       as_dirs="$as_dir $as_dirs"
25211       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25212 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25213          X"$as_dir" : 'X\(//\)[^/]' \| \
25214          X"$as_dir" : 'X\(//\)$' \| \
25215          X"$as_dir" : 'X\(/\)' \| \
25216          .     : '\(.\)' 2>/dev/null ||
25217 echo X"$as_dir" |
25218     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25219           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25220           /^X\(\/\/\)$/{ s//\1/; q; }
25221           /^X\(\/\).*/{ s//\1/; q; }
25222           s/.*/./; q'`
25223     done
25224     test ! -n "$as_dirs" || mkdir $as_dirs
25225   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
25226 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
25227    { (exit 1); exit 1; }; }; }
25228
25229   ac_builddir=.
25230
25231 if test "$ac_dir" != .; then
25232   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
25233   # A "../" for each directory in $ac_dir_suffix.
25234   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
25235 else
25236   ac_dir_suffix= ac_top_builddir=
25237 fi
25238
25239 case $srcdir in
25240   .)  # No --srcdir option.  We are building in place.
25241     ac_srcdir=.
25242     if test -z "$ac_top_builddir"; then
25243        ac_top_srcdir=.
25244     else
25245        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
25246     fi ;;
25247   [\\/]* | ?:[\\/]* )  # Absolute path.
25248     ac_srcdir=$srcdir$ac_dir_suffix;
25249     ac_top_srcdir=$srcdir ;;
25250   *) # Relative path.
25251     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
25252     ac_top_srcdir=$ac_top_builddir$srcdir ;;
25253 esac
25254
25255 # Do not use `cd foo && pwd` to compute absolute paths, because
25256 # the directories may not exist.
25257 case `pwd` in
25258 .) ac_abs_builddir="$ac_dir";;
25259 *)
25260   case "$ac_dir" in
25261   .) ac_abs_builddir=`pwd`;;
25262   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
25263   *) ac_abs_builddir=`pwd`/"$ac_dir";;
25264   esac;;
25265 esac
25266 case $ac_abs_builddir in
25267 .) ac_abs_top_builddir=${ac_top_builddir}.;;
25268 *)
25269   case ${ac_top_builddir}. in
25270   .) ac_abs_top_builddir=$ac_abs_builddir;;
25271   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
25272   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
25273   esac;;
25274 esac
25275 case $ac_abs_builddir in
25276 .) ac_abs_srcdir=$ac_srcdir;;
25277 *)
25278   case $ac_srcdir in
25279   .) ac_abs_srcdir=$ac_abs_builddir;;
25280   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
25281   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
25282   esac;;
25283 esac
25284 case $ac_abs_builddir in
25285 .) ac_abs_top_srcdir=$ac_top_srcdir;;
25286 *)
25287   case $ac_top_srcdir in
25288   .) ac_abs_top_srcdir=$ac_abs_builddir;;
25289   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
25290   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
25291   esac;;
25292 esac
25293
25294
25295   case $INSTALL in
25296   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
25297   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
25298   esac
25299
25300   if test x"$ac_file" != x-; then
25301     { echo "$as_me:$LINENO: creating $ac_file" >&5
25302 echo "$as_me: creating $ac_file" >&6;}
25303     rm -f "$ac_file"
25304   fi
25305   # Let's still pretend it is `configure' which instantiates (i.e., don't
25306   # use $as_me), people would be surprised to read:
25307   #    /* config.h.  Generated by config.status.  */
25308   if test x"$ac_file" = x-; then
25309     configure_input=
25310   else
25311     configure_input="$ac_file.  "
25312   fi
25313   configure_input=$configure_input"Generated from `echo $ac_file_in |
25314                                      sed 's,.*/,,'` by configure."
25315
25316   # First look for the input files in the build tree, otherwise in the
25317   # src tree.
25318   ac_file_inputs=`IFS=:
25319     for f in $ac_file_in; do
25320       case $f in
25321       -) echo $tmp/stdin ;;
25322       [\\/$]*)
25323          # Absolute (can't be DOS-style, as IFS=:)
25324          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25325 echo "$as_me: error: cannot find input file: $f" >&2;}
25326    { (exit 1); exit 1; }; }
25327          echo "$f";;
25328       *) # Relative
25329          if test -f "$f"; then
25330            # Build tree
25331            echo "$f"
25332          elif test -f "$srcdir/$f"; then
25333            # Source tree
25334            echo "$srcdir/$f"
25335          else
25336            # /dev/null tree
25337            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25338 echo "$as_me: error: cannot find input file: $f" >&2;}
25339    { (exit 1); exit 1; }; }
25340          fi;;
25341       esac
25342     done` || { (exit 1); exit 1; }
25343 _ACEOF
25344 cat >>$CONFIG_STATUS <<_ACEOF
25345   sed "$ac_vpsub
25346 $extrasub
25347 _ACEOF
25348 cat >>$CONFIG_STATUS <<\_ACEOF
25349 :t
25350 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
25351 s,@configure_input@,$configure_input,;t t
25352 s,@srcdir@,$ac_srcdir,;t t
25353 s,@abs_srcdir@,$ac_abs_srcdir,;t t
25354 s,@top_srcdir@,$ac_top_srcdir,;t t
25355 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
25356 s,@builddir@,$ac_builddir,;t t
25357 s,@abs_builddir@,$ac_abs_builddir,;t t
25358 s,@top_builddir@,$ac_top_builddir,;t t
25359 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
25360 s,@INSTALL@,$ac_INSTALL,;t t
25361 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
25362   rm -f $tmp/stdin
25363   if test x"$ac_file" != x-; then
25364     mv $tmp/out $ac_file
25365   else
25366     cat $tmp/out
25367     rm -f $tmp/out
25368   fi
25369
25370 done
25371 _ACEOF
25372 cat >>$CONFIG_STATUS <<\_ACEOF
25373
25374 #
25375 # CONFIG_HEADER section.
25376 #
25377
25378 # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
25379 # NAME is the cpp macro being defined and VALUE is the value it is being given.
25380 #
25381 # ac_d sets the value in "#define NAME VALUE" lines.
25382 ac_dA='s,^\([    ]*\)#\([        ]*define[       ][      ]*\)'
25383 ac_dB='[         ].*$,\1#\2'
25384 ac_dC=' '
25385 ac_dD=',;t'
25386 # ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
25387 ac_uA='s,^\([    ]*\)#\([        ]*\)undef\([    ][      ]*\)'
25388 ac_uB='$,\1#\2define\3'
25389 ac_uC=' '
25390 ac_uD=',;t'
25391
25392 for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue
25393   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
25394   case $ac_file in
25395   - | *:- | *:-:* ) # input from stdin
25396         cat >$tmp/stdin
25397         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25398         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25399   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25400         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25401   * )   ac_file_in=$ac_file.in ;;
25402   esac
25403
25404   test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5
25405 echo "$as_me: creating $ac_file" >&6;}
25406
25407   # First look for the input files in the build tree, otherwise in the
25408   # src tree.
25409   ac_file_inputs=`IFS=:
25410     for f in $ac_file_in; do
25411       case $f in
25412       -) echo $tmp/stdin ;;
25413       [\\/$]*)
25414          # Absolute (can't be DOS-style, as IFS=:)
25415          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25416 echo "$as_me: error: cannot find input file: $f" >&2;}
25417    { (exit 1); exit 1; }; }
25418          # Do quote $f, to prevent DOS paths from being IFS'd.
25419          echo "$f";;
25420       *) # Relative
25421          if test -f "$f"; then
25422            # Build tree
25423            echo "$f"
25424          elif test -f "$srcdir/$f"; then
25425            # Source tree
25426            echo "$srcdir/$f"
25427          else
25428            # /dev/null tree
25429            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25430 echo "$as_me: error: cannot find input file: $f" >&2;}
25431    { (exit 1); exit 1; }; }
25432          fi;;
25433       esac
25434     done` || { (exit 1); exit 1; }
25435   # Remove the trailing spaces.
25436   sed 's/[       ]*$//' $ac_file_inputs >$tmp/in
25437
25438 _ACEOF
25439
25440 # Transform confdefs.h into two sed scripts, `conftest.defines' and
25441 # `conftest.undefs', that substitutes the proper values into
25442 # config.h.in to produce config.h.  The first handles `#define'
25443 # templates, and the second `#undef' templates.
25444 # And first: Protect against being on the right side of a sed subst in
25445 # config.status.  Protect against being in an unquoted here document
25446 # in config.status.
25447 rm -f conftest.defines conftest.undefs
25448 # Using a here document instead of a string reduces the quoting nightmare.
25449 # Putting comments in sed scripts is not portable.
25450 #
25451 # `end' is used to avoid that the second main sed command (meant for
25452 # 0-ary CPP macros) applies to n-ary macro definitions.
25453 # See the Autoconf documentation for `clear'.
25454 cat >confdef2sed.sed <<\_ACEOF
25455 s/[\\&,]/\\&/g
25456 s,[\\$`],\\&,g
25457 t clear
25458 : clear
25459 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
25460 t end
25461 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
25462 : end
25463 _ACEOF
25464 # If some macros were called several times there might be several times
25465 # the same #defines, which is useless.  Nevertheless, we may not want to
25466 # sort them, since we want the *last* AC-DEFINE to be honored.
25467 uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines
25468 sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs
25469 rm -f confdef2sed.sed
25470
25471 # This sed command replaces #undef with comments.  This is necessary, for
25472 # example, in the case of _POSIX_SOURCE, which is predefined and required
25473 # on some systems where configure will not decide to define it.
25474 cat >>conftest.undefs <<\_ACEOF
25475 s,^[     ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
25476 _ACEOF
25477
25478 # Break up conftest.defines because some shells have a limit on the size
25479 # of here documents, and old seds have small limits too (100 cmds).
25480 echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
25481 echo '  if grep "^[      ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
25482 echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
25483 echo '  :' >>$CONFIG_STATUS
25484 rm -f conftest.tail
25485 while grep . conftest.defines >/dev/null
25486 do
25487   # Write a limited-size here document to $tmp/defines.sed.
25488   echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
25489   # Speed up: don't consider the non `#define' lines.
25490   echo '/^[      ]*#[    ]*define/!b' >>$CONFIG_STATUS
25491   # Work around the forget-to-reset-the-flag bug.
25492   echo 't clr' >>$CONFIG_STATUS
25493   echo ': clr' >>$CONFIG_STATUS
25494   sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS
25495   echo 'CEOF
25496   sed -f $tmp/defines.sed $tmp/in >$tmp/out
25497   rm -f $tmp/in
25498   mv $tmp/out $tmp/in
25499 ' >>$CONFIG_STATUS
25500   sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail
25501   rm -f conftest.defines
25502   mv conftest.tail conftest.defines
25503 done
25504 rm -f conftest.defines
25505 echo '  fi # grep' >>$CONFIG_STATUS
25506 echo >>$CONFIG_STATUS
25507
25508 # Break up conftest.undefs because some shells have a limit on the size
25509 # of here documents, and old seds have small limits too (100 cmds).
25510 echo '  # Handle all the #undef templates' >>$CONFIG_STATUS
25511 rm -f conftest.tail
25512 while grep . conftest.undefs >/dev/null
25513 do
25514   # Write a limited-size here document to $tmp/undefs.sed.
25515   echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
25516   # Speed up: don't consider the non `#undef'
25517   echo '/^[      ]*#[    ]*undef/!b' >>$CONFIG_STATUS
25518   # Work around the forget-to-reset-the-flag bug.
25519   echo 't clr' >>$CONFIG_STATUS
25520   echo ': clr' >>$CONFIG_STATUS
25521   sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS
25522   echo 'CEOF
25523   sed -f $tmp/undefs.sed $tmp/in >$tmp/out
25524   rm -f $tmp/in
25525   mv $tmp/out $tmp/in
25526 ' >>$CONFIG_STATUS
25527   sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail
25528   rm -f conftest.undefs
25529   mv conftest.tail conftest.undefs
25530 done
25531 rm -f conftest.undefs
25532
25533 cat >>$CONFIG_STATUS <<\_ACEOF
25534   # Let's still pretend it is `configure' which instantiates (i.e., don't
25535   # use $as_me), people would be surprised to read:
25536   #    /* config.h.  Generated by config.status.  */
25537   if test x"$ac_file" = x-; then
25538     echo "/* Generated by configure.  */" >$tmp/config.h
25539   else
25540     echo "/* $ac_file.  Generated by configure.  */" >$tmp/config.h
25541   fi
25542   cat $tmp/in >>$tmp/config.h
25543   rm -f $tmp/in
25544   if test x"$ac_file" != x-; then
25545     if diff $ac_file $tmp/config.h >/dev/null 2>&1; then
25546       { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
25547 echo "$as_me: $ac_file is unchanged" >&6;}
25548     else
25549       ac_dir=`(dirname "$ac_file") 2>/dev/null ||
25550 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25551          X"$ac_file" : 'X\(//\)[^/]' \| \
25552          X"$ac_file" : 'X\(//\)$' \| \
25553          X"$ac_file" : 'X\(/\)' \| \
25554          .     : '\(.\)' 2>/dev/null ||
25555 echo X"$ac_file" |
25556     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25557           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25558           /^X\(\/\/\)$/{ s//\1/; q; }
25559           /^X\(\/\).*/{ s//\1/; q; }
25560           s/.*/./; q'`
25561       { if $as_mkdir_p; then
25562     mkdir -p "$ac_dir"
25563   else
25564     as_dir="$ac_dir"
25565     as_dirs=
25566     while test ! -d "$as_dir"; do
25567       as_dirs="$as_dir $as_dirs"
25568       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25569 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25570          X"$as_dir" : 'X\(//\)[^/]' \| \
25571          X"$as_dir" : 'X\(//\)$' \| \
25572          X"$as_dir" : 'X\(/\)' \| \
25573          .     : '\(.\)' 2>/dev/null ||
25574 echo X"$as_dir" |
25575     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25576           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25577           /^X\(\/\/\)$/{ s//\1/; q; }
25578           /^X\(\/\).*/{ s//\1/; q; }
25579           s/.*/./; q'`
25580     done
25581     test ! -n "$as_dirs" || mkdir $as_dirs
25582   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
25583 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
25584    { (exit 1); exit 1; }; }; }
25585
25586       rm -f $ac_file
25587       mv $tmp/config.h $ac_file
25588     fi
25589   else
25590     cat $tmp/config.h
25591     rm -f $tmp/config.h
25592   fi
25593 # Compute $ac_file's index in $config_headers.
25594 _am_stamp_count=1
25595 for _am_header in $config_headers :; do
25596   case $_am_header in
25597     $ac_file | $ac_file:* )
25598       break ;;
25599     * )
25600       _am_stamp_count=`expr $_am_stamp_count + 1` ;;
25601   esac
25602 done
25603 echo "timestamp for $ac_file" >`(dirname $ac_file) 2>/dev/null ||
25604 $as_expr X$ac_file : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25605          X$ac_file : 'X\(//\)[^/]' \| \
25606          X$ac_file : 'X\(//\)$' \| \
25607          X$ac_file : 'X\(/\)' \| \
25608          .     : '\(.\)' 2>/dev/null ||
25609 echo X$ac_file |
25610     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25611           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25612           /^X\(\/\/\)$/{ s//\1/; q; }
25613           /^X\(\/\).*/{ s//\1/; q; }
25614           s/.*/./; q'`/stamp-h$_am_stamp_count
25615 done
25616 _ACEOF
25617 cat >>$CONFIG_STATUS <<\_ACEOF
25618
25619 #
25620 # CONFIG_COMMANDS section.
25621 #
25622 for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue
25623   ac_dest=`echo "$ac_file" | sed 's,:.*,,'`
25624   ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`
25625   ac_dir=`(dirname "$ac_dest") 2>/dev/null ||
25626 $as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25627          X"$ac_dest" : 'X\(//\)[^/]' \| \
25628          X"$ac_dest" : 'X\(//\)$' \| \
25629          X"$ac_dest" : 'X\(/\)' \| \
25630          .     : '\(.\)' 2>/dev/null ||
25631 echo X"$ac_dest" |
25632     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25633           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25634           /^X\(\/\/\)$/{ s//\1/; q; }
25635           /^X\(\/\).*/{ s//\1/; q; }
25636           s/.*/./; q'`
25637   { if $as_mkdir_p; then
25638     mkdir -p "$ac_dir"
25639   else
25640     as_dir="$ac_dir"
25641     as_dirs=
25642     while test ! -d "$as_dir"; do
25643       as_dirs="$as_dir $as_dirs"
25644       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25645 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25646          X"$as_dir" : 'X\(//\)[^/]' \| \
25647          X"$as_dir" : 'X\(//\)$' \| \
25648          X"$as_dir" : 'X\(/\)' \| \
25649          .     : '\(.\)' 2>/dev/null ||
25650 echo X"$as_dir" |
25651     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25652           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25653           /^X\(\/\/\)$/{ s//\1/; q; }
25654           /^X\(\/\).*/{ s//\1/; q; }
25655           s/.*/./; q'`
25656     done
25657     test ! -n "$as_dirs" || mkdir $as_dirs
25658   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
25659 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
25660    { (exit 1); exit 1; }; }; }
25661
25662   ac_builddir=.
25663
25664 if test "$ac_dir" != .; then
25665   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
25666   # A "../" for each directory in $ac_dir_suffix.
25667   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
25668 else
25669   ac_dir_suffix= ac_top_builddir=
25670 fi
25671
25672 case $srcdir in
25673   .)  # No --srcdir option.  We are building in place.
25674     ac_srcdir=.
25675     if test -z "$ac_top_builddir"; then
25676        ac_top_srcdir=.
25677     else
25678        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
25679     fi ;;
25680   [\\/]* | ?:[\\/]* )  # Absolute path.
25681     ac_srcdir=$srcdir$ac_dir_suffix;
25682     ac_top_srcdir=$srcdir ;;
25683   *) # Relative path.
25684     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
25685     ac_top_srcdir=$ac_top_builddir$srcdir ;;
25686 esac
25687
25688 # Do not use `cd foo && pwd` to compute absolute paths, because
25689 # the directories may not exist.
25690 case `pwd` in
25691 .) ac_abs_builddir="$ac_dir";;
25692 *)
25693   case "$ac_dir" in
25694   .) ac_abs_builddir=`pwd`;;
25695   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
25696   *) ac_abs_builddir=`pwd`/"$ac_dir";;
25697   esac;;
25698 esac
25699 case $ac_abs_builddir in
25700 .) ac_abs_top_builddir=${ac_top_builddir}.;;
25701 *)
25702   case ${ac_top_builddir}. in
25703   .) ac_abs_top_builddir=$ac_abs_builddir;;
25704   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
25705   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
25706   esac;;
25707 esac
25708 case $ac_abs_builddir in
25709 .) ac_abs_srcdir=$ac_srcdir;;
25710 *)
25711   case $ac_srcdir in
25712   .) ac_abs_srcdir=$ac_abs_builddir;;
25713   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
25714   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
25715   esac;;
25716 esac
25717 case $ac_abs_builddir in
25718 .) ac_abs_top_srcdir=$ac_top_srcdir;;
25719 *)
25720   case $ac_top_srcdir in
25721   .) ac_abs_top_srcdir=$ac_abs_builddir;;
25722   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
25723   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
25724   esac;;
25725 esac
25726
25727
25728   { echo "$as_me:$LINENO: executing $ac_dest commands" >&5
25729 echo "$as_me: executing $ac_dest commands" >&6;}
25730   case $ac_dest in
25731     default-1 )
25732 # Only add multilib support code if we just rebuilt the top-level
25733 # Makefile.
25734 case " $CONFIG_FILES " in
25735  *" Makefile "*)
25736    ac_file=Makefile . ${multi_basedir}/config-ml.in
25737    ;;
25738 esac ;;
25739     depfiles ) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do
25740   # Strip MF so we end up with the name of the file.
25741   mf=`echo "$mf" | sed -e 's/:.*$//'`
25742   # Check whether this is an Automake generated Makefile or not.
25743   # We used to match only the files named `Makefile.in', but
25744   # some people rename them; so instead we look at the file content.
25745   # Grep'ing the first line is not enough: some people post-process
25746   # each Makefile.in and add a new line on top of each file to say so.
25747   # So let's grep whole file.
25748   if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then
25749     dirpart=`(dirname "$mf") 2>/dev/null ||
25750 $as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25751          X"$mf" : 'X\(//\)[^/]' \| \
25752          X"$mf" : 'X\(//\)$' \| \
25753          X"$mf" : 'X\(/\)' \| \
25754          .     : '\(.\)' 2>/dev/null ||
25755 echo X"$mf" |
25756     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25757           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25758           /^X\(\/\/\)$/{ s//\1/; q; }
25759           /^X\(\/\).*/{ s//\1/; q; }
25760           s/.*/./; q'`
25761   else
25762     continue
25763   fi
25764   # Extract the definition of DEPDIR, am__include, and am__quote
25765   # from the Makefile without running `make'.
25766   DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
25767   test -z "$DEPDIR" && continue
25768   am__include=`sed -n 's/^am__include = //p' < "$mf"`
25769   test -z "am__include" && continue
25770   am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
25771   # When using ansi2knr, U may be empty or an underscore; expand it
25772   U=`sed -n 's/^U = //p' < "$mf"`
25773   # Find all dependency output files, they are included files with
25774   # $(DEPDIR) in their names.  We invoke sed twice because it is the
25775   # simplest approach to changing $(DEPDIR) to its actual value in the
25776   # expansion.
25777   for file in `sed -n "
25778     s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
25779        sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
25780     # Make sure the directory exists.
25781     test -f "$dirpart/$file" && continue
25782     fdir=`(dirname "$file") 2>/dev/null ||
25783 $as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25784          X"$file" : 'X\(//\)[^/]' \| \
25785          X"$file" : 'X\(//\)$' \| \
25786          X"$file" : 'X\(/\)' \| \
25787          .     : '\(.\)' 2>/dev/null ||
25788 echo X"$file" |
25789     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25790           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25791           /^X\(\/\/\)$/{ s//\1/; q; }
25792           /^X\(\/\).*/{ s//\1/; q; }
25793           s/.*/./; q'`
25794     { if $as_mkdir_p; then
25795     mkdir -p $dirpart/$fdir
25796   else
25797     as_dir=$dirpart/$fdir
25798     as_dirs=
25799     while test ! -d "$as_dir"; do
25800       as_dirs="$as_dir $as_dirs"
25801       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25802 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25803          X"$as_dir" : 'X\(//\)[^/]' \| \
25804          X"$as_dir" : 'X\(//\)$' \| \
25805          X"$as_dir" : 'X\(/\)' \| \
25806          .     : '\(.\)' 2>/dev/null ||
25807 echo X"$as_dir" |
25808     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25809           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25810           /^X\(\/\/\)$/{ s//\1/; q; }
25811           /^X\(\/\).*/{ s//\1/; q; }
25812           s/.*/./; q'`
25813     done
25814     test ! -n "$as_dirs" || mkdir $as_dirs
25815   fi || { { echo "$as_me:$LINENO: error: cannot create directory $dirpart/$fdir" >&5
25816 echo "$as_me: error: cannot create directory $dirpart/$fdir" >&2;}
25817    { (exit 1); exit 1; }; }; }
25818
25819     # echo "creating $dirpart/$file"
25820     echo '# dummy' > "$dirpart/$file"
25821   done
25822 done
25823  ;;
25824     gstdint.h )
25825 if test "$GCC" = yes; then
25826   echo "/* generated for " `$CC --version | sed 1q` "*/" > tmp-stdint.h
25827 else
25828   echo "/* generated for $CC */" > tmp-stdint.h
25829 fi
25830
25831 sed 's/^ *//' >> tmp-stdint.h <<EOF
25832
25833   #ifndef GCC_GENERATED_STDINT_H
25834   #define GCC_GENERATED_STDINT_H 1
25835
25836   #include <sys/types.h>
25837 EOF
25838
25839 if test "$acx_cv_header_stdint" != stdint.h; then
25840   echo "#include <stddef.h>" >> tmp-stdint.h
25841 fi
25842 if test "$acx_cv_header_stdint" != stddef.h; then
25843   echo "#include <$acx_cv_header_stdint>" >> tmp-stdint.h
25844 fi
25845
25846 sed 's/^ *//' >> tmp-stdint.h <<EOF
25847   /* glibc uses these symbols as guards to prevent redefinitions.  */
25848   #ifdef __int8_t_defined
25849   #define _INT8_T
25850   #define _INT16_T
25851   #define _INT32_T
25852   #endif
25853   #ifdef __uint32_t_defined
25854   #define _UINT32_T
25855   #endif
25856
25857 EOF
25858
25859 # ----------------- done header, emit basic int types -------------
25860 if test "$acx_cv_header_stdint" = stddef.h; then
25861   sed 's/^ *//' >> tmp-stdint.h <<EOF
25862
25863     #ifndef _UINT8_T
25864     #define _UINT8_T
25865     typedef unsigned $acx_cv_type_int8_t uint8_t;
25866     #endif
25867
25868     #ifndef _UINT16_T
25869     #define _UINT16_T
25870     typedef unsigned $acx_cv_type_int16_t uint16_t;
25871     #endif
25872
25873     #ifndef _UINT32_T
25874     #define _UINT32_T
25875     typedef unsigned $acx_cv_type_int32_t uint32_t;
25876     #endif
25877
25878     #ifndef _INT8_T
25879     #define _INT8_T
25880     typedef $acx_cv_type_int8_t int8_t;
25881     #endif
25882
25883     #ifndef _INT16_T
25884     #define _INT16_T
25885     typedef $acx_cv_type_int16_t int16_t;
25886     #endif
25887
25888     #ifndef _INT32_T
25889     #define _INT32_T
25890     typedef $acx_cv_type_int32_t int32_t;
25891     #endif
25892 EOF
25893 elif test "$ac_cv_type_u_int32_t" = yes; then
25894   sed 's/^ *//' >> tmp-stdint.h <<EOF
25895
25896     /* int8_t int16_t int32_t defined by inet code, we do the u_intXX types */
25897     #ifndef _INT8_T
25898     #define _INT8_T
25899     #endif
25900     #ifndef _INT16_T
25901     #define _INT16_T
25902     #endif
25903     #ifndef _INT32_T
25904     #define _INT32_T
25905     #endif
25906
25907     #ifndef _UINT8_T
25908     #define _UINT8_T
25909     typedef u_int8_t uint8_t;
25910     #endif
25911
25912     #ifndef _UINT16_T
25913     #define _UINT16_T
25914     typedef u_int16_t uint16_t;
25915     #endif
25916
25917     #ifndef _UINT32_T
25918     #define _UINT32_T
25919     typedef u_int32_t uint32_t;
25920     #endif
25921 EOF
25922 else
25923   sed 's/^ *//' >> tmp-stdint.h <<EOF
25924
25925     /* Some systems have guard macros to prevent redefinitions, define them.  */
25926     #ifndef _INT8_T
25927     #define _INT8_T
25928     #endif
25929     #ifndef _INT16_T
25930     #define _INT16_T
25931     #endif
25932     #ifndef _INT32_T
25933     #define _INT32_T
25934     #endif
25935     #ifndef _UINT8_T
25936     #define _UINT8_T
25937     #endif
25938     #ifndef _UINT16_T
25939     #define _UINT16_T
25940     #endif
25941     #ifndef _UINT32_T
25942     #define _UINT32_T
25943     #endif
25944 EOF
25945 fi
25946
25947 # ------------- done basic int types, emit int64_t types ------------
25948 if test "$ac_cv_type_uint64_t" = yes; then
25949   sed 's/^ *//' >> tmp-stdint.h <<EOF
25950
25951     /* system headers have good uint64_t and int64_t */
25952     #ifndef _INT64_T
25953     #define _INT64_T
25954     #endif
25955     #ifndef _UINT64_T
25956     #define _UINT64_T
25957     #endif
25958 EOF
25959 elif test "$ac_cv_type_u_int64_t" = yes; then
25960   sed 's/^ *//' >> tmp-stdint.h <<EOF
25961
25962     /* system headers have an u_int64_t (and int64_t) */
25963     #ifndef _INT64_T
25964     #define _INT64_T
25965     #endif
25966     #ifndef _UINT64_T
25967     #define _UINT64_T
25968     typedef u_int64_t uint64_t;
25969     #endif
25970 EOF
25971 elif test -n "$acx_cv_type_int64_t"; then
25972   sed 's/^ *//' >> tmp-stdint.h <<EOF
25973
25974     /* architecture has a 64-bit type, $acx_cv_type_int64_t */
25975     #ifndef _INT64_T
25976     #define _INT64_T
25977     typedef $acx_cv_type_int64_t int64_t;
25978     #endif
25979     #ifndef _UINT64_T
25980     #define _UINT64_T
25981     typedef unsigned $acx_cv_type_int64_t uint64_t;
25982     #endif
25983 EOF
25984 else
25985   sed 's/^ *//' >> tmp-stdint.h <<EOF
25986
25987     /* some common heuristics for int64_t, using compiler-specific tests */
25988     #if defined __STDC_VERSION__ && (__STDC_VERSION__-0) >= 199901L
25989     #ifndef _INT64_T
25990     #define _INT64_T
25991     typedef long long int64_t;
25992     #endif
25993     #ifndef _UINT64_T
25994     #define _UINT64_T
25995     typedef unsigned long long uint64_t;
25996     #endif
25997
25998     #elif defined __GNUC__ && defined (__STDC__) && __STDC__-0
25999     /* NextStep 2.0 cc is really gcc 1.93 but it defines __GNUC__ = 2 and
26000        does not implement __extension__.  But that compiler doesn't define
26001        __GNUC_MINOR__.  */
26002     # if __GNUC__ < 2 || (__NeXT__ && !__GNUC_MINOR__)
26003     # define __extension__
26004     # endif
26005
26006     # ifndef _INT64_T
26007     # define _INT64_T
26008     __extension__ typedef long long int64_t;
26009     # endif
26010     # ifndef _UINT64_T
26011     # define _UINT64_T
26012     __extension__ typedef unsigned long long uint64_t;
26013     # endif
26014
26015     #elif !defined __STRICT_ANSI__
26016     # if defined _MSC_VER || defined __WATCOMC__ || defined __BORLANDC__
26017
26018     #  ifndef _INT64_T
26019     #  define _INT64_T
26020     typedef __int64 int64_t;
26021     #  endif
26022     #  ifndef _UINT64_T
26023     #  define _UINT64_T
26024     typedef unsigned __int64 uint64_t;
26025     #  endif
26026     # endif /* compiler */
26027
26028     #endif /* ANSI version */
26029 EOF
26030 fi
26031
26032 # ------------- done int64_t types, emit intptr types ------------
26033 if test "$ac_cv_type_uintptr_t" != yes; then
26034   sed 's/^ *//' >> tmp-stdint.h <<EOF
26035
26036     /* Define intptr_t based on sizeof(void*) = $ac_cv_sizeof_void_p */
26037     typedef u$acx_cv_type_intptr_t uintptr_t;
26038     typedef $acx_cv_type_intptr_t  intptr_t;
26039 EOF
26040 fi
26041
26042 # ------------- done intptr types, emit int_least types ------------
26043 if test "$ac_cv_type_int_least32_t" != yes; then
26044   sed 's/^ *//' >> tmp-stdint.h <<EOF
26045
26046     /* Define int_least types */
26047     typedef int8_t     int_least8_t;
26048     typedef int16_t    int_least16_t;
26049     typedef int32_t    int_least32_t;
26050     #ifdef _INT64_T
26051     typedef int64_t    int_least64_t;
26052     #endif
26053
26054     typedef uint8_t    uint_least8_t;
26055     typedef uint16_t   uint_least16_t;
26056     typedef uint32_t   uint_least32_t;
26057     #ifdef _UINT64_T
26058     typedef uint64_t   uint_least64_t;
26059     #endif
26060 EOF
26061 fi
26062
26063 # ------------- done intptr types, emit int_fast types ------------
26064 if test "$ac_cv_type_int_fast32_t" != yes; then
26065       sed 's/^ *//' >> tmp-stdint.h <<EOF
26066
26067     /* Define int_fast types.  short is often slow */
26068     typedef int8_t       int_fast8_t;
26069     typedef int          int_fast16_t;
26070     typedef int32_t      int_fast32_t;
26071     #ifdef _INT64_T
26072     typedef int64_t      int_fast64_t;
26073     #endif
26074
26075     typedef uint8_t      uint_fast8_t;
26076     typedef unsigned int uint_fast16_t;
26077     typedef uint32_t     uint_fast32_t;
26078     #ifdef _UINT64_T
26079     typedef uint64_t     uint_fast64_t;
26080     #endif
26081 EOF
26082 fi
26083
26084 if test "$ac_cv_type_uintmax_t" != yes; then
26085   sed 's/^ *//' >> tmp-stdint.h <<EOF
26086
26087     /* Define intmax based on what we found */
26088     #ifdef _INT64_T
26089     typedef int64_t       intmax_t;
26090     #else
26091     typedef long          intmax_t;
26092     #endif
26093     #ifdef _UINT64_T
26094     typedef uint64_t      uintmax_t;
26095     #else
26096     typedef unsigned long uintmax_t;
26097     #endif
26098 EOF
26099 fi
26100
26101 sed 's/^ *//' >> tmp-stdint.h <<EOF
26102
26103   #endif /* GCC_GENERATED_STDINT_H */
26104 EOF
26105
26106 if test -r gstdint.h && cmp -s tmp-stdint.h gstdint.h; then
26107   rm -f tmp-stdint.h
26108 else
26109   mv -f tmp-stdint.h gstdint.h
26110 fi
26111
26112  ;;
26113   esac
26114 done
26115 _ACEOF
26116
26117 cat >>$CONFIG_STATUS <<\_ACEOF
26118
26119 { (exit 0); exit 0; }
26120 _ACEOF
26121 chmod +x $CONFIG_STATUS
26122 ac_clean_files=$ac_clean_files_save
26123
26124
26125 # configure is writing to config.log, and then calls config.status.
26126 # config.status does its own redirection, appending to config.log.
26127 # Unfortunately, on DOS this fails, as config.log is still kept open
26128 # by configure, so config.status won't be able to write to it; its
26129 # output is simply discarded.  So we exec the FD to /dev/null,
26130 # effectively closing config.log, so it can be properly (re)opened and
26131 # appended to by config.status.  When coming back to configure, we
26132 # need to make the FD available again.
26133 if test "$no_create" != yes; then
26134   ac_cs_success=:
26135   ac_config_status_args=
26136   test "$silent" = yes &&
26137     ac_config_status_args="$ac_config_status_args --quiet"
26138   exec 5>/dev/null
26139   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
26140   exec 5>>config.log
26141   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
26142   # would make configure fail if this is the last instruction.
26143   $ac_cs_success || { (exit 1); exit 1; }
26144 fi
26145