libgfortran/configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59 for GNU Fortran Runtime Library 0.3.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME='GNU Fortran Runtime Library'
 269 PACKAGE_TARNAME='libgfortran'
 270 PACKAGE_VERSION='0.3'
 271 PACKAGE_STRING='GNU Fortran Runtime Library 0.3'
 272 PACKAGE_BUGREPORT=''
 273
 274 # Factoring default headers for most tests.
 275 ac_includes_default="\
 276 #include <stdio.h>
 277 #if HAVE_SYS_TYPES_H
 278 # include <sys/types.h>
 279 #endif
 280 #if HAVE_SYS_STAT_H
 281 # include <sys/stat.h>
 282 #endif
 283 #if STDC_HEADERS
 284 # include <stdlib.h>
 285 # include <stddef.h>
 286 #else
 287 # if HAVE_STDLIB_H
 288 #  include <stdlib.h>
 289 # endif
 290 #endif
 291 #if HAVE_STRING_H
 292 # if !STDC_HEADERS && HAVE_MEMORY_H
 293 #  include <memory.h>
 294 # endif
 295 # include <string.h>
 296 #endif
 297 #if HAVE_STRINGS_H
 298 # include <strings.h>
 299 #endif
 300 #if HAVE_INTTYPES_H
 301 # include <inttypes.h>
 302 #else
 303 # if HAVE_STDINT_H
 304 #  include <stdint.h>
 305 # endif
 306 #endif
 307 #if HAVE_UNISTD_H
 308 # include <unistd.h>
 309 #endif"
 310
 311 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os build_libsubdir build_subdir host_subdir target_subdir host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA CYGPATH_W PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM mkdir_p AWK SET_MAKE am__leading_dot AMTAR am__tar am__untar MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT multi_basedir toolexecdir toolexeclibdir CC ac_ct_CC EXEEXT OBJEXT DEPDIR am__include am__quote AMDEP_TRUE AMDEP_FALSE AMDEPBACKSLASH CCDEPMODE am__fastdepCC_TRUE am__fastdepCC_FALSE AM_FCFLAGS AM_CFLAGS AS ac_ct_AS AR ac_ct_AR RANLIB ac_ct_RANLIB LN_S LIBTOOL enable_shared enable_static FC FCFLAGS LDFLAGS ac_ct_FC extra_ldflags_libgfortran CPP CPPFLAGS EGREP FPU_HOST_HEADER LIBOBJS LTLIBOBJS'
 312 ac_subst_files=''
 313
 314 # Initialize some variables set by options.
 315 ac_init_help=
 316 ac_init_version=false
 317 # The variables have the same names as the options, with
 318 # dashes changed to underlines.
 319 cache_file=/dev/null
 320 exec_prefix=NONE
 321 no_create=
 322 no_recursion=
 323 prefix=NONE
 324 program_prefix=NONE
 325 program_suffix=NONE
 326 program_transform_name=s,x,x,
 327 silent=
 328 site=
 329 srcdir=
 330 verbose=
 331 x_includes=NONE
 332 x_libraries=NONE
 333
 334 # Installation directory options.
 335 # These are left unexpanded so users can "make install exec_prefix=/foo"
 336 # and all the variables that are supposed to be based on exec_prefix
 337 # by default will actually change.
 338 # Use braces instead of parens because sh, perl, etc. also accept them.
 339 bindir='${exec_prefix}/bin'
 340 sbindir='${exec_prefix}/sbin'
 341 libexecdir='${exec_prefix}/libexec'
 342 datadir='${prefix}/share'
 343 sysconfdir='${prefix}/etc'
 344 sharedstatedir='${prefix}/com'
 345 localstatedir='${prefix}/var'
 346 libdir='${exec_prefix}/lib'
 347 includedir='${prefix}/include'
 348 oldincludedir='/usr/include'
 349 infodir='${prefix}/info'
 350 mandir='${prefix}/man'
 351
 352 ac_prev=
 353 for ac_option
 354 do
 355   # If the previous option needs an argument, assign it.
 356   if test -n "$ac_prev"; then
 357     eval "$ac_prev=\$ac_option"
 358     ac_prev=
 359     continue
 360   fi
 361
 362   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 363
 364   # Accept the important Cygnus configure options, so we can diagnose typos.
 365
 366   case $ac_option in
 367
 368   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 369     ac_prev=bindir ;;
 370   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 371     bindir=$ac_optarg ;;
 372
 373   -build | --build | --buil | --bui | --bu)
 374     ac_prev=build_alias ;;
 375   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 376     build_alias=$ac_optarg ;;
 377
 378   -cache-file | --cache-file | --cache-fil | --cache-fi \
 379   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 380     ac_prev=cache_file ;;
 381   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 382   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 383     cache_file=$ac_optarg ;;
 384
 385   --config-cache | -C)
 386     cache_file=config.cache ;;
 387
 388   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 389     ac_prev=datadir ;;
 390   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 391   | --da=*)
 392     datadir=$ac_optarg ;;
 393
 394   -disable-* | --disable-*)
 395     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 396     # Reject names that are not valid shell variable names.
 397     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 398       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 399    { (exit 1); exit 1; }; }
 400     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 401     eval "enable_$ac_feature=no" ;;
 402
 403   -enable-* | --enable-*)
 404     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 405     # Reject names that are not valid shell variable names.
 406     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 407       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 408    { (exit 1); exit 1; }; }
 409     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 410     case $ac_option in
 411       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 412       *) ac_optarg=yes ;;
 413     esac
 414     eval "enable_$ac_feature='$ac_optarg'" ;;
 415
 416   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 417   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 418   | --exec | --exe | --ex)
 419     ac_prev=exec_prefix ;;
 420   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 421   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 422   | --exec=* | --exe=* | --ex=*)
 423     exec_prefix=$ac_optarg ;;
 424
 425   -gas | --gas | --ga | --g)
 426     # Obsolete; use --with-gas.
 427     with_gas=yes ;;
 428
 429   -help | --help | --hel | --he | -h)
 430     ac_init_help=long ;;
 431   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 432     ac_init_help=recursive ;;
 433   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 434     ac_init_help=short ;;
 435
 436   -host | --host | --hos | --ho)
 437     ac_prev=host_alias ;;
 438   -host=* | --host=* | --hos=* | --ho=*)
 439     host_alias=$ac_optarg ;;
 440
 441   -includedir | --includedir | --includedi | --included | --include \
 442   | --includ | --inclu | --incl | --inc)
 443     ac_prev=includedir ;;
 444   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 445   | --includ=* | --inclu=* | --incl=* | --inc=*)
 446     includedir=$ac_optarg ;;
 447
 448   -infodir | --infodir | --infodi | --infod | --info | --inf)
 449     ac_prev=infodir ;;
 450   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 451     infodir=$ac_optarg ;;
 452
 453   -libdir | --libdir | --libdi | --libd)
 454     ac_prev=libdir ;;
 455   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 456     libdir=$ac_optarg ;;
 457
 458   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 459   | --libexe | --libex | --libe)
 460     ac_prev=libexecdir ;;
 461   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 462   | --libexe=* | --libex=* | --libe=*)
 463     libexecdir=$ac_optarg ;;
 464
 465   -localstatedir | --localstatedir | --localstatedi | --localstated \
 466   | --localstate | --localstat | --localsta | --localst \
 467   | --locals | --local | --loca | --loc | --lo)
 468     ac_prev=localstatedir ;;
 469   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 470   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 471   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 472     localstatedir=$ac_optarg ;;
 473
 474   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 475     ac_prev=mandir ;;
 476   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 477     mandir=$ac_optarg ;;
 478
 479   -nfp | --nfp | --nf)
 480     # Obsolete; use --without-fp.
 481     with_fp=no ;;
 482
 483   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 484   | --no-cr | --no-c | -n)
 485     no_create=yes ;;
 486
 487   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 488   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 489     no_recursion=yes ;;
 490
 491   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 492   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 493   | --oldin | --oldi | --old | --ol | --o)
 494     ac_prev=oldincludedir ;;
 495   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 496   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 497   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 498     oldincludedir=$ac_optarg ;;
 499
 500   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 501     ac_prev=prefix ;;
 502   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 503     prefix=$ac_optarg ;;
 504
 505   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 506   | --program-pre | --program-pr | --program-p)
 507     ac_prev=program_prefix ;;
 508   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 509   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 510     program_prefix=$ac_optarg ;;
 511
 512   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 513   | --program-suf | --program-su | --program-s)
 514     ac_prev=program_suffix ;;
 515   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 516   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 517     program_suffix=$ac_optarg ;;
 518
 519   -program-transform-name | --program-transform-name \
 520   | --program-transform-nam | --program-transform-na \
 521   | --program-transform-n | --program-transform- \
 522   | --program-transform | --program-transfor \
 523   | --program-transfo | --program-transf \
 524   | --program-trans | --program-tran \
 525   | --progr-tra | --program-tr | --program-t)
 526     ac_prev=program_transform_name ;;
 527   -program-transform-name=* | --program-transform-name=* \
 528   | --program-transform-nam=* | --program-transform-na=* \
 529   | --program-transform-n=* | --program-transform-=* \
 530   | --program-transform=* | --program-transfor=* \
 531   | --program-transfo=* | --program-transf=* \
 532   | --program-trans=* | --program-tran=* \
 533   | --progr-tra=* | --program-tr=* | --program-t=*)
 534     program_transform_name=$ac_optarg ;;
 535
 536   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 537   | -silent | --silent | --silen | --sile | --sil)
 538     silent=yes ;;
 539
 540   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 541     ac_prev=sbindir ;;
 542   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 543   | --sbi=* | --sb=*)
 544     sbindir=$ac_optarg ;;
 545
 546   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 547   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 548   | --sharedst | --shareds | --shared | --share | --shar \
 549   | --sha | --sh)
 550     ac_prev=sharedstatedir ;;
 551   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 552   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 553   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 554   | --sha=* | --sh=*)
 555     sharedstatedir=$ac_optarg ;;
 556
 557   -site | --site | --sit)
 558     ac_prev=site ;;
 559   -site=* | --site=* | --sit=*)
 560     site=$ac_optarg ;;
 561
 562   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 563     ac_prev=srcdir ;;
 564   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 565     srcdir=$ac_optarg ;;
 566
 567   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 568   | --syscon | --sysco | --sysc | --sys | --sy)
 569     ac_prev=sysconfdir ;;
 570   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 571   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 572     sysconfdir=$ac_optarg ;;
 573
 574   -target | --target | --targe | --targ | --tar | --ta | --t)
 575     ac_prev=target_alias ;;
 576   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 577     target_alias=$ac_optarg ;;
 578
 579   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 580     verbose=yes ;;
 581
 582   -version | --version | --versio | --versi | --vers | -V)
 583     ac_init_version=: ;;
 584
 585   -with-* | --with-*)
 586     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 587     # Reject names that are not valid shell variable names.
 588     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 589       { echo "$as_me: error: invalid package name: $ac_package" >&2
 590    { (exit 1); exit 1; }; }
 591     ac_package=`echo $ac_package| sed 's/-/_/g'`
 592     case $ac_option in
 593       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 594       *) ac_optarg=yes ;;
 595     esac
 596     eval "with_$ac_package='$ac_optarg'" ;;
 597
 598   -without-* | --without-*)
 599     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 600     # Reject names that are not valid shell variable names.
 601     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 602       { echo "$as_me: error: invalid package name: $ac_package" >&2
 603    { (exit 1); exit 1; }; }
 604     ac_package=`echo $ac_package | sed 's/-/_/g'`
 605     eval "with_$ac_package=no" ;;
 606
 607   --x)
 608     # Obsolete; use --with-x.
 609     with_x=yes ;;
 610
 611   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 612   | --x-incl | --x-inc | --x-in | --x-i)
 613     ac_prev=x_includes ;;
 614   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 615   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 616     x_includes=$ac_optarg ;;
 617
 618   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 619   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 620     ac_prev=x_libraries ;;
 621   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 622   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 623     x_libraries=$ac_optarg ;;
 624
 625   -*) { echo "$as_me: error: unrecognized option: $ac_option
 626 Try \`$0 --help' for more information." >&2
 627    { (exit 1); exit 1; }; }
 628     ;;
 629
 630   *=*)
 631     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 632     # Reject names that are not valid shell variable names.
 633     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 634       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 635    { (exit 1); exit 1; }; }
 636     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 637     eval "$ac_envvar='$ac_optarg'"
 638     export $ac_envvar ;;
 639
 640   *)
 641     # FIXME: should be removed in autoconf 3.0.
 642     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 643     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 644       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 645     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 646     ;;
 647
 648   esac
 649 done
 650
 651 if test -n "$ac_prev"; then
 652   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 653   { echo "$as_me: error: missing argument to $ac_option" >&2
 654    { (exit 1); exit 1; }; }
 655 fi
 656
 657 # Be sure to have absolute paths.
 658 for ac_var in exec_prefix prefix
 659 do
 660   eval ac_val=$`echo $ac_var`
 661   case $ac_val in
 662     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 663     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 664    { (exit 1); exit 1; }; };;
 665   esac
 666 done
 667
 668 # Be sure to have absolute paths.
 669 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 670               localstatedir libdir includedir oldincludedir infodir mandir
 671 do
 672   eval ac_val=$`echo $ac_var`
 673   case $ac_val in
 674     [\\/$]* | ?:[\\/]* ) ;;
 675     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 676    { (exit 1); exit 1; }; };;
 677   esac
 678 done
 679
 680 # There might be people who depend on the old broken behavior: `$host'
 681 # used to hold the argument of --host etc.
 682 # FIXME: To remove some day.
 683 build=$build_alias
 684 host=$host_alias
 685 target=$target_alias
 686
 687 # FIXME: To remove some day.
 688 if test "x$host_alias" != x; then
 689   if test "x$build_alias" = x; then
 690     cross_compiling=maybe
 691     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 692     If a cross compiler is detected then cross compile mode will be used." >&2
 693   elif test "x$build_alias" != "x$host_alias"; then
 694     cross_compiling=yes
 695   fi
 696 fi
 697
 698 ac_tool_prefix=
 699 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 700
 701 test "$silent" = yes && exec 6>/dev/null
 702
 703
 704 # Find the source files, if location was not specified.
 705 if test -z "$srcdir"; then
 706   ac_srcdir_defaulted=yes
 707   # Try the directory containing this script, then its parent.
 708   ac_confdir=`(dirname "$0") 2>/dev/null ||
 709 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 710          X"$0" : 'X\(//\)[^/]' \| \
 711          X"$0" : 'X\(//\)$' \| \
 712          X"$0" : 'X\(/\)' \| \
 713          .     : '\(.\)' 2>/dev/null ||
 714 echo X"$0" |
 715     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 716           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 717           /^X\(\/\/\)$/{ s//\1/; q; }
 718           /^X\(\/\).*/{ s//\1/; q; }
 719           s/.*/./; q'`
 720   srcdir=$ac_confdir
 721   if test ! -r $srcdir/$ac_unique_file; then
 722     srcdir=..
 723   fi
 724 else
 725   ac_srcdir_defaulted=no
 726 fi
 727 if test ! -r $srcdir/$ac_unique_file; then
 728   if test "$ac_srcdir_defaulted" = yes; then
 729     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 730    { (exit 1); exit 1; }; }
 731   else
 732     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 733    { (exit 1); exit 1; }; }
 734   fi
 735 fi
 736 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 737   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 738    { (exit 1); exit 1; }; }
 739 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 740 ac_env_build_alias_set=${build_alias+set}
 741 ac_env_build_alias_value=$build_alias
 742 ac_cv_env_build_alias_set=${build_alias+set}
 743 ac_cv_env_build_alias_value=$build_alias
 744 ac_env_host_alias_set=${host_alias+set}
 745 ac_env_host_alias_value=$host_alias
 746 ac_cv_env_host_alias_set=${host_alias+set}
 747 ac_cv_env_host_alias_value=$host_alias
 748 ac_env_target_alias_set=${target_alias+set}
 749 ac_env_target_alias_value=$target_alias
 750 ac_cv_env_target_alias_set=${target_alias+set}
 751 ac_cv_env_target_alias_value=$target_alias
 752 ac_env_FC_set=${FC+set}
 753 ac_env_FC_value=$FC
 754 ac_cv_env_FC_set=${FC+set}
 755 ac_cv_env_FC_value=$FC
 756 ac_env_FCFLAGS_set=${FCFLAGS+set}
 757 ac_env_FCFLAGS_value=$FCFLAGS
 758 ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
 759 ac_cv_env_FCFLAGS_value=$FCFLAGS
 760 ac_env_LDFLAGS_set=${LDFLAGS+set}
 761 ac_env_LDFLAGS_value=$LDFLAGS
 762 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 763 ac_cv_env_LDFLAGS_value=$LDFLAGS
 764 ac_env_CPP_set=${CPP+set}
 765 ac_env_CPP_value=$CPP
 766 ac_cv_env_CPP_set=${CPP+set}
 767 ac_cv_env_CPP_value=$CPP
 768 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 769 ac_env_CPPFLAGS_value=$CPPFLAGS
 770 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 771 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 772
 773 #
 774 # Report the --help message.
 775 #
 776 if test "$ac_init_help" = "long"; then
 777   # Omit some internal or obsolete options to make the list less imposing.
 778   # This message is too long to be a string in the A/UX 3.1 sh.
 779   cat <<_ACEOF
 780 \`configure' configures GNU Fortran Runtime Library 0.3 to adapt to many kinds of systems.
 781
 782 Usage: $0 [OPTION]... [VAR=VALUE]...
 783
 784 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 785 VAR=VALUE.  See below for descriptions of some of the useful variables.
 786
 787 Defaults for the options are specified in brackets.
 788
 789 Configuration:
 790   -h, --help              display this help and exit
 791       --help=short        display options specific to this package
 792       --help=recursive    display the short help of all the included packages
 793   -V, --version           display version information and exit
 794   -q, --quiet, --silent   do not print \`checking...' messages
 795       --cache-file=FILE   cache test results in FILE [disabled]
 796   -C, --config-cache      alias for \`--cache-file=config.cache'
 797   -n, --no-create         do not create output files
 798       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 799
 800 _ACEOF
 801
 802   cat <<_ACEOF
 803 Installation directories:
 804   --prefix=PREFIX         install architecture-independent files in PREFIX
 805                           [$ac_default_prefix]
 806   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 807                           [PREFIX]
 808
 809 By default, \`make install' will install all the files in
 810 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 811 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 812 for instance \`--prefix=\$HOME'.
 813
 814 For better control, use the options below.
 815
 816 Fine tuning of the installation directories:
 817   --bindir=DIR           user executables [EPREFIX/bin]
 818   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 819   --libexecdir=DIR       program executables [EPREFIX/libexec]
 820   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 821   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 822   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 823   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 824   --libdir=DIR           object code libraries [EPREFIX/lib]
 825   --includedir=DIR       C header files [PREFIX/include]
 826   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 827   --infodir=DIR          info documentation [PREFIX/info]
 828   --mandir=DIR           man documentation [PREFIX/man]
 829 _ACEOF
 830
 831   cat <<\_ACEOF
 832
 833 Program names:
 834   --program-prefix=PREFIX            prepend PREFIX to installed program names
 835   --program-suffix=SUFFIX            append SUFFIX to installed program names
 836   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 837
 838 System types:
 839   --build=BUILD     configure for building on BUILD [guessed]
 840   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 841   --target=TARGET   configure for building compilers for TARGET [HOST]
 842 _ACEOF
 843 fi
 844
 845 if test -n "$ac_init_help"; then
 846   case $ac_init_help in
 847      short | recursive ) echo "Configuration of GNU Fortran Runtime Library 0.3:";;
 848    esac
 849   cat <<\_ACEOF
 850
 851 Optional Features:
 852   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 853   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 854   --enable-version-specific-runtime-libs    Specify that runtime libraries should be installed in a compiler-specific directory
 855   --enable-maintainer-mode  enable make rules and dependencies not useful
 856                           (and sometimes confusing) to the casual installer
 857   --enable-multilib       build many library versions (default)
 858   --disable-dependency-tracking  speeds up one-time build
 859   --enable-dependency-tracking   do not reject slow dependency extractors
 860   --enable-shared=PKGS  build shared libraries default=yes
 861   --enable-static=PKGS  build static libraries default=yes
 862   --enable-fast-install=PKGS  optimize for fast installation default=yes
 863   --disable-libtool-lock  avoid locking (might break parallel builds)
 864   --disable-largefile     omit support for large files
 865
 866 Optional Packages:
 867   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 868   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 869   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 870   --with-gnu-ld           assume the C compiler uses GNU ld default=no
 871   --with-pic              try to use only PIC/non-PIC objects default=use both
 872
 873 Some influential environment variables:
 874   CC          C compiler command
 875   CFLAGS      C compiler flags
 876   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 877               nonstandard directory <lib dir>
 878   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 879               headers in a nonstandard directory <include dir>
 880   FC          Fortran compiler command
 881   FCFLAGS     Fortran compiler flags
 882   CPP         C preprocessor
 883
 884 Use these variables to override the choices made by `configure' or to help
 885 it to find libraries and programs with nonstandard names/locations.
 886
 887 _ACEOF
 888 fi
 889
 890 if test "$ac_init_help" = "recursive"; then
 891   # If there are subdirs, report their specific --help.
 892   ac_popdir=`pwd`
 893   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
 894     test -d $ac_dir || continue
 895     ac_builddir=.
 896
 897 if test "$ac_dir" != .; then
 898   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
 899   # A "../" for each directory in $ac_dir_suffix.
 900   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
 901 else
 902   ac_dir_suffix= ac_top_builddir=
 903 fi
 904
 905 case $srcdir in
 906   .)  # No --srcdir option.  We are building in place.
 907     ac_srcdir=.
 908     if test -z "$ac_top_builddir"; then
 909        ac_top_srcdir=.
 910     else
 911        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
 912     fi ;;
 913   [\\/]* | ?:[\\/]* )  # Absolute path.
 914     ac_srcdir=$srcdir$ac_dir_suffix;
 915     ac_top_srcdir=$srcdir ;;
 916   *) # Relative path.
 917     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
 918     ac_top_srcdir=$ac_top_builddir$srcdir ;;
 919 esac
 920
 921 # Do not use `cd foo && pwd` to compute absolute paths, because
 922 # the directories may not exist.
 923 case `pwd` in
 924 .) ac_abs_builddir="$ac_dir";;
 925 *)
 926   case "$ac_dir" in
 927   .) ac_abs_builddir=`pwd`;;
 928   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
 929   *) ac_abs_builddir=`pwd`/"$ac_dir";;
 930   esac;;
 931 esac
 932 case $ac_abs_builddir in
 933 .) ac_abs_top_builddir=${ac_top_builddir}.;;
 934 *)
 935   case ${ac_top_builddir}. in
 936   .) ac_abs_top_builddir=$ac_abs_builddir;;
 937   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
 938   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
 939   esac;;
 940 esac
 941 case $ac_abs_builddir in
 942 .) ac_abs_srcdir=$ac_srcdir;;
 943 *)
 944   case $ac_srcdir in
 945   .) ac_abs_srcdir=$ac_abs_builddir;;
 946   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
 947   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
 948   esac;;
 949 esac
 950 case $ac_abs_builddir in
 951 .) ac_abs_top_srcdir=$ac_top_srcdir;;
 952 *)
 953   case $ac_top_srcdir in
 954   .) ac_abs_top_srcdir=$ac_abs_builddir;;
 955   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
 956   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
 957   esac;;
 958 esac
 959
 960     cd $ac_dir
 961     # Check for guested configure; otherwise get Cygnus style configure.
 962     if test -f $ac_srcdir/configure.gnu; then
 963       echo
 964       $SHELL $ac_srcdir/configure.gnu  --help=recursive
 965     elif test -f $ac_srcdir/configure; then
 966       echo
 967       $SHELL $ac_srcdir/configure  --help=recursive
 968     elif test -f $ac_srcdir/configure.ac ||
 969            test -f $ac_srcdir/configure.in; then
 970       echo
 971       $ac_configure --help
 972     else
 973       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
 974     fi
 975     cd $ac_popdir
 976   done
 977 fi
 978
 979 test -n "$ac_init_help" && exit 0
 980 if $ac_init_version; then
 981   cat <<\_ACEOF
 982 GNU Fortran Runtime Library configure 0.3
 983 generated by GNU Autoconf 2.59
 984
 985 Copyright (C) 2003 Free Software Foundation, Inc.
 986 This configure script is free software; the Free Software Foundation
 987 gives unlimited permission to copy, distribute and modify it.
 988 _ACEOF
 989   exit 0
 990 fi
 991 exec 5>config.log
 992 cat >&5 <<_ACEOF
 993 This file contains any messages produced by compilers while
 994 running configure, to aid debugging if configure makes a mistake.
 995
 996 It was created by GNU Fortran Runtime Library $as_me 0.3, which was
 997 generated by GNU Autoconf 2.59.  Invocation command line was
 998
 999   $ $0 $@
1000
1001 _ACEOF
1002 {
1003 cat <<_ASUNAME
1004 ## --------- ##
1005 ## Platform. ##
1006 ## --------- ##
1007
1008 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1009 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1010 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1011 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1012 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1013
1014 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1015 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1016
1017 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1018 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1019 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1020 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1021 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1022 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1023 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1024
1025 _ASUNAME
1026
1027 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1028 for as_dir in $PATH
1029 do
1030   IFS=$as_save_IFS
1031   test -z "$as_dir" && as_dir=.
1032   echo "PATH: $as_dir"
1033 done
1034
1035 } >&5
1036
1037 cat >&5 <<_ACEOF
1038
1039
1040 ## ----------- ##
1041 ## Core tests. ##
1042 ## ----------- ##
1043
1044 _ACEOF
1045
1046
1047 # Keep a trace of the command line.
1048 # Strip out --no-create and --no-recursion so they do not pile up.
1049 # Strip out --silent because we don't want to record it for future runs.
1050 # Also quote any args containing shell meta-characters.
1051 # Make two passes to allow for proper duplicate-argument suppression.
1052 ac_configure_args=
1053 ac_configure_args0=
1054 ac_configure_args1=
1055 ac_sep=
1056 ac_must_keep_next=false
1057 for ac_pass in 1 2
1058 do
1059   for ac_arg
1060   do
1061     case $ac_arg in
1062     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1063     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1064     | -silent | --silent | --silen | --sile | --sil)
1065       continue ;;
1066     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1067       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1068     esac
1069     case $ac_pass in
1070     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1071     2)
1072       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1073       if test $ac_must_keep_next = true; then
1074         ac_must_keep_next=false # Got value, back to normal.
1075       else
1076         case $ac_arg in
1077           *=* | --config-cache | -C | -disable-* | --disable-* \
1078           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1079           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1080           | -with-* | --with-* | -without-* | --without-* | --x)
1081             case "$ac_configure_args0 " in
1082               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1083             esac
1084             ;;
1085           -* ) ac_must_keep_next=true ;;
1086         esac
1087       fi
1088       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1089       # Get rid of the leading space.
1090       ac_sep=" "
1091       ;;
1092     esac
1093   done
1094 done
1095 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1096 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1097
1098 # When interrupted or exit'd, cleanup temporary files, and complete
1099 # config.log.  We remove comments because anyway the quotes in there
1100 # would cause problems or look ugly.
1101 # WARNING: Be sure not to use single quotes in there, as some shells,
1102 # such as our DU 5.0 friend, will then `close' the trap.
1103 trap 'exit_status=$?
1104   # Save into config.log some information that might help in debugging.
1105   {
1106     echo
1107
1108     cat <<\_ASBOX
1109 ## ---------------- ##
1110 ## Cache variables. ##
1111 ## ---------------- ##
1112 _ASBOX
1113     echo
1114     # The following way of writing the cache mishandles newlines in values,
1115 {
1116   (set) 2>&1 |
1117     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1118     *ac_space=\ *)
1119       sed -n \
1120         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1121           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1122       ;;
1123     *)
1124       sed -n \
1125         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1126       ;;
1127     esac;
1128 }
1129     echo
1130
1131     cat <<\_ASBOX
1132 ## ----------------- ##
1133 ## Output variables. ##
1134 ## ----------------- ##
1135 _ASBOX
1136     echo
1137     for ac_var in $ac_subst_vars
1138     do
1139       eval ac_val=$`echo $ac_var`
1140       echo "$ac_var='"'"'$ac_val'"'"'"
1141     done | sort
1142     echo
1143
1144     if test -n "$ac_subst_files"; then
1145       cat <<\_ASBOX
1146 ## ------------- ##
1147 ## Output files. ##
1148 ## ------------- ##
1149 _ASBOX
1150       echo
1151       for ac_var in $ac_subst_files
1152       do
1153         eval ac_val=$`echo $ac_var`
1154         echo "$ac_var='"'"'$ac_val'"'"'"
1155       done | sort
1156       echo
1157     fi
1158
1159     if test -s confdefs.h; then
1160       cat <<\_ASBOX
1161 ## ----------- ##
1162 ## confdefs.h. ##
1163 ## ----------- ##
1164 _ASBOX
1165       echo
1166       sed "/^$/d" confdefs.h | sort
1167       echo
1168     fi
1169     test "$ac_signal" != 0 &&
1170       echo "$as_me: caught signal $ac_signal"
1171     echo "$as_me: exit $exit_status"
1172   } >&5
1173   rm -f core *.core &&
1174   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1175     exit $exit_status
1176      ' 0
1177 for ac_signal in 1 2 13 15; do
1178   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1179 done
1180 ac_signal=0
1181
1182 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1183 rm -rf conftest* confdefs.h
1184 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1185 echo >confdefs.h
1186
1187 # Predefined preprocessor variables.
1188
1189 cat >>confdefs.h <<_ACEOF
1190 #define PACKAGE_NAME "$PACKAGE_NAME"
1191 _ACEOF
1192
1193
1194 cat >>confdefs.h <<_ACEOF
1195 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1196 _ACEOF
1197
1198
1199 cat >>confdefs.h <<_ACEOF
1200 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1201 _ACEOF
1202
1203
1204 cat >>confdefs.h <<_ACEOF
1205 #define PACKAGE_STRING "$PACKAGE_STRING"
1206 _ACEOF
1207
1208
1209 cat >>confdefs.h <<_ACEOF
1210 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1211 _ACEOF
1212
1213
1214 # Let the site file select an alternate cache file if it wants to.
1215 # Prefer explicitly selected file to automatically selected ones.
1216 if test -z "$CONFIG_SITE"; then
1217   if test "x$prefix" != xNONE; then
1218     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1219   else
1220     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1221   fi
1222 fi
1223 for ac_site_file in $CONFIG_SITE; do
1224   if test -r "$ac_site_file"; then
1225     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1226 echo "$as_me: loading site script $ac_site_file" >&6;}
1227     sed 's/^/| /' "$ac_site_file" >&5
1228     . "$ac_site_file"
1229   fi
1230 done
1231
1232 if test -r "$cache_file"; then
1233   # Some versions of bash will fail to source /dev/null (special
1234   # files actually), so we avoid doing that.
1235   if test -f "$cache_file"; then
1236     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1237 echo "$as_me: loading cache $cache_file" >&6;}
1238     case $cache_file in
1239       [\\/]* | ?:[\\/]* ) . $cache_file;;
1240       *)                      . ./$cache_file;;
1241     esac
1242   fi
1243 else
1244   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1245 echo "$as_me: creating cache $cache_file" >&6;}
1246   >$cache_file
1247 fi
1248
1249 # Check that the precious variables saved in the cache have kept the same
1250 # value.
1251 ac_cache_corrupted=false
1252 for ac_var in `(set) 2>&1 |
1253                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1254   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1255   eval ac_new_set=\$ac_env_${ac_var}_set
1256   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1257   eval ac_new_val="\$ac_env_${ac_var}_value"
1258   case $ac_old_set,$ac_new_set in
1259     set,)
1260       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1261 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1262       ac_cache_corrupted=: ;;
1263     ,set)
1264       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1265 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1266       ac_cache_corrupted=: ;;
1267     ,);;
1268     *)
1269       if test "x$ac_old_val" != "x$ac_new_val"; then
1270         { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1271 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1272         { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1273 echo "$as_me:   former value:  $ac_old_val" >&2;}
1274         { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1275 echo "$as_me:   current value: $ac_new_val" >&2;}
1276         ac_cache_corrupted=:
1277       fi;;
1278   esac
1279   # Pass precious variables to config.status.
1280   if test "$ac_new_set" = set; then
1281     case $ac_new_val in
1282     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1283       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1284     *) ac_arg=$ac_var=$ac_new_val ;;
1285     esac
1286     case " $ac_configure_args " in
1287       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1288       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1289     esac
1290   fi
1291 done
1292 if $ac_cache_corrupted; then
1293   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1294 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1295   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1296 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1297    { (exit 1); exit 1; }; }
1298 fi
1299
1300 ac_ext=c
1301 ac_cpp='$CPP $CPPFLAGS'
1302 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1303 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1304 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332           ac_config_headers="$ac_config_headers config.h"
1333
1334 ac_aux_dir=
1335 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1336   if test -f $ac_dir/install-sh; then
1337     ac_aux_dir=$ac_dir
1338     ac_install_sh="$ac_aux_dir/install-sh -c"
1339     break
1340   elif test -f $ac_dir/install.sh; then
1341     ac_aux_dir=$ac_dir
1342     ac_install_sh="$ac_aux_dir/install.sh -c"
1343     break
1344   elif test -f $ac_dir/shtool; then
1345     ac_aux_dir=$ac_dir
1346     ac_install_sh="$ac_aux_dir/shtool install -c"
1347     break
1348   fi
1349 done
1350 if test -z "$ac_aux_dir"; then
1351   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1352 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1353    { (exit 1); exit 1; }; }
1354 fi
1355 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1356 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1357 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1358
1359 # Make sure we can run config.sub.
1360 $ac_config_sub sun4 >/dev/null 2>&1 ||
1361   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1362 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1363    { (exit 1); exit 1; }; }
1364
1365 echo "$as_me:$LINENO: checking build system type" >&5
1366 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1367 if test "${ac_cv_build+set}" = set; then
1368   echo $ECHO_N "(cached) $ECHO_C" >&6
1369 else
1370   ac_cv_build_alias=$build_alias
1371 test -z "$ac_cv_build_alias" &&
1372   ac_cv_build_alias=`$ac_config_guess`
1373 test -z "$ac_cv_build_alias" &&
1374   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1375 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1376    { (exit 1); exit 1; }; }
1377 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1378   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1379 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1380    { (exit 1); exit 1; }; }
1381
1382 fi
1383 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1384 echo "${ECHO_T}$ac_cv_build" >&6
1385 build=$ac_cv_build
1386 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1387 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1388 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1389
1390
1391  case ${build_alias} in
1392   "") build_noncanonical=${build} ;;
1393   *) build_noncanonical=${build_alias} ;;
1394 esac
1395
1396  case ${host_alias} in
1397   "") host_noncanonical=${build_noncanonical} ;;
1398   *) host_noncanonical=${host_alias} ;;
1399 esac
1400
1401  case ${target_alias} in
1402   "") target_noncanonical=${host_noncanonical} ;;
1403   *) target_noncanonical=${target_alias} ;;
1404 esac
1405
1406
1407 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1408 # have matching libraries, they should use host libraries: Makefile.tpl
1409 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1410 # However, they still use the build modules, because the corresponding
1411 # host modules (e.g. bison) are only built for the host when bootstrap
1412 # finishes. So:
1413 # - build_subdir is where we find build modules, and never changes.
1414 # - build_libsubdir is where we find build libraries, and can be overridden.
1415
1416 # Prefix 'build-' so this never conflicts with target_subdir.
1417 build_subdir="build-${build_noncanonical}"
1418
1419 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1420 if test "${with_build_libsubdir+set}" = set; then
1421   withval="$with_build_libsubdir"
1422   build_libsubdir="$withval"
1423 else
1424   build_libsubdir="$build_subdir"
1425 fi;
1426 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1427 if ( test $srcdir = . && test -d gcc ) \
1428    || test -d $srcdir/../host-${host_noncanonical}; then
1429   host_subdir="host-${host_noncanonical}"
1430 else
1431   host_subdir=.
1432 fi
1433 # No prefix.
1434 target_subdir=${target_noncanonical}
1435
1436
1437 # -------
1438 # Options
1439 # -------
1440
1441 echo "$as_me:$LINENO: checking for --enable-version-specific-runtime-libs" >&5
1442 echo $ECHO_N "checking for --enable-version-specific-runtime-libs... $ECHO_C" >&6
1443 # Check whether --enable-version-specific-runtime-libs or --disable-version-specific-runtime-libs was given.
1444 if test "${enable_version_specific_runtime_libs+set}" = set; then
1445   enableval="$enable_version_specific_runtime_libs"
1446   case "$enableval" in
1447  yes) version_specific_libs=yes ;;
1448  no)  version_specific_libs=no ;;
1449  *)   { { echo "$as_me:$LINENO: error: Unknown argument to enable/disable version-specific libs" >&5
1450 echo "$as_me: error: Unknown argument to enable/disable version-specific libs" >&2;}
1451    { (exit 1); exit 1; }; };;
1452  esac
1453 else
1454   version_specific_libs=no
1455 fi;
1456 echo "$as_me:$LINENO: result: $version_specific_libs" >&5
1457 echo "${ECHO_T}$version_specific_libs" >&6
1458
1459
1460 # Gets build, host, target, *_vendor, *_cpu, *_os, etc.
1461 #
1462 # You will slowly go insane if you do not grok the following fact:  when
1463 # building this library, the top-level /target/ becomes the library's /host/.
1464 #
1465 # configure then causes --target to default to --host, exactly like any
1466 # other package using autoconf.  Therefore, 'target' and 'host' will
1467 # always be the same.  This makes sense both for native and cross compilers
1468 # just think about it for a little while.  :-)
1469 #
1470 # Also, if this library is being configured as part of a cross compiler, the
1471 # top-level configure script will pass the "real" host as $with_cross_host.
1472 #
1473 # Do not delete or change the following two lines.  For why, see
1474 # http://gcc.gnu.org/ml/libstdc++/2003-07/msg00451.html
1475 echo "$as_me:$LINENO: checking host system type" >&5
1476 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1477 if test "${ac_cv_host+set}" = set; then
1478   echo $ECHO_N "(cached) $ECHO_C" >&6
1479 else
1480   ac_cv_host_alias=$host_alias
1481 test -z "$ac_cv_host_alias" &&
1482   ac_cv_host_alias=$ac_cv_build_alias
1483 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1484   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1485 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1486    { (exit 1); exit 1; }; }
1487
1488 fi
1489 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1490 echo "${ECHO_T}$ac_cv_host" >&6
1491 host=$ac_cv_host
1492 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1493 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1494 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1495
1496
1497 echo "$as_me:$LINENO: checking target system type" >&5
1498 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1499 if test "${ac_cv_target+set}" = set; then
1500   echo $ECHO_N "(cached) $ECHO_C" >&6
1501 else
1502   ac_cv_target_alias=$target_alias
1503 test "x$ac_cv_target_alias" = "x" &&
1504   ac_cv_target_alias=$ac_cv_host_alias
1505 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1506   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1507 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1508    { (exit 1); exit 1; }; }
1509
1510 fi
1511 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1512 echo "${ECHO_T}$ac_cv_target" >&6
1513 target=$ac_cv_target
1514 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1515 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1516 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1517
1518
1519 # The aliases save the names the user supplied, while $host etc.
1520 # will get canonicalized.
1521 test -n "$target_alias" &&
1522   test "$program_prefix$program_suffix$program_transform_name" = \
1523     NONENONEs,x,x, &&
1524   program_prefix=${target_alias}-
1525 target_alias=${target_alias-$host_alias}
1526
1527 # Sets up automake.  Must come after AC_CANONICAL_SYSTEM.  Each of the
1528 # following is magically included in AUTOMAKE_OPTIONS in each Makefile.am.
1529 #  1.9.6:  minimum required version
1530 #  no-define:  PACKAGE and VERSION will not be #define'd in config.h (a bunch
1531 #              of other PACKAGE_* variables will, however, and there's nothing
1532 #              we can do about that; they come from AC_INIT).
1533 #  foreign:  we don't follow the normal rules for GNU packages (no COPYING
1534 #            file in the top srcdir, etc, etc), so stop complaining.
1535 #  -Wall:  turns on all automake warnings...
1536 #  -Wno-portability:  ...except this one, since GNU make is required.
1537 am__api_version="1.9"
1538 # Find a good install program.  We prefer a C program (faster),
1539 # so one script is as good as another.  But avoid the broken or
1540 # incompatible versions:
1541 # SysV /etc/install, /usr/sbin/install
1542 # SunOS /usr/etc/install
1543 # IRIX /sbin/install
1544 # AIX /bin/install
1545 # AmigaOS /C/install, which installs bootblocks on floppy discs
1546 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1547 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1548 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1549 # OS/2's system install, which has a completely different semantic
1550 # ./install, which can be erroneously created by make from ./install.sh.
1551 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1552 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1553 if test -z "$INSTALL"; then
1554 if test "${ac_cv_path_install+set}" = set; then
1555   echo $ECHO_N "(cached) $ECHO_C" >&6
1556 else
1557   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1558 for as_dir in $PATH
1559 do
1560   IFS=$as_save_IFS
1561   test -z "$as_dir" && as_dir=.
1562   # Account for people who put trailing slashes in PATH elements.
1563 case $as_dir/ in
1564   ./ | .// | /cC/* | \
1565   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1566   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1567   /usr/ucb/* ) ;;
1568   *)
1569     # OSF1 and SCO ODT 3.0 have their own names for install.
1570     # Don't use installbsd from OSF since it installs stuff as root
1571     # by default.
1572     for ac_prog in ginstall scoinst install; do
1573       for ac_exec_ext in '' $ac_executable_extensions; do
1574         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1575           if test $ac_prog = install &&
1576             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1577             # AIX install.  It has an incompatible calling convention.
1578             :
1579           elif test $ac_prog = install &&
1580             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1581             # program-specific install script used by HP pwplus--don't use.
1582             :
1583           else
1584             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1585             break 3
1586           fi
1587         fi
1588       done
1589     done
1590     ;;
1591 esac
1592 done
1593
1594
1595 fi
1596   if test "${ac_cv_path_install+set}" = set; then
1597     INSTALL=$ac_cv_path_install
1598   else
1599     # As a last resort, use the slow shell script.  We don't cache a
1600     # path for INSTALL within a source directory, because that will
1601     # break other packages using the cache if that directory is
1602     # removed, or if the path is relative.
1603     INSTALL=$ac_install_sh
1604   fi
1605 fi
1606 echo "$as_me:$LINENO: result: $INSTALL" >&5
1607 echo "${ECHO_T}$INSTALL" >&6
1608
1609 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1610 # It thinks the first close brace ends the variable substitution.
1611 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1612
1613 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1614
1615 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1616
1617 echo "$as_me:$LINENO: checking whether build environment is sane" >&5
1618 echo $ECHO_N "checking whether build environment is sane... $ECHO_C" >&6
1619 # Just in case
1620 sleep 1
1621 echo timestamp > conftest.file
1622 # Do `set' in a subshell so we don't clobber the current shell's
1623 # arguments.  Must try -L first in case configure is actually a
1624 # symlink; some systems play weird games with the mod time of symlinks
1625 # (eg FreeBSD returns the mod time of the symlink's containing
1626 # directory).
1627 if (
1628    set X `ls -Lt $srcdir/configure conftest.file 2> /dev/null`
1629    if test "$*" = "X"; then
1630       # -L didn't work.
1631       set X `ls -t $srcdir/configure conftest.file`
1632    fi
1633    rm -f conftest.file
1634    if test "$*" != "X $srcdir/configure conftest.file" \
1635       && test "$*" != "X conftest.file $srcdir/configure"; then
1636
1637       # If neither matched, then we have a broken ls.  This can happen
1638       # if, for instance, CONFIG_SHELL is bash and it inherits a
1639       # broken ls alias from the environment.  This has actually
1640       # happened.  Such a system could not be considered "sane".
1641       { { echo "$as_me:$LINENO: error: ls -t appears to fail.  Make sure there is not a broken
1642 alias in your environment" >&5
1643 echo "$as_me: error: ls -t appears to fail.  Make sure there is not a broken
1644 alias in your environment" >&2;}
1645    { (exit 1); exit 1; }; }
1646    fi
1647
1648    test "$2" = conftest.file
1649    )
1650 then
1651    # Ok.
1652    :
1653 else
1654    { { echo "$as_me:$LINENO: error: newly created file is older than distributed files!
1655 Check your system clock" >&5
1656 echo "$as_me: error: newly created file is older than distributed files!
1657 Check your system clock" >&2;}
1658    { (exit 1); exit 1; }; }
1659 fi
1660 echo "$as_me:$LINENO: result: yes" >&5
1661 echo "${ECHO_T}yes" >&6
1662 test "$program_prefix" != NONE &&
1663   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1664 # Use a double $ so make ignores it.
1665 test "$program_suffix" != NONE &&
1666   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1667 # Double any \ or $.  echo might interpret backslashes.
1668 # By default was `s,x,x', remove it if useless.
1669 cat <<\_ACEOF >conftest.sed
1670 s/[\\$]/&&/g;s/;s,x,x,$//
1671 _ACEOF
1672 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1673 rm conftest.sed
1674
1675 # expand $ac_aux_dir to an absolute path
1676 am_aux_dir=`cd $ac_aux_dir && pwd`
1677
1678 test x"${MISSING+set}" = xset || MISSING="\${SHELL} $am_aux_dir/missing"
1679 # Use eval to expand $SHELL
1680 if eval "$MISSING --run true"; then
1681   am_missing_run="$MISSING --run "
1682 else
1683   am_missing_run=
1684   { echo "$as_me:$LINENO: WARNING: \`missing' script is too old or missing" >&5
1685 echo "$as_me: WARNING: \`missing' script is too old or missing" >&2;}
1686 fi
1687
1688 if mkdir -p --version . >/dev/null 2>&1 && test ! -d ./--version; then
1689   # We used to keeping the `.' as first argument, in order to
1690   # allow $(mkdir_p) to be used without argument.  As in
1691   #   $(mkdir_p) $(somedir)
1692   # where $(somedir) is conditionally defined.  However this is wrong
1693   # for two reasons:
1694   #  1. if the package is installed by a user who cannot write `.'
1695   #     make install will fail,
1696   #  2. the above comment should most certainly read
1697   #     $(mkdir_p) $(DESTDIR)$(somedir)
1698   #     so it does not work when $(somedir) is undefined and
1699   #     $(DESTDIR) is not.
1700   #  To support the latter case, we have to write
1701   #     test -z "$(somedir)" || $(mkdir_p) $(DESTDIR)$(somedir),
1702   #  so the `.' trick is pointless.
1703   mkdir_p='mkdir -p --'
1704 else
1705   # On NextStep and OpenStep, the `mkdir' command does not
1706   # recognize any option.  It will interpret all options as
1707   # directories to create, and then abort because `.' already
1708   # exists.
1709   for d in ./-p ./--version;
1710   do
1711     test -d $d && rmdir $d
1712   done
1713   # $(mkinstalldirs) is defined by Automake if mkinstalldirs exists.
1714   if test -f "$ac_aux_dir/mkinstalldirs"; then
1715     mkdir_p='$(mkinstalldirs)'
1716   else
1717     mkdir_p='$(install_sh) -d'
1718   fi
1719 fi
1720
1721 for ac_prog in gawk mawk nawk awk
1722 do
1723   # Extract the first word of "$ac_prog", so it can be a program name with args.
1724 set dummy $ac_prog; ac_word=$2
1725 echo "$as_me:$LINENO: checking for $ac_word" >&5
1726 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1727 if test "${ac_cv_prog_AWK+set}" = set; then
1728   echo $ECHO_N "(cached) $ECHO_C" >&6
1729 else
1730   if test -n "$AWK"; then
1731   ac_cv_prog_AWK="$AWK" # Let the user override the test.
1732 else
1733 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1734 for as_dir in $PATH
1735 do
1736   IFS=$as_save_IFS
1737   test -z "$as_dir" && as_dir=.
1738   for ac_exec_ext in '' $ac_executable_extensions; do
1739   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1740     ac_cv_prog_AWK="$ac_prog"
1741     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1742     break 2
1743   fi
1744 done
1745 done
1746
1747 fi
1748 fi
1749 AWK=$ac_cv_prog_AWK
1750 if test -n "$AWK"; then
1751   echo "$as_me:$LINENO: result: $AWK" >&5
1752 echo "${ECHO_T}$AWK" >&6
1753 else
1754   echo "$as_me:$LINENO: result: no" >&5
1755 echo "${ECHO_T}no" >&6
1756 fi
1757
1758   test -n "$AWK" && break
1759 done
1760
1761 echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
1762 echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
1763 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
1764 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
1765   echo $ECHO_N "(cached) $ECHO_C" >&6
1766 else
1767   cat >conftest.make <<\_ACEOF
1768 all:
1769         @echo 'ac_maketemp="$(MAKE)"'
1770 _ACEOF
1771 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
1772 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
1773 if test -n "$ac_maketemp"; then
1774   eval ac_cv_prog_make_${ac_make}_set=yes
1775 else
1776   eval ac_cv_prog_make_${ac_make}_set=no
1777 fi
1778 rm -f conftest.make
1779 fi
1780 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
1781   echo "$as_me:$LINENO: result: yes" >&5
1782 echo "${ECHO_T}yes" >&6
1783   SET_MAKE=
1784 else
1785   echo "$as_me:$LINENO: result: no" >&5
1786 echo "${ECHO_T}no" >&6
1787   SET_MAKE="MAKE=${MAKE-make}"
1788 fi
1789
1790 rm -rf .tst 2>/dev/null
1791 mkdir .tst 2>/dev/null
1792 if test -d .tst; then
1793   am__leading_dot=.
1794 else
1795   am__leading_dot=_
1796 fi
1797 rmdir .tst 2>/dev/null
1798
1799 # test to see if srcdir already configured
1800 if test "`cd $srcdir && pwd`" != "`pwd`" &&
1801    test -f $srcdir/config.status; then
1802   { { echo "$as_me:$LINENO: error: source directory already configured; run \"make distclean\" there first" >&5
1803 echo "$as_me: error: source directory already configured; run \"make distclean\" there first" >&2;}
1804    { (exit 1); exit 1; }; }
1805 fi
1806
1807 # test whether we have cygpath
1808 if test -z "$CYGPATH_W"; then
1809   if (cygpath --version) >/dev/null 2>/dev/null; then
1810     CYGPATH_W='cygpath -w'
1811   else
1812     CYGPATH_W=echo
1813   fi
1814 fi
1815
1816
1817 # Define the identity of the package.
1818  PACKAGE='libgfortran'
1819  VERSION='0.3'
1820
1821
1822 # Some tools Automake needs.
1823
1824 ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}
1825
1826
1827 AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}
1828
1829
1830 AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}
1831
1832
1833 AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}
1834
1835
1836 MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
1837
1838 install_sh=${install_sh-"$am_aux_dir/install-sh"}
1839
1840 # Installed binaries are usually stripped using `strip' when the user
1841 # run `make install-strip'.  However `strip' might not be the right
1842 # tool to use in cross-compilation environments, therefore Automake
1843 # will honor the `STRIP' environment variable to overrule this program.
1844 if test "$cross_compiling" != no; then
1845   if test -n "$ac_tool_prefix"; then
1846   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
1847 set dummy ${ac_tool_prefix}strip; ac_word=$2
1848 echo "$as_me:$LINENO: checking for $ac_word" >&5
1849 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1850 if test "${ac_cv_prog_STRIP+set}" = set; then
1851   echo $ECHO_N "(cached) $ECHO_C" >&6
1852 else
1853   if test -n "$STRIP"; then
1854   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
1855 else
1856 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1857 for as_dir in $PATH
1858 do
1859   IFS=$as_save_IFS
1860   test -z "$as_dir" && as_dir=.
1861   for ac_exec_ext in '' $ac_executable_extensions; do
1862   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1863     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
1864     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1865     break 2
1866   fi
1867 done
1868 done
1869
1870 fi
1871 fi
1872 STRIP=$ac_cv_prog_STRIP
1873 if test -n "$STRIP"; then
1874   echo "$as_me:$LINENO: result: $STRIP" >&5
1875 echo "${ECHO_T}$STRIP" >&6
1876 else
1877   echo "$as_me:$LINENO: result: no" >&5
1878 echo "${ECHO_T}no" >&6
1879 fi
1880
1881 fi
1882 if test -z "$ac_cv_prog_STRIP"; then
1883   ac_ct_STRIP=$STRIP
1884   # Extract the first word of "strip", so it can be a program name with args.
1885 set dummy strip; ac_word=$2
1886 echo "$as_me:$LINENO: checking for $ac_word" >&5
1887 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1888 if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
1889   echo $ECHO_N "(cached) $ECHO_C" >&6
1890 else
1891   if test -n "$ac_ct_STRIP"; then
1892   ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
1893 else
1894 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1895 for as_dir in $PATH
1896 do
1897   IFS=$as_save_IFS
1898   test -z "$as_dir" && as_dir=.
1899   for ac_exec_ext in '' $ac_executable_extensions; do
1900   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1901     ac_cv_prog_ac_ct_STRIP="strip"
1902     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1903     break 2
1904   fi
1905 done
1906 done
1907
1908   test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
1909 fi
1910 fi
1911 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
1912 if test -n "$ac_ct_STRIP"; then
1913   echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
1914 echo "${ECHO_T}$ac_ct_STRIP" >&6
1915 else
1916   echo "$as_me:$LINENO: result: no" >&5
1917 echo "${ECHO_T}no" >&6
1918 fi
1919
1920   STRIP=$ac_ct_STRIP
1921 else
1922   STRIP="$ac_cv_prog_STRIP"
1923 fi
1924
1925 fi
1926 INSTALL_STRIP_PROGRAM="\${SHELL} \$(install_sh) -c -s"
1927
1928 # We need awk for the "check" target.  The system "awk" is bad on
1929 # some platforms.
1930 # Always define AMTAR for backward compatibility.
1931
1932 AMTAR=${AMTAR-"${am_missing_run}tar"}
1933
1934 am__tar='${AMTAR} chof - "$$tardir"'; am__untar='${AMTAR} xf -'
1935
1936
1937
1938
1939
1940
1941 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
1942 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
1943     # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
1944 if test "${enable_maintainer_mode+set}" = set; then
1945   enableval="$enable_maintainer_mode"
1946   USE_MAINTAINER_MODE=$enableval
1947 else
1948   USE_MAINTAINER_MODE=no
1949 fi;
1950   echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
1951 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
1952
1953
1954 if test $USE_MAINTAINER_MODE = yes; then
1955   MAINTAINER_MODE_TRUE=
1956   MAINTAINER_MODE_FALSE='#'
1957 else
1958   MAINTAINER_MODE_TRUE='#'
1959   MAINTAINER_MODE_FALSE=
1960 fi
1961
1962   MAINT=$MAINTAINER_MODE_TRUE
1963
1964
1965 # Default to --enable-multilib
1966 # Check whether --enable-multilib or --disable-multilib was given.
1967 if test "${enable_multilib+set}" = set; then
1968   enableval="$enable_multilib"
1969   case "$enableval" in
1970   yes) multilib=yes ;;
1971   no)  multilib=no ;;
1972   *)   { { echo "$as_me:$LINENO: error: bad value $enableval for multilib option" >&5
1973 echo "$as_me: error: bad value $enableval for multilib option" >&2;}
1974    { (exit 1); exit 1; }; } ;;
1975  esac
1976 else
1977   multilib=yes
1978 fi;
1979
1980 # We may get other options which we leave undocumented:
1981 # --with-target-subdir, --with-multisrctop, --with-multisubdir
1982 # See config-ml.in if you want the gory details.
1983
1984 if test "$srcdir" = "."; then
1985   if test "$with_target_subdir" != "."; then
1986     multi_basedir="$srcdir/$with_multisrctop../.."
1987   else
1988     multi_basedir="$srcdir/$with_multisrctop.."
1989   fi
1990 else
1991   multi_basedir="$srcdir/.."
1992 fi
1993
1994
1995 # Even if the default multilib is not a cross compilation,
1996 # it may be that some of the other multilibs are.
1997 if test $cross_compiling = no && test $multilib = yes \
1998    && test "x${with_multisubdir}" != x ; then
1999    cross_compiling=maybe
2000 fi
2001
2002           ac_config_commands="$ac_config_commands default-1"
2003
2004
2005 # Handy for debugging:
2006 #AC_MSG_NOTICE($build / $host / $target / $host_alias / $target_alias); sleep 5
2007
2008 # Are we being configured with some form of cross compiler?
2009 # NB: We don't actually need to know this just now, but when, say, a test
2010 #     suite is included, we'll have to know.
2011 if test "$build" != "$host"; then
2012   LIBGFOR_IS_NATIVE=false
2013
2014 else
2015   LIBGFOR_IS_NATIVE=true
2016 fi
2017
2018 # Calculate toolexeclibdir
2019 # Also toolexecdir, though it's only used in toolexeclibdir
2020 case ${version_specific_libs} in
2021   yes)
2022     # Need the gcc compiler version to know where to install libraries
2023     # and header files if --enable-version-specific-runtime-libs option
2024     # is selected.
2025     toolexecdir='$(libdir)/gcc/$(target_alias)'
2026     toolexeclibdir='$(toolexecdir)/$(gcc_version)$(MULTISUBDIR)'
2027     ;;
2028   no)
2029     if test -n "$with_cross_host" &&
2030        test x"$with_cross_host" != x"no"; then
2031       # Install a library built with a cross compiler in tooldir, not libdir.
2032       toolexecdir='$(exec_prefix)/$(target_alias)'
2033       toolexeclibdir='$(toolexecdir)/lib'
2034     else
2035       toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
2036       toolexeclibdir='$(libdir)'
2037     fi
2038     multi_os_directory=`$CC -print-multi-os-directory`
2039     case $multi_os_directory in
2040       .) ;; # Avoid trailing /.
2041       *) toolexeclibdir=$toolexeclibdir/$multi_os_directory ;;
2042     esac
2043     ;;
2044 esac
2045
2046
2047
2048 # Check the compiler.
2049 # The same as in boehm-gc and libstdc++. Have to borrow it from there.
2050 # We must force CC to /not/ be precious variables; otherwise
2051 # the wrong, non-multilib-adjusted value will be used in multilibs.
2052 # As a side effect, we have to subst CFLAGS ourselves.
2053
2054
2055
2056 ac_ext=c
2057 ac_cpp='$CPP $CPPFLAGS'
2058 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2059 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2060 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2061 if test -n "$ac_tool_prefix"; then
2062   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2063 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2064 echo "$as_me:$LINENO: checking for $ac_word" >&5
2065 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2066 if test "${ac_cv_prog_CC+set}" = set; then
2067   echo $ECHO_N "(cached) $ECHO_C" >&6
2068 else
2069   if test -n "$CC"; then
2070   ac_cv_prog_CC="$CC" # Let the user override the test.
2071 else
2072 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2073 for as_dir in $PATH
2074 do
2075   IFS=$as_save_IFS
2076   test -z "$as_dir" && as_dir=.
2077   for ac_exec_ext in '' $ac_executable_extensions; do
2078   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2079     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2080     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2081     break 2
2082   fi
2083 done
2084 done
2085
2086 fi
2087 fi
2088 CC=$ac_cv_prog_CC
2089 if test -n "$CC"; then
2090   echo "$as_me:$LINENO: result: $CC" >&5
2091 echo "${ECHO_T}$CC" >&6
2092 else
2093   echo "$as_me:$LINENO: result: no" >&5
2094 echo "${ECHO_T}no" >&6
2095 fi
2096
2097 fi
2098 if test -z "$ac_cv_prog_CC"; then
2099   ac_ct_CC=$CC
2100   # Extract the first word of "gcc", so it can be a program name with args.
2101 set dummy gcc; ac_word=$2
2102 echo "$as_me:$LINENO: checking for $ac_word" >&5
2103 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2104 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2105   echo $ECHO_N "(cached) $ECHO_C" >&6
2106 else
2107   if test -n "$ac_ct_CC"; then
2108   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2109 else
2110 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2111 for as_dir in $PATH
2112 do
2113   IFS=$as_save_IFS
2114   test -z "$as_dir" && as_dir=.
2115   for ac_exec_ext in '' $ac_executable_extensions; do
2116   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2117     ac_cv_prog_ac_ct_CC="gcc"
2118     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2119     break 2
2120   fi
2121 done
2122 done
2123
2124 fi
2125 fi
2126 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2127 if test -n "$ac_ct_CC"; then
2128   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2129 echo "${ECHO_T}$ac_ct_CC" >&6
2130 else
2131   echo "$as_me:$LINENO: result: no" >&5
2132 echo "${ECHO_T}no" >&6
2133 fi
2134
2135   CC=$ac_ct_CC
2136 else
2137   CC="$ac_cv_prog_CC"
2138 fi
2139
2140 if test -z "$CC"; then
2141   if test -n "$ac_tool_prefix"; then
2142   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2143 set dummy ${ac_tool_prefix}cc; ac_word=$2
2144 echo "$as_me:$LINENO: checking for $ac_word" >&5
2145 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2146 if test "${ac_cv_prog_CC+set}" = set; then
2147   echo $ECHO_N "(cached) $ECHO_C" >&6
2148 else
2149   if test -n "$CC"; then
2150   ac_cv_prog_CC="$CC" # Let the user override the test.
2151 else
2152 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2153 for as_dir in $PATH
2154 do
2155   IFS=$as_save_IFS
2156   test -z "$as_dir" && as_dir=.
2157   for ac_exec_ext in '' $ac_executable_extensions; do
2158   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2159     ac_cv_prog_CC="${ac_tool_prefix}cc"
2160     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2161     break 2
2162   fi
2163 done
2164 done
2165
2166 fi
2167 fi
2168 CC=$ac_cv_prog_CC
2169 if test -n "$CC"; then
2170   echo "$as_me:$LINENO: result: $CC" >&5
2171 echo "${ECHO_T}$CC" >&6
2172 else
2173   echo "$as_me:$LINENO: result: no" >&5
2174 echo "${ECHO_T}no" >&6
2175 fi
2176
2177 fi
2178 if test -z "$ac_cv_prog_CC"; then
2179   ac_ct_CC=$CC
2180   # Extract the first word of "cc", so it can be a program name with args.
2181 set dummy cc; ac_word=$2
2182 echo "$as_me:$LINENO: checking for $ac_word" >&5
2183 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2184 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2185   echo $ECHO_N "(cached) $ECHO_C" >&6
2186 else
2187   if test -n "$ac_ct_CC"; then
2188   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2189 else
2190 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2191 for as_dir in $PATH
2192 do
2193   IFS=$as_save_IFS
2194   test -z "$as_dir" && as_dir=.
2195   for ac_exec_ext in '' $ac_executable_extensions; do
2196   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2197     ac_cv_prog_ac_ct_CC="cc"
2198     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2199     break 2
2200   fi
2201 done
2202 done
2203
2204 fi
2205 fi
2206 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2207 if test -n "$ac_ct_CC"; then
2208   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2209 echo "${ECHO_T}$ac_ct_CC" >&6
2210 else
2211   echo "$as_me:$LINENO: result: no" >&5
2212 echo "${ECHO_T}no" >&6
2213 fi
2214
2215   CC=$ac_ct_CC
2216 else
2217   CC="$ac_cv_prog_CC"
2218 fi
2219
2220 fi
2221 if test -z "$CC"; then
2222   # Extract the first word of "cc", so it can be a program name with args.
2223 set dummy cc; ac_word=$2
2224 echo "$as_me:$LINENO: checking for $ac_word" >&5
2225 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2226 if test "${ac_cv_prog_CC+set}" = set; then
2227   echo $ECHO_N "(cached) $ECHO_C" >&6
2228 else
2229   if test -n "$CC"; then
2230   ac_cv_prog_CC="$CC" # Let the user override the test.
2231 else
2232   ac_prog_rejected=no
2233 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2234 for as_dir in $PATH
2235 do
2236   IFS=$as_save_IFS
2237   test -z "$as_dir" && as_dir=.
2238   for ac_exec_ext in '' $ac_executable_extensions; do
2239   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2240     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2241        ac_prog_rejected=yes
2242        continue
2243      fi
2244     ac_cv_prog_CC="cc"
2245     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2246     break 2
2247   fi
2248 done
2249 done
2250
2251 if test $ac_prog_rejected = yes; then
2252   # We found a bogon in the path, so make sure we never use it.
2253   set dummy $ac_cv_prog_CC
2254   shift
2255   if test $# != 0; then
2256     # We chose a different compiler from the bogus one.
2257     # However, it has the same basename, so the bogon will be chosen
2258     # first if we set CC to just the basename; use the full file name.
2259     shift
2260     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
2261   fi
2262 fi
2263 fi
2264 fi
2265 CC=$ac_cv_prog_CC
2266 if test -n "$CC"; then
2267   echo "$as_me:$LINENO: result: $CC" >&5
2268 echo "${ECHO_T}$CC" >&6
2269 else
2270   echo "$as_me:$LINENO: result: no" >&5
2271 echo "${ECHO_T}no" >&6
2272 fi
2273
2274 fi
2275 if test -z "$CC"; then
2276   if test -n "$ac_tool_prefix"; then
2277   for ac_prog in cl
2278   do
2279     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2280 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2281 echo "$as_me:$LINENO: checking for $ac_word" >&5
2282 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2283 if test "${ac_cv_prog_CC+set}" = set; then
2284   echo $ECHO_N "(cached) $ECHO_C" >&6
2285 else
2286   if test -n "$CC"; then
2287   ac_cv_prog_CC="$CC" # Let the user override the test.
2288 else
2289 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2290 for as_dir in $PATH
2291 do
2292   IFS=$as_save_IFS
2293   test -z "$as_dir" && as_dir=.
2294   for ac_exec_ext in '' $ac_executable_extensions; do
2295   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2296     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2297     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2298     break 2
2299   fi
2300 done
2301 done
2302
2303 fi
2304 fi
2305 CC=$ac_cv_prog_CC
2306 if test -n "$CC"; then
2307   echo "$as_me:$LINENO: result: $CC" >&5
2308 echo "${ECHO_T}$CC" >&6
2309 else
2310   echo "$as_me:$LINENO: result: no" >&5
2311 echo "${ECHO_T}no" >&6
2312 fi
2313
2314     test -n "$CC" && break
2315   done
2316 fi
2317 if test -z "$CC"; then
2318   ac_ct_CC=$CC
2319   for ac_prog in cl
2320 do
2321   # Extract the first word of "$ac_prog", so it can be a program name with args.
2322 set dummy $ac_prog; ac_word=$2
2323 echo "$as_me:$LINENO: checking for $ac_word" >&5
2324 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2325 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2326   echo $ECHO_N "(cached) $ECHO_C" >&6
2327 else
2328   if test -n "$ac_ct_CC"; then
2329   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2330 else
2331 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2332 for as_dir in $PATH
2333 do
2334   IFS=$as_save_IFS
2335   test -z "$as_dir" && as_dir=.
2336   for ac_exec_ext in '' $ac_executable_extensions; do
2337   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2338     ac_cv_prog_ac_ct_CC="$ac_prog"
2339     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2340     break 2
2341   fi
2342 done
2343 done
2344
2345 fi
2346 fi
2347 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2348 if test -n "$ac_ct_CC"; then
2349   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2350 echo "${ECHO_T}$ac_ct_CC" >&6
2351 else
2352   echo "$as_me:$LINENO: result: no" >&5
2353 echo "${ECHO_T}no" >&6
2354 fi
2355
2356   test -n "$ac_ct_CC" && break
2357 done
2358
2359   CC=$ac_ct_CC
2360 fi
2361
2362 fi
2363
2364
2365 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2366 See \`config.log' for more details." >&5
2367 echo "$as_me: error: no acceptable C compiler found in \$PATH
2368 See \`config.log' for more details." >&2;}
2369    { (exit 1); exit 1; }; }
2370
2371 # Provide some information about the compiler.
2372 echo "$as_me:$LINENO:" \
2373      "checking for C compiler version" >&5
2374 ac_compiler=`set X $ac_compile; echo $2`
2375 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2376   (eval $ac_compiler --version </dev/null >&5) 2>&5
2377   ac_status=$?
2378   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2379   (exit $ac_status); }
2380 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2381   (eval $ac_compiler -v </dev/null >&5) 2>&5
2382   ac_status=$?
2383   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2384   (exit $ac_status); }
2385 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2386   (eval $ac_compiler -V </dev/null >&5) 2>&5
2387   ac_status=$?
2388   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2389   (exit $ac_status); }
2390
2391 cat >conftest.$ac_ext <<_ACEOF
2392 /* confdefs.h.  */
2393 _ACEOF
2394 cat confdefs.h >>conftest.$ac_ext
2395 cat >>conftest.$ac_ext <<_ACEOF
2396 /* end confdefs.h.  */
2397
2398 int
2399 main ()
2400 {
2401
2402   ;
2403   return 0;
2404 }
2405 _ACEOF
2406 # FIXME: Cleanup?
2407 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
2408   (eval $ac_link) 2>&5
2409   ac_status=$?
2410   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2411   (exit $ac_status); }; then
2412   gcc_no_link=no
2413 else
2414   gcc_no_link=yes
2415 fi
2416
2417 if test x$gcc_no_link = xyes; then
2418   # Setting cross_compile will disable run tests; it will
2419   # also disable AC_CHECK_FILE but that's generally
2420   # correct if we can't link.
2421   cross_compiling=yes
2422   EXEEXT=
2423 else
2424   cat >conftest.$ac_ext <<_ACEOF
2425 /* confdefs.h.  */
2426 _ACEOF
2427 cat confdefs.h >>conftest.$ac_ext
2428 cat >>conftest.$ac_ext <<_ACEOF
2429 /* end confdefs.h.  */
2430
2431 int
2432 main ()
2433 {
2434
2435   ;
2436   return 0;
2437 }
2438 _ACEOF
2439 ac_clean_files_save=$ac_clean_files
2440 ac_clean_files="$ac_clean_files a.out a.exe b.out"
2441 # Try to create an executable without -o first, disregard a.out.
2442 # It will help us diagnose broken compilers, and finding out an intuition
2443 # of exeext.
2444 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
2445 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
2446 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
2447 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
2448   (eval $ac_link_default) 2>&5
2449   ac_status=$?
2450   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2451   (exit $ac_status); }; then
2452   # Find the output, starting from the most likely.  This scheme is
2453 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
2454 # resort.
2455
2456 # Be careful to initialize this variable, since it used to be cached.
2457 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
2458 ac_cv_exeext=
2459 # b.out is created by i960 compilers.
2460 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
2461 do
2462   test -f "$ac_file" || continue
2463   case $ac_file in
2464     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
2465         ;;
2466     conftest.$ac_ext )
2467         # This is the source file.
2468         ;;
2469     [ab].out )
2470         # We found the default executable, but exeext='' is most
2471         # certainly right.
2472         break;;
2473     *.* )
2474         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
2475         # FIXME: I believe we export ac_cv_exeext for Libtool,
2476         # but it would be cool to find out if it's true.  Does anybody
2477         # maintain Libtool? --akim.
2478         export ac_cv_exeext
2479         break;;
2480     * )
2481         break;;
2482   esac
2483 done
2484 else
2485   echo "$as_me: failed program was:" >&5
2486 sed 's/^/| /' conftest.$ac_ext >&5
2487
2488 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
2489 See \`config.log' for more details." >&5
2490 echo "$as_me: error: C compiler cannot create executables
2491 See \`config.log' for more details." >&2;}
2492    { (exit 77); exit 77; }; }
2493 fi
2494
2495 ac_exeext=$ac_cv_exeext
2496 echo "$as_me:$LINENO: result: $ac_file" >&5
2497 echo "${ECHO_T}$ac_file" >&6
2498
2499 # Check the compiler produces executables we can run.  If not, either
2500 # the compiler is broken, or we cross compile.
2501 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
2502 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
2503 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
2504 # If not cross compiling, check that we can run a simple program.
2505 if test "$cross_compiling" != yes; then
2506   if { ac_try='./$ac_file'
2507   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2508   (eval $ac_try) 2>&5
2509   ac_status=$?
2510   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2511   (exit $ac_status); }; }; then
2512     cross_compiling=no
2513   else
2514     if test "$cross_compiling" = maybe; then
2515         cross_compiling=yes
2516     else
2517         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
2518 If you meant to cross compile, use \`--host'.
2519 See \`config.log' for more details." >&5
2520 echo "$as_me: error: cannot run C compiled programs.
2521 If you meant to cross compile, use \`--host'.
2522 See \`config.log' for more details." >&2;}
2523    { (exit 1); exit 1; }; }
2524     fi
2525   fi
2526 fi
2527 echo "$as_me:$LINENO: result: yes" >&5
2528 echo "${ECHO_T}yes" >&6
2529
2530 rm -f a.out a.exe conftest$ac_cv_exeext b.out
2531 ac_clean_files=$ac_clean_files_save
2532 # Check the compiler produces executables we can run.  If not, either
2533 # the compiler is broken, or we cross compile.
2534 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
2535 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
2536 echo "$as_me:$LINENO: result: $cross_compiling" >&5
2537 echo "${ECHO_T}$cross_compiling" >&6
2538
2539 echo "$as_me:$LINENO: checking for suffix of executables" >&5
2540 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
2541 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
2542   (eval $ac_link) 2>&5
2543   ac_status=$?
2544   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2545   (exit $ac_status); }; then
2546   # If both `conftest.exe' and `conftest' are `present' (well, observable)
2547 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
2548 # work properly (i.e., refer to `conftest.exe'), while it won't with
2549 # `rm'.
2550 for ac_file in conftest.exe conftest conftest.*; do
2551   test -f "$ac_file" || continue
2552   case $ac_file in
2553     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
2554     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
2555           export ac_cv_exeext
2556           break;;
2557     * ) break;;
2558   esac
2559 done
2560 else
2561   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
2562 See \`config.log' for more details." >&5
2563 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
2564 See \`config.log' for more details." >&2;}
2565    { (exit 1); exit 1; }; }
2566 fi
2567
2568 rm -f conftest$ac_cv_exeext
2569 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
2570 echo "${ECHO_T}$ac_cv_exeext" >&6
2571
2572 rm -f conftest.$ac_ext
2573 EXEEXT=$ac_cv_exeext
2574 ac_exeext=$EXEEXT
2575 fi
2576 echo "$as_me:$LINENO: checking for suffix of object files" >&5
2577 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
2578 if test "${ac_cv_objext+set}" = set; then
2579   echo $ECHO_N "(cached) $ECHO_C" >&6
2580 else
2581   cat >conftest.$ac_ext <<_ACEOF
2582 /* confdefs.h.  */
2583 _ACEOF
2584 cat confdefs.h >>conftest.$ac_ext
2585 cat >>conftest.$ac_ext <<_ACEOF
2586 /* end confdefs.h.  */
2587
2588 int
2589 main ()
2590 {
2591
2592   ;
2593   return 0;
2594 }
2595 _ACEOF
2596 rm -f conftest.o conftest.obj
2597 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2598   (eval $ac_compile) 2>&5
2599   ac_status=$?
2600   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2601   (exit $ac_status); }; then
2602   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
2603   case $ac_file in
2604     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
2605     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
2606        break;;
2607   esac
2608 done
2609 else
2610   echo "$as_me: failed program was:" >&5
2611 sed 's/^/| /' conftest.$ac_ext >&5
2612
2613 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
2614 See \`config.log' for more details." >&5
2615 echo "$as_me: error: cannot compute suffix of object files: cannot compile
2616 See \`config.log' for more details." >&2;}
2617    { (exit 1); exit 1; }; }
2618 fi
2619
2620 rm -f conftest.$ac_cv_objext conftest.$ac_ext
2621 fi
2622 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
2623 echo "${ECHO_T}$ac_cv_objext" >&6
2624 OBJEXT=$ac_cv_objext
2625 ac_objext=$OBJEXT
2626 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2627 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2628 if test "${ac_cv_c_compiler_gnu+set}" = set; then
2629   echo $ECHO_N "(cached) $ECHO_C" >&6
2630 else
2631   cat >conftest.$ac_ext <<_ACEOF
2632 /* confdefs.h.  */
2633 _ACEOF
2634 cat confdefs.h >>conftest.$ac_ext
2635 cat >>conftest.$ac_ext <<_ACEOF
2636 /* end confdefs.h.  */
2637
2638 int
2639 main ()
2640 {
2641 #ifndef __GNUC__
2642        choke me
2643 #endif
2644
2645   ;
2646   return 0;
2647 }
2648 _ACEOF
2649 rm -f conftest.$ac_objext
2650 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2651   (eval $ac_compile) 2>conftest.er1
2652   ac_status=$?
2653   grep -v '^ *+' conftest.er1 >conftest.err
2654   rm -f conftest.er1
2655   cat conftest.err >&5
2656   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2657   (exit $ac_status); } &&
2658          { ac_try='test -z "$ac_c_werror_flag"
2659                          || test ! -s conftest.err'
2660   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2661   (eval $ac_try) 2>&5
2662   ac_status=$?
2663   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2664   (exit $ac_status); }; } &&
2665          { ac_try='test -s conftest.$ac_objext'
2666   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2667   (eval $ac_try) 2>&5
2668   ac_status=$?
2669   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2670   (exit $ac_status); }; }; then
2671   ac_compiler_gnu=yes
2672 else
2673   echo "$as_me: failed program was:" >&5
2674 sed 's/^/| /' conftest.$ac_ext >&5
2675
2676 ac_compiler_gnu=no
2677 fi
2678 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2679 ac_cv_c_compiler_gnu=$ac_compiler_gnu
2680
2681 fi
2682 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2683 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2684 GCC=`test $ac_compiler_gnu = yes && echo yes`
2685 ac_test_CFLAGS=${CFLAGS+set}
2686 ac_save_CFLAGS=$CFLAGS
2687 CFLAGS="-g"
2688 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2689 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2690 if test "${ac_cv_prog_cc_g+set}" = set; then
2691   echo $ECHO_N "(cached) $ECHO_C" >&6
2692 else
2693   cat >conftest.$ac_ext <<_ACEOF
2694 /* confdefs.h.  */
2695 _ACEOF
2696 cat confdefs.h >>conftest.$ac_ext
2697 cat >>conftest.$ac_ext <<_ACEOF
2698 /* end confdefs.h.  */
2699
2700 int
2701 main ()
2702 {
2703
2704   ;
2705   return 0;
2706 }
2707 _ACEOF
2708 rm -f conftest.$ac_objext
2709 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2710   (eval $ac_compile) 2>conftest.er1
2711   ac_status=$?
2712   grep -v '^ *+' conftest.er1 >conftest.err
2713   rm -f conftest.er1
2714   cat conftest.err >&5
2715   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2716   (exit $ac_status); } &&
2717          { ac_try='test -z "$ac_c_werror_flag"
2718                          || test ! -s conftest.err'
2719   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2720   (eval $ac_try) 2>&5
2721   ac_status=$?
2722   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2723   (exit $ac_status); }; } &&
2724          { ac_try='test -s conftest.$ac_objext'
2725   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2726   (eval $ac_try) 2>&5
2727   ac_status=$?
2728   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2729   (exit $ac_status); }; }; then
2730   ac_cv_prog_cc_g=yes
2731 else
2732   echo "$as_me: failed program was:" >&5
2733 sed 's/^/| /' conftest.$ac_ext >&5
2734
2735 ac_cv_prog_cc_g=no
2736 fi
2737 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2738 fi
2739 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2740 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2741 if test "$ac_test_CFLAGS" = set; then
2742   CFLAGS=$ac_save_CFLAGS
2743 elif test $ac_cv_prog_cc_g = yes; then
2744   if test "$GCC" = yes; then
2745     CFLAGS="-g -O2"
2746   else
2747     CFLAGS="-g"
2748   fi
2749 else
2750   if test "$GCC" = yes; then
2751     CFLAGS="-O2"
2752   else
2753     CFLAGS=
2754   fi
2755 fi
2756 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2757 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2758 if test "${ac_cv_prog_cc_stdc+set}" = set; then
2759   echo $ECHO_N "(cached) $ECHO_C" >&6
2760 else
2761   ac_cv_prog_cc_stdc=no
2762 ac_save_CC=$CC
2763 cat >conftest.$ac_ext <<_ACEOF
2764 /* confdefs.h.  */
2765 _ACEOF
2766 cat confdefs.h >>conftest.$ac_ext
2767 cat >>conftest.$ac_ext <<_ACEOF
2768 /* end confdefs.h.  */
2769 #include <stdarg.h>
2770 #include <stdio.h>
2771 #include <sys/types.h>
2772 #include <sys/stat.h>
2773 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2774 struct buf { int x; };
2775 FILE * (*rcsopen) (struct buf *, struct stat *, int);
2776 static char *e (p, i)
2777      char **p;
2778      int i;
2779 {
2780   return p[i];
2781 }
2782 static char *f (char * (*g) (char **, int), char **p, ...)
2783 {
2784   char *s;
2785   va_list v;
2786   va_start (v,p);
2787   s = g (p, va_arg (v,int));
2788   va_end (v);
2789   return s;
2790 }
2791
2792 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2793    function prototypes and stuff, but not '\xHH' hex character constants.
2794    These don't provoke an error unfortunately, instead are silently treated
2795    as 'x'.  The following induces an error, until -std1 is added to get
2796    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2797    array size at least.  It's necessary to write '\x00'==0 to get something
2798    that's true only with -std1.  */
2799 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2800
2801 int test (int i, double x);
2802 struct s1 {int (*f) (int a);};
2803 struct s2 {int (*f) (double a);};
2804 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2805 int argc;
2806 char **argv;
2807 int
2808 main ()
2809 {
2810 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2811   ;
2812   return 0;
2813 }
2814 _ACEOF
2815 # Don't try gcc -ansi; that turns off useful extensions and
2816 # breaks some systems' header files.
2817 # AIX                   -qlanglvl=ansi
2818 # Ultrix and OSF/1      -std1
2819 # HP-UX 10.20 and later -Ae
2820 # HP-UX older versions  -Aa -D_HPUX_SOURCE
2821 # SVR4                  -Xc -D__EXTENSIONS__
2822 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2823 do
2824   CC="$ac_save_CC $ac_arg"
2825   rm -f conftest.$ac_objext
2826 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2827   (eval $ac_compile) 2>conftest.er1
2828   ac_status=$?
2829   grep -v '^ *+' conftest.er1 >conftest.err
2830   rm -f conftest.er1
2831   cat conftest.err >&5
2832   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2833   (exit $ac_status); } &&
2834          { ac_try='test -z "$ac_c_werror_flag"
2835                          || test ! -s conftest.err'
2836   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2837   (eval $ac_try) 2>&5
2838   ac_status=$?
2839   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2840   (exit $ac_status); }; } &&
2841          { ac_try='test -s conftest.$ac_objext'
2842   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2843   (eval $ac_try) 2>&5
2844   ac_status=$?
2845   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2846   (exit $ac_status); }; }; then
2847   ac_cv_prog_cc_stdc=$ac_arg
2848 break
2849 else
2850   echo "$as_me: failed program was:" >&5
2851 sed 's/^/| /' conftest.$ac_ext >&5
2852
2853 fi
2854 rm -f conftest.err conftest.$ac_objext
2855 done
2856 rm -f conftest.$ac_ext conftest.$ac_objext
2857 CC=$ac_save_CC
2858
2859 fi
2860
2861 case "x$ac_cv_prog_cc_stdc" in
2862   x|xno)
2863     echo "$as_me:$LINENO: result: none needed" >&5
2864 echo "${ECHO_T}none needed" >&6 ;;
2865   *)
2866     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2867 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2868     CC="$CC $ac_cv_prog_cc_stdc" ;;
2869 esac
2870
2871 # Some people use a C++ compiler to compile C.  Since we use `exit',
2872 # in C++ we need to declare it.  In case someone uses the same compiler
2873 # for both compiling C and C++ we need to have the C++ compiler decide
2874 # the declaration of exit, since it's the most demanding environment.
2875 cat >conftest.$ac_ext <<_ACEOF
2876 #ifndef __cplusplus
2877   choke me
2878 #endif
2879 _ACEOF
2880 rm -f conftest.$ac_objext
2881 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2882   (eval $ac_compile) 2>conftest.er1
2883   ac_status=$?
2884   grep -v '^ *+' conftest.er1 >conftest.err
2885   rm -f conftest.er1
2886   cat conftest.err >&5
2887   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2888   (exit $ac_status); } &&
2889          { ac_try='test -z "$ac_c_werror_flag"
2890                          || test ! -s conftest.err'
2891   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2892   (eval $ac_try) 2>&5
2893   ac_status=$?
2894   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2895   (exit $ac_status); }; } &&
2896          { ac_try='test -s conftest.$ac_objext'
2897   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2898   (eval $ac_try) 2>&5
2899   ac_status=$?
2900   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2901   (exit $ac_status); }; }; then
2902   for ac_declaration in \
2903    '' \
2904    'extern "C" void std::exit (int) throw (); using std::exit;' \
2905    'extern "C" void std::exit (int); using std::exit;' \
2906    'extern "C" void exit (int) throw ();' \
2907    'extern "C" void exit (int);' \
2908    'void exit (int);'
2909 do
2910   cat >conftest.$ac_ext <<_ACEOF
2911 /* confdefs.h.  */
2912 _ACEOF
2913 cat confdefs.h >>conftest.$ac_ext
2914 cat >>conftest.$ac_ext <<_ACEOF
2915 /* end confdefs.h.  */
2916 $ac_declaration
2917 #include <stdlib.h>
2918 int
2919 main ()
2920 {
2921 exit (42);
2922   ;
2923   return 0;
2924 }
2925 _ACEOF
2926 rm -f conftest.$ac_objext
2927 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2928   (eval $ac_compile) 2>conftest.er1
2929   ac_status=$?
2930   grep -v '^ *+' conftest.er1 >conftest.err
2931   rm -f conftest.er1
2932   cat conftest.err >&5
2933   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2934   (exit $ac_status); } &&
2935          { ac_try='test -z "$ac_c_werror_flag"
2936                          || test ! -s conftest.err'
2937   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2938   (eval $ac_try) 2>&5
2939   ac_status=$?
2940   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2941   (exit $ac_status); }; } &&
2942          { ac_try='test -s conftest.$ac_objext'
2943   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2944   (eval $ac_try) 2>&5
2945   ac_status=$?
2946   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2947   (exit $ac_status); }; }; then
2948   :
2949 else
2950   echo "$as_me: failed program was:" >&5
2951 sed 's/^/| /' conftest.$ac_ext >&5
2952
2953 continue
2954 fi
2955 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2956   cat >conftest.$ac_ext <<_ACEOF
2957 /* confdefs.h.  */
2958 _ACEOF
2959 cat confdefs.h >>conftest.$ac_ext
2960 cat >>conftest.$ac_ext <<_ACEOF
2961 /* end confdefs.h.  */
2962 $ac_declaration
2963 int
2964 main ()
2965 {
2966 exit (42);
2967   ;
2968   return 0;
2969 }
2970 _ACEOF
2971 rm -f conftest.$ac_objext
2972 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2973   (eval $ac_compile) 2>conftest.er1
2974   ac_status=$?
2975   grep -v '^ *+' conftest.er1 >conftest.err
2976   rm -f conftest.er1
2977   cat conftest.err >&5
2978   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2979   (exit $ac_status); } &&
2980          { ac_try='test -z "$ac_c_werror_flag"
2981                          || test ! -s conftest.err'
2982   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2983   (eval $ac_try) 2>&5
2984   ac_status=$?
2985   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2986   (exit $ac_status); }; } &&
2987          { ac_try='test -s conftest.$ac_objext'
2988   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2989   (eval $ac_try) 2>&5
2990   ac_status=$?
2991   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2992   (exit $ac_status); }; }; then
2993   break
2994 else
2995   echo "$as_me: failed program was:" >&5
2996 sed 's/^/| /' conftest.$ac_ext >&5
2997
2998 fi
2999 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3000 done
3001 rm -f conftest*
3002 if test -n "$ac_declaration"; then
3003   echo '#ifdef __cplusplus' >>confdefs.h
3004   echo $ac_declaration      >>confdefs.h
3005   echo '#endif'             >>confdefs.h
3006 fi
3007
3008 else
3009   echo "$as_me: failed program was:" >&5
3010 sed 's/^/| /' conftest.$ac_ext >&5
3011
3012 fi
3013 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3014 ac_ext=c
3015 ac_cpp='$CPP $CPPFLAGS'
3016 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3017 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3018 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3019 DEPDIR="${am__leading_dot}deps"
3020
3021           ac_config_commands="$ac_config_commands depfiles"
3022
3023
3024 am_make=${MAKE-make}
3025 cat > confinc << 'END'
3026 am__doit:
3027         @echo done
3028 .PHONY: am__doit
3029 END
3030 # If we don't find an include directive, just comment out the code.
3031 echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
3032 echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6
3033 am__include="#"
3034 am__quote=
3035 _am_result=none
3036 # First try GNU make style include.
3037 echo "include confinc" > confmf
3038 # We grep out `Entering directory' and `Leaving directory'
3039 # messages which can occur if `w' ends up in MAKEFLAGS.
3040 # In particular we don't look at `^make:' because GNU make might
3041 # be invoked under some other name (usually "gmake"), in which
3042 # case it prints its new name instead of `make'.
3043 if test "`$am_make -s -f confmf 2> /dev/null | grep -v 'ing directory'`" = "done"; then
3044    am__include=include
3045    am__quote=
3046    _am_result=GNU
3047 fi
3048 # Now try BSD make style include.
3049 if test "$am__include" = "#"; then
3050    echo '.include "confinc"' > confmf
3051    if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then
3052       am__include=.include
3053       am__quote="\""
3054       _am_result=BSD
3055    fi
3056 fi
3057
3058
3059 echo "$as_me:$LINENO: result: $_am_result" >&5
3060 echo "${ECHO_T}$_am_result" >&6
3061 rm -f confinc confmf
3062
3063 # Check whether --enable-dependency-tracking or --disable-dependency-tracking was given.
3064 if test "${enable_dependency_tracking+set}" = set; then
3065   enableval="$enable_dependency_tracking"
3066
3067 fi;
3068 if test "x$enable_dependency_tracking" != xno; then
3069   am_depcomp="$ac_aux_dir/depcomp"
3070   AMDEPBACKSLASH='\'
3071 fi
3072
3073
3074 if test "x$enable_dependency_tracking" != xno; then
3075   AMDEP_TRUE=
3076   AMDEP_FALSE='#'
3077 else
3078   AMDEP_TRUE='#'
3079   AMDEP_FALSE=
3080 fi
3081
3082
3083
3084
3085 depcc="$CC"   am_compiler_list=
3086
3087 echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
3088 echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6
3089 if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then
3090   echo $ECHO_N "(cached) $ECHO_C" >&6
3091 else
3092   if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
3093   # We make a subdir and do the tests there.  Otherwise we can end up
3094   # making bogus files that we don't know about and never remove.  For
3095   # instance it was reported that on HP-UX the gcc test will end up
3096   # making a dummy file named `D' -- because `-MD' means `put the output
3097   # in D'.
3098   mkdir conftest.dir
3099   # Copy depcomp to subdir because otherwise we won't find it if we're
3100   # using a relative directory.
3101   cp "$am_depcomp" conftest.dir
3102   cd conftest.dir
3103   # We will build objects and dependencies in a subdirectory because
3104   # it helps to detect inapplicable dependency modes.  For instance
3105   # both Tru64's cc and ICC support -MD to output dependencies as a
3106   # side effect of compilation, but ICC will put the dependencies in
3107   # the current directory while Tru64 will put them in the object
3108   # directory.
3109   mkdir sub
3110
3111   am_cv_CC_dependencies_compiler_type=none
3112   if test "$am_compiler_list" = ""; then
3113      am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
3114   fi
3115   for depmode in $am_compiler_list; do
3116     # Setup a source with many dependencies, because some compilers
3117     # like to wrap large dependency lists on column 80 (with \), and
3118     # we should not choose a depcomp mode which is confused by this.
3119     #
3120     # We need to recreate these files for each test, as the compiler may
3121     # overwrite some of them when testing with obscure command lines.
3122     # This happens at least with the AIX C compiler.
3123     : > sub/conftest.c
3124     for i in 1 2 3 4 5 6; do
3125       echo '#include "conftst'$i'.h"' >> sub/conftest.c
3126       # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
3127       # Solaris 8's {/usr,}/bin/sh.
3128       touch sub/conftst$i.h
3129     done
3130     echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
3131
3132     case $depmode in
3133     nosideeffect)
3134       # after this tag, mechanisms are not by side-effect, so they'll
3135       # only be used when explicitly requested
3136       if test "x$enable_dependency_tracking" = xyes; then
3137         continue
3138       else
3139         break
3140       fi
3141       ;;
3142     none) break ;;
3143     esac
3144     # We check with `-c' and `-o' for the sake of the "dashmstdout"
3145     # mode.  It turns out that the SunPro C++ compiler does not properly
3146     # handle `-M -o', and we need to detect this.
3147     if depmode=$depmode \
3148        source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \
3149        depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
3150        $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \
3151          >/dev/null 2>conftest.err &&
3152        grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
3153        grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&
3154        ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
3155       # icc doesn't choke on unknown options, it will just issue warnings
3156       # or remarks (even with -Werror).  So we grep stderr for any message
3157       # that says an option was ignored or not supported.
3158       # When given -MP, icc 7.0 and 7.1 complain thusly:
3159       #   icc: Command line warning: ignoring option '-M'; no argument required
3160       # The diagnosis changed in icc 8.0:
3161       #   icc: Command line remark: option '-MP' not supported
3162       if (grep 'ignoring option' conftest.err ||
3163           grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
3164         am_cv_CC_dependencies_compiler_type=$depmode
3165         break
3166       fi
3167     fi
3168   done
3169
3170   cd ..
3171   rm -rf conftest.dir
3172 else
3173   am_cv_CC_dependencies_compiler_type=none
3174 fi
3175
3176 fi
3177 echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5
3178 echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6
3179 CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
3180
3181
3182
3183 if
3184   test "x$enable_dependency_tracking" != xno \
3185   && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
3186   am__fastdepCC_TRUE=
3187   am__fastdepCC_FALSE='#'
3188 else
3189   am__fastdepCC_TRUE='#'
3190   am__fastdepCC_FALSE=
3191 fi
3192
3193
3194
3195
3196 # Add -Wall -fno-repack-arrays -fno-underscoring if we are using GCC.
3197 if test "x$GCC" = "xyes"; then
3198   AM_FCFLAGS="-I . -Wall -fno-repack-arrays -fno-underscoring"
3199   ## We like to use C99 routines when available.  This makes sure that
3200   ## __STDC_VERSION__ is set such that libc includes make them available.
3201   AM_CFLAGS="-std=gnu99 -Wall -Wstrict-prototypes -Wmissing-prototypes -Wold-style-definition -Wextra -Wwrite-strings"
3202   ## Compile the following tests with the same system header contents
3203   ## that we'll encounter when compiling our own source files.
3204   CFLAGS="-std=gnu99 $CFLAGS"
3205 fi
3206
3207
3208
3209 # Find other programs we need.
3210 if test -n "$ac_tool_prefix"; then
3211   # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
3212 set dummy ${ac_tool_prefix}as; ac_word=$2
3213 echo "$as_me:$LINENO: checking for $ac_word" >&5
3214 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3215 if test "${ac_cv_prog_AS+set}" = set; then
3216   echo $ECHO_N "(cached) $ECHO_C" >&6
3217 else
3218   if test -n "$AS"; then
3219   ac_cv_prog_AS="$AS" # Let the user override the test.
3220 else
3221 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3222 for as_dir in $PATH
3223 do
3224   IFS=$as_save_IFS
3225   test -z "$as_dir" && as_dir=.
3226   for ac_exec_ext in '' $ac_executable_extensions; do
3227   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3228     ac_cv_prog_AS="${ac_tool_prefix}as"
3229     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3230     break 2
3231   fi
3232 done
3233 done
3234
3235 fi
3236 fi
3237 AS=$ac_cv_prog_AS
3238 if test -n "$AS"; then
3239   echo "$as_me:$LINENO: result: $AS" >&5
3240 echo "${ECHO_T}$AS" >&6
3241 else
3242   echo "$as_me:$LINENO: result: no" >&5
3243 echo "${ECHO_T}no" >&6
3244 fi
3245
3246 fi
3247 if test -z "$ac_cv_prog_AS"; then
3248   ac_ct_AS=$AS
3249   # Extract the first word of "as", so it can be a program name with args.
3250 set dummy as; ac_word=$2
3251 echo "$as_me:$LINENO: checking for $ac_word" >&5
3252 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3253 if test "${ac_cv_prog_ac_ct_AS+set}" = set; then
3254   echo $ECHO_N "(cached) $ECHO_C" >&6
3255 else
3256   if test -n "$ac_ct_AS"; then
3257   ac_cv_prog_ac_ct_AS="$ac_ct_AS" # Let the user override the test.
3258 else
3259 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3260 for as_dir in $PATH
3261 do
3262   IFS=$as_save_IFS
3263   test -z "$as_dir" && as_dir=.
3264   for ac_exec_ext in '' $ac_executable_extensions; do
3265   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3266     ac_cv_prog_ac_ct_AS="as"
3267     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3268     break 2
3269   fi
3270 done
3271 done
3272
3273 fi
3274 fi
3275 ac_ct_AS=$ac_cv_prog_ac_ct_AS
3276 if test -n "$ac_ct_AS"; then
3277   echo "$as_me:$LINENO: result: $ac_ct_AS" >&5
3278 echo "${ECHO_T}$ac_ct_AS" >&6
3279 else
3280   echo "$as_me:$LINENO: result: no" >&5
3281 echo "${ECHO_T}no" >&6
3282 fi
3283
3284   AS=$ac_ct_AS
3285 else
3286   AS="$ac_cv_prog_AS"
3287 fi
3288
3289 if test -n "$ac_tool_prefix"; then
3290   # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
3291 set dummy ${ac_tool_prefix}ar; ac_word=$2
3292 echo "$as_me:$LINENO: checking for $ac_word" >&5
3293 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3294 if test "${ac_cv_prog_AR+set}" = set; then
3295   echo $ECHO_N "(cached) $ECHO_C" >&6
3296 else
3297   if test -n "$AR"; then
3298   ac_cv_prog_AR="$AR" # Let the user override the test.
3299 else
3300 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3301 for as_dir in $PATH
3302 do
3303   IFS=$as_save_IFS
3304   test -z "$as_dir" && as_dir=.
3305   for ac_exec_ext in '' $ac_executable_extensions; do
3306   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3307     ac_cv_prog_AR="${ac_tool_prefix}ar"
3308     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3309     break 2
3310   fi
3311 done
3312 done
3313
3314 fi
3315 fi
3316 AR=$ac_cv_prog_AR
3317 if test -n "$AR"; then
3318   echo "$as_me:$LINENO: result: $AR" >&5
3319 echo "${ECHO_T}$AR" >&6
3320 else
3321   echo "$as_me:$LINENO: result: no" >&5
3322 echo "${ECHO_T}no" >&6
3323 fi
3324
3325 fi
3326 if test -z "$ac_cv_prog_AR"; then
3327   ac_ct_AR=$AR
3328   # Extract the first word of "ar", so it can be a program name with args.
3329 set dummy ar; ac_word=$2
3330 echo "$as_me:$LINENO: checking for $ac_word" >&5
3331 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3332 if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
3333   echo $ECHO_N "(cached) $ECHO_C" >&6
3334 else
3335   if test -n "$ac_ct_AR"; then
3336   ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
3337 else
3338 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3339 for as_dir in $PATH
3340 do
3341   IFS=$as_save_IFS
3342   test -z "$as_dir" && as_dir=.
3343   for ac_exec_ext in '' $ac_executable_extensions; do
3344   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3345     ac_cv_prog_ac_ct_AR="ar"
3346     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3347     break 2
3348   fi
3349 done
3350 done
3351
3352 fi
3353 fi
3354 ac_ct_AR=$ac_cv_prog_ac_ct_AR
3355 if test -n "$ac_ct_AR"; then
3356   echo "$as_me:$LINENO: result: $ac_ct_AR" >&5
3357 echo "${ECHO_T}$ac_ct_AR" >&6
3358 else
3359   echo "$as_me:$LINENO: result: no" >&5
3360 echo "${ECHO_T}no" >&6
3361 fi
3362
3363   AR=$ac_ct_AR
3364 else
3365   AR="$ac_cv_prog_AR"
3366 fi
3367
3368 if test -n "$ac_tool_prefix"; then
3369   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3370 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3371 echo "$as_me:$LINENO: checking for $ac_word" >&5
3372 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3373 if test "${ac_cv_prog_RANLIB+set}" = set; then
3374   echo $ECHO_N "(cached) $ECHO_C" >&6
3375 else
3376   if test -n "$RANLIB"; then
3377   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3378 else
3379 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3380 for as_dir in $PATH
3381 do
3382   IFS=$as_save_IFS
3383   test -z "$as_dir" && as_dir=.
3384   for ac_exec_ext in '' $ac_executable_extensions; do
3385   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3386     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3387     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3388     break 2
3389   fi
3390 done
3391 done
3392
3393 fi
3394 fi
3395 RANLIB=$ac_cv_prog_RANLIB
3396 if test -n "$RANLIB"; then
3397   echo "$as_me:$LINENO: result: $RANLIB" >&5
3398 echo "${ECHO_T}$RANLIB" >&6
3399 else
3400   echo "$as_me:$LINENO: result: no" >&5
3401 echo "${ECHO_T}no" >&6
3402 fi
3403
3404 fi
3405 if test -z "$ac_cv_prog_RANLIB"; then
3406   ac_ct_RANLIB=$RANLIB
3407   # Extract the first word of "ranlib", so it can be a program name with args.
3408 set dummy ranlib; ac_word=$2
3409 echo "$as_me:$LINENO: checking for $ac_word" >&5
3410 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3411 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3412   echo $ECHO_N "(cached) $ECHO_C" >&6
3413 else
3414   if test -n "$ac_ct_RANLIB"; then
3415   ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3416 else
3417 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3418 for as_dir in $PATH
3419 do
3420   IFS=$as_save_IFS
3421   test -z "$as_dir" && as_dir=.
3422   for ac_exec_ext in '' $ac_executable_extensions; do
3423   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3424     ac_cv_prog_ac_ct_RANLIB="ranlib"
3425     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3426     break 2
3427   fi
3428 done
3429 done
3430
3431   test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB="ranlib-not-found-in-path-error"
3432 fi
3433 fi
3434 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3435 if test -n "$ac_ct_RANLIB"; then
3436   echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3437 echo "${ECHO_T}$ac_ct_RANLIB" >&6
3438 else
3439   echo "$as_me:$LINENO: result: no" >&5
3440 echo "${ECHO_T}no" >&6
3441 fi
3442
3443   RANLIB=$ac_ct_RANLIB
3444 else
3445   RANLIB="$ac_cv_prog_RANLIB"
3446 fi
3447
3448 echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3449 echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3450 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3451 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3452   echo $ECHO_N "(cached) $ECHO_C" >&6
3453 else
3454   cat >conftest.make <<\_ACEOF
3455 all:
3456         @echo 'ac_maketemp="$(MAKE)"'
3457 _ACEOF
3458 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3459 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3460 if test -n "$ac_maketemp"; then
3461   eval ac_cv_prog_make_${ac_make}_set=yes
3462 else
3463   eval ac_cv_prog_make_${ac_make}_set=no
3464 fi
3465 rm -f conftest.make
3466 fi
3467 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3468   echo "$as_me:$LINENO: result: yes" >&5
3469 echo "${ECHO_T}yes" >&6
3470   SET_MAKE=
3471 else
3472   echo "$as_me:$LINENO: result: no" >&5
3473 echo "${ECHO_T}no" >&6
3474   SET_MAKE="MAKE=${MAKE-make}"
3475 fi
3476
3477 # Find a good install program.  We prefer a C program (faster),
3478 # so one script is as good as another.  But avoid the broken or
3479 # incompatible versions:
3480 # SysV /etc/install, /usr/sbin/install
3481 # SunOS /usr/etc/install
3482 # IRIX /sbin/install
3483 # AIX /bin/install
3484 # AmigaOS /C/install, which installs bootblocks on floppy discs
3485 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3486 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3487 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3488 # OS/2's system install, which has a completely different semantic
3489 # ./install, which can be erroneously created by make from ./install.sh.
3490 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3491 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3492 if test -z "$INSTALL"; then
3493 if test "${ac_cv_path_install+set}" = set; then
3494   echo $ECHO_N "(cached) $ECHO_C" >&6
3495 else
3496   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3497 for as_dir in $PATH
3498 do
3499   IFS=$as_save_IFS
3500   test -z "$as_dir" && as_dir=.
3501   # Account for people who put trailing slashes in PATH elements.
3502 case $as_dir/ in
3503   ./ | .// | /cC/* | \
3504   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3505   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3506   /usr/ucb/* ) ;;
3507   *)
3508     # OSF1 and SCO ODT 3.0 have their own names for install.
3509     # Don't use installbsd from OSF since it installs stuff as root
3510     # by default.
3511     for ac_prog in ginstall scoinst install; do
3512       for ac_exec_ext in '' $ac_executable_extensions; do
3513         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3514           if test $ac_prog = install &&
3515             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3516             # AIX install.  It has an incompatible calling convention.
3517             :
3518           elif test $ac_prog = install &&
3519             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3520             # program-specific install script used by HP pwplus--don't use.
3521             :
3522           else
3523             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3524             break 3
3525           fi
3526         fi
3527       done
3528     done
3529     ;;
3530 esac
3531 done
3532
3533
3534 fi
3535   if test "${ac_cv_path_install+set}" = set; then
3536     INSTALL=$ac_cv_path_install
3537   else
3538     # As a last resort, use the slow shell script.  We don't cache a
3539     # path for INSTALL within a source directory, because that will
3540     # break other packages using the cache if that directory is
3541     # removed, or if the path is relative.
3542     INSTALL=$ac_install_sh
3543   fi
3544 fi
3545 echo "$as_me:$LINENO: result: $INSTALL" >&5
3546 echo "${ECHO_T}$INSTALL" >&6
3547
3548 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3549 # It thinks the first close brace ends the variable substitution.
3550 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3551
3552 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3553
3554 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3555
3556
3557 # Configure libtool
3558 #AC_MSG_NOTICE([====== Starting libtool configuration])
3559
3560 # Check whether --enable-shared or --disable-shared was given.
3561 if test "${enable_shared+set}" = set; then
3562   enableval="$enable_shared"
3563   p=${PACKAGE-default}
3564 case $enableval in
3565 yes) enable_shared=yes ;;
3566 no) enable_shared=no ;;
3567 *)
3568   enable_shared=no
3569   # Look at the argument we got.  We use all the common list separators.
3570   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3571   for pkg in $enableval; do
3572     if test "X$pkg" = "X$p"; then
3573       enable_shared=yes
3574     fi
3575   done
3576   IFS="$ac_save_ifs"
3577   ;;
3578 esac
3579 else
3580   enable_shared=yes
3581 fi;
3582 # Check whether --enable-static or --disable-static was given.
3583 if test "${enable_static+set}" = set; then
3584   enableval="$enable_static"
3585   p=${PACKAGE-default}
3586 case $enableval in
3587 yes) enable_static=yes ;;
3588 no) enable_static=no ;;
3589 *)
3590   enable_static=no
3591   # Look at the argument we got.  We use all the common list separators.
3592   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3593   for pkg in $enableval; do
3594     if test "X$pkg" = "X$p"; then
3595       enable_static=yes
3596     fi
3597   done
3598   IFS="$ac_save_ifs"
3599   ;;
3600 esac
3601 else
3602   enable_static=yes
3603 fi;
3604 # Check whether --enable-fast-install or --disable-fast-install was given.
3605 if test "${enable_fast_install+set}" = set; then
3606   enableval="$enable_fast_install"
3607   p=${PACKAGE-default}
3608 case $enableval in
3609 yes) enable_fast_install=yes ;;
3610 no) enable_fast_install=no ;;
3611 *)
3612   enable_fast_install=no
3613   # Look at the argument we got.  We use all the common list separators.
3614   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3615   for pkg in $enableval; do
3616     if test "X$pkg" = "X$p"; then
3617       enable_fast_install=yes
3618     fi
3619   done
3620   IFS="$ac_save_ifs"
3621   ;;
3622 esac
3623 else
3624   enable_fast_install=yes
3625 fi;
3626
3627 # Check whether --with-gnu-ld or --without-gnu-ld was given.
3628 if test "${with_gnu_ld+set}" = set; then
3629   withval="$with_gnu_ld"
3630   test "$withval" = no || with_gnu_ld=yes
3631 else
3632   with_gnu_ld=no
3633 fi;
3634 ac_prog=ld
3635 if test "$GCC" = yes; then
3636   # Check if gcc -print-prog-name=ld gives a path.
3637   echo "$as_me:$LINENO: checking for ld used by GCC" >&5
3638 echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6
3639   case $host in
3640   *-*-mingw*)
3641     # gcc leaves a trailing carriage return which upsets mingw
3642     ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
3643   *)
3644     ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
3645   esac
3646   case $ac_prog in
3647     # Accept absolute paths.
3648     [\\/]* | [A-Za-z]:[\\/]*)
3649       re_direlt='/[^/][^/]*/\.\./'
3650       # Canonicalize the path of ld
3651       ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
3652       while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
3653         ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
3654       done
3655       test -z "$LD" && LD="$ac_prog"
3656       ;;
3657   "")
3658     # If it fails, then pretend we aren't using GCC.
3659     ac_prog=ld
3660     ;;
3661   *)
3662     # If it is relative, then search for the first ld in PATH.
3663     with_gnu_ld=unknown
3664     ;;
3665   esac
3666 elif test "$with_gnu_ld" = yes; then
3667   echo "$as_me:$LINENO: checking for GNU ld" >&5
3668 echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6
3669 else
3670   echo "$as_me:$LINENO: checking for non-GNU ld" >&5
3671 echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6
3672 fi
3673 if test "${lt_cv_path_LD+set}" = set; then
3674   echo $ECHO_N "(cached) $ECHO_C" >&6
3675 else
3676   if test -z "$LD"; then
3677   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
3678   for ac_dir in $PATH; do
3679     test -z "$ac_dir" && ac_dir=.
3680     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
3681       lt_cv_path_LD="$ac_dir/$ac_prog"
3682       # Check to see if the program is GNU ld.  I'd rather use --version,
3683       # but apparently some GNU ld's only accept -v.
3684       # Break only if it was the GNU/non-GNU ld that we prefer.
3685       if "$lt_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
3686         test "$with_gnu_ld" != no && break
3687       else
3688         test "$with_gnu_ld" != yes && break
3689       fi
3690     fi
3691   done
3692   IFS="$ac_save_ifs"
3693 else
3694   lt_cv_path_LD="$LD" # Let the user override the test with a path.
3695 fi
3696 fi
3697
3698 LD="$lt_cv_path_LD"
3699 if test -n "$LD"; then
3700   echo "$as_me:$LINENO: result: $LD" >&5
3701 echo "${ECHO_T}$LD" >&6
3702 else
3703   echo "$as_me:$LINENO: result: no" >&5
3704 echo "${ECHO_T}no" >&6
3705 fi
3706 test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5
3707 echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}
3708    { (exit 1); exit 1; }; }
3709 echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
3710 echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6
3711 if test "${lt_cv_prog_gnu_ld+set}" = set; then
3712   echo $ECHO_N "(cached) $ECHO_C" >&6
3713 else
3714   # I'd rather use --version here, but apparently some GNU ld's only accept -v.
3715 if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
3716   lt_cv_prog_gnu_ld=yes
3717 else
3718   lt_cv_prog_gnu_ld=no
3719 fi
3720 fi
3721 echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
3722 echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6
3723 with_gnu_ld=$lt_cv_prog_gnu_ld
3724
3725
3726 echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
3727 echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6
3728 if test "${lt_cv_ld_reload_flag+set}" = set; then
3729   echo $ECHO_N "(cached) $ECHO_C" >&6
3730 else
3731   lt_cv_ld_reload_flag='-r'
3732 fi
3733 echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
3734 echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6
3735 reload_flag=$lt_cv_ld_reload_flag
3736 test -n "$reload_flag" && reload_flag=" $reload_flag"
3737
3738 echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
3739 echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6
3740 if test "${lt_cv_path_NM+set}" = set; then
3741   echo $ECHO_N "(cached) $ECHO_C" >&6
3742 else
3743   if test -n "$NM"; then
3744   # Let the user override the test.
3745   lt_cv_path_NM="$NM"
3746 else
3747   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
3748   for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
3749     test -z "$ac_dir" && ac_dir=.
3750     tmp_nm=$ac_dir/${ac_tool_prefix}nm
3751     if test -f $tmp_nm || test -f $tmp_nm$ac_exeext ; then
3752       # Check to see if the nm accepts a BSD-compat flag.
3753       # Adding the `sed 1q' prevents false positives on HP-UX, which says:
3754       #   nm: unknown option "B" ignored
3755       # Tru64's nm complains that /dev/null is an invalid object file
3756       if ($tmp_nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep '(/dev/null|Invalid file or object type)' >/dev/null; then
3757         lt_cv_path_NM="$tmp_nm -B"
3758         break
3759       elif ($tmp_nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
3760         lt_cv_path_NM="$tmp_nm -p"
3761         break
3762       else
3763         lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
3764         continue # so that we can try to find one that supports BSD flags
3765       fi
3766     fi
3767   done
3768   IFS="$ac_save_ifs"
3769   test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm
3770 fi
3771 fi
3772
3773 NM="$lt_cv_path_NM"
3774 echo "$as_me:$LINENO: result: $NM" >&5
3775 echo "${ECHO_T}$NM" >&6
3776
3777 echo "$as_me:$LINENO: checking whether ln -s works" >&5
3778 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3779 LN_S=$as_ln_s
3780 if test "$LN_S" = "ln -s"; then
3781   echo "$as_me:$LINENO: result: yes" >&5
3782 echo "${ECHO_T}yes" >&6
3783 else
3784   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3785 echo "${ECHO_T}no, using $LN_S" >&6
3786 fi
3787
3788 echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5
3789 echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6
3790 if test "${lt_cv_deplibs_check_method+set}" = set; then
3791   echo $ECHO_N "(cached) $ECHO_C" >&6
3792 else
3793   lt_cv_file_magic_cmd='$MAGIC_CMD'
3794 lt_cv_file_magic_test_file=
3795 lt_cv_deplibs_check_method='unknown'
3796 # Need to set the preceding variable on all platforms that support
3797 # interlibrary dependencies.
3798 # 'none' -- dependencies not supported.
3799 # `unknown' -- same as none, but documents that we really don't know.
3800 # 'pass_all' -- all dependencies passed with no checks.
3801 # 'test_compile' -- check by making test program.
3802 # 'file_magic [regex]' -- check by looking for files in library path
3803 # which responds to the $file_magic_cmd with a given egrep regex.
3804 # If you have `file' or equivalent on your system and you're not sure
3805 # whether `pass_all' will *always* work, you probably want this one.
3806
3807 case $host_os in
3808 aix*)
3809   lt_cv_deplibs_check_method=pass_all
3810   ;;
3811
3812 beos*)
3813   lt_cv_deplibs_check_method=pass_all
3814   ;;
3815
3816 bsdi4*)
3817   lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
3818   lt_cv_file_magic_cmd='/usr/bin/file -L'
3819   lt_cv_file_magic_test_file=/shlib/libc.so
3820   ;;
3821
3822 cygwin* | mingw* |pw32*)
3823   lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
3824   lt_cv_file_magic_cmd='$OBJDUMP -f'
3825   ;;
3826
3827 darwin* | rhapsody*)
3828   # this will be overwritten by pass_all, but leave it in just in case
3829   lt_cv_deplibs_check_method='file_magic Mach-O dynamically linked shared library'
3830   lt_cv_file_magic_cmd='/usr/bin/file -L'
3831   case "$host_os" in
3832   rhapsody* | darwin1.012)
3833     lt_cv_file_magic_test_file='/System/Library/Frameworks/System.framework/System'
3834     ;;
3835   *) # Darwin 1.3 on
3836     lt_cv_file_magic_test_file='/usr/lib/libSystem.dylib'
3837     ;;
3838   esac
3839   lt_cv_deplibs_check_method=pass_all
3840   ;;
3841
3842 freebsd* | kfreebsd*-gnu)
3843   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
3844     case $host_cpu in
3845     i*86 )
3846       # Not sure whether the presence of OpenBSD here was a mistake.
3847       # Let's accept both of them until this is cleared up.
3848       lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[3-9]86 (compact )?demand paged shared library'
3849       lt_cv_file_magic_cmd=/usr/bin/file
3850       lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
3851       ;;
3852     esac
3853   else
3854     lt_cv_deplibs_check_method=pass_all
3855   fi
3856   ;;
3857
3858 gnu*)
3859   lt_cv_deplibs_check_method=pass_all
3860   ;;
3861
3862 hpux10.20*|hpux11*)
3863   case $host_cpu in
3864   hppa*)
3865     lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library'
3866     lt_cv_file_magic_cmd=/usr/bin/file
3867     lt_cv_file_magic_test_file=/usr/lib/libc.sl
3868     ;;
3869   ia64*)
3870     lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
3871     lt_cv_file_magic_cmd=/usr/bin/file
3872     lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
3873     ;;
3874   esac
3875   ;;
3876
3877 irix5* | irix6*)
3878   case $host_os in
3879   irix5*)
3880     # this will be overridden with pass_all, but let us keep it just in case
3881     lt_cv_deplibs_check_method="file_magic ELF 32-bit MSB dynamic lib MIPS - version 1"
3882     ;;
3883   *)
3884     case $LD in
3885     *-32|*"-32 ") libmagic=32-bit;;
3886     *-n32|*"-n32 ") libmagic=N32;;
3887     *-64|*"-64 ") libmagic=64-bit;;
3888     *) libmagic=never-match;;
3889     esac
3890     # this will be overridden with pass_all, but let us keep it just in case
3891     lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[1234] dynamic lib MIPS - version 1"
3892     ;;
3893   esac
3894   lt_cv_file_magic_test_file=`echo /lib${libsuff}/libc.so*`
3895   lt_cv_deplibs_check_method=pass_all
3896   ;;
3897
3898 # This must be Linux ELF.
3899 linux-gnu*)
3900   lt_cv_deplibs_check_method=pass_all
3901   ;;
3902
3903 netbsd* | knetbsd*-gnu)
3904   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
3905     lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so\.[0-9]+\.[0-9]+$'
3906   else
3907     lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so$'
3908   fi
3909   ;;
3910
3911 newsos6)
3912   lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'
3913   lt_cv_file_magic_cmd=/usr/bin/file
3914   lt_cv_file_magic_test_file=/usr/lib/libnls.so
3915   ;;
3916
3917 osf3* | osf4* | osf5*)
3918   # this will be overridden with pass_all, but let us keep it just in case
3919   lt_cv_deplibs_check_method='file_magic COFF format alpha shared library'
3920   lt_cv_file_magic_test_file=/shlib/libc.so
3921   lt_cv_deplibs_check_method=pass_all
3922   ;;
3923
3924 sco3.2v5*)
3925   lt_cv_deplibs_check_method=pass_all
3926   ;;
3927
3928 solaris*)
3929   lt_cv_deplibs_check_method=pass_all
3930   lt_cv_file_magic_test_file=/lib/libc.so
3931   ;;
3932
3933 sysv5uw[78]* | sysv4*uw2*)
3934   lt_cv_deplibs_check_method=pass_all
3935   ;;
3936
3937 sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
3938   case $host_vendor in
3939   ncr)
3940     lt_cv_deplibs_check_method=pass_all
3941     ;;
3942   motorola)
3943     lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'
3944     lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
3945     ;;
3946   esac
3947   ;;
3948 esac
3949
3950 fi
3951 echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
3952 echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6
3953 file_magic_cmd=$lt_cv_file_magic_cmd
3954 deplibs_check_method=$lt_cv_deplibs_check_method
3955
3956
3957
3958
3959
3960 # Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
3961
3962 # find the maximum length of command line arguments
3963 echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
3964 echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6
3965 if test "${lt_cv_sys_max_cmd_len+set}" = set; then
3966   echo $ECHO_N "(cached) $ECHO_C" >&6
3967 else
3968     i=0
3969   teststring="ABCD"
3970
3971   case $build_os in
3972   msdosdjgpp*)
3973     # On DJGPP, this test can blow up pretty badly due to problems in libc
3974     # (any single argument exceeding 2000 bytes causes a buffer overrun
3975     # during glob expansion).  Even if it were fixed, the result of this
3976     # check would be larger than it should be.
3977     lt_cv_sys_max_cmd_len=12288;    # 12K is about right
3978     ;;
3979
3980   cygwin* | mingw*)
3981     # On Win9x/ME, this test blows up -- it succeeds, but takes
3982     # about 5 minutes as the teststring grows exponentially.
3983     # Worse, since 9x/ME are not pre-emptively multitasking,
3984     # you end up with a "frozen" computer, even though with patience
3985     # the test eventually succeeds (with a max line length of 256k).
3986     # Instead, let's just punt: use the minimum linelength reported by
3987     # all of the supported platforms: 8192 (on NT/2K/XP).
3988     lt_cv_sys_max_cmd_len=8192;
3989     ;;
3990
3991   amigaos*)
3992     # On AmigaOS with pdksh, this test takes hours, literally.
3993     # So we just punt and use a minimum line length of 8192.
3994     lt_cv_sys_max_cmd_len=8192;
3995     ;;
3996
3997   netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
3998     # This has been around since 386BSD, at least.  Likely further.
3999     if test -x /sbin/sysctl; then
4000       lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
4001     elif test -x /usr/sbin/sysctl; then
4002       lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
4003     else
4004       lt_cv_sys_max_cmd_len=65536 # usable default for *BSD
4005     fi
4006     # And add a safety zone
4007     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
4008     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
4009     ;;
4010   esac
4011
4012 fi
4013
4014 if test -n "$lt_cv_sys_max_cmd_len" ; then
4015   echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
4016 echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6
4017 else
4018   echo "$as_me:$LINENO: result: none" >&5
4019 echo "${ECHO_T}none" >&6
4020 fi
4021
4022
4023 # Only perform the check for file, if the check method requires it
4024 case $deplibs_check_method in
4025 file_magic*)
4026   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
4027     echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
4028 echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6
4029 if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
4030   echo $ECHO_N "(cached) $ECHO_C" >&6
4031 else
4032   case $MAGIC_CMD in
4033   /*)
4034   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
4035   ;;
4036   ?:/*)
4037   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
4038   ;;
4039   *)
4040   ac_save_MAGIC_CMD="$MAGIC_CMD"
4041   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4042   ac_dummy="/usr/bin:$PATH"
4043   for ac_dir in $ac_dummy; do
4044     test -z "$ac_dir" && ac_dir=.
4045     if test -f $ac_dir/${ac_tool_prefix}file; then
4046       lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
4047       if test -n "$file_magic_test_file"; then
4048         case $deplibs_check_method in
4049         "file_magic "*)
4050           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
4051           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
4052           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
4053             egrep "$file_magic_regex" > /dev/null; then
4054             :
4055           else
4056             cat <<EOF 1>&2
4057
4058 *** Warning: the command libtool uses to detect shared libraries,
4059 *** $file_magic_cmd, produces output that libtool cannot recognize.
4060 *** The result is that libtool may fail to recognize shared libraries
4061 *** as such.  This will affect the creation of libtool libraries that
4062 *** depend on shared libraries, but programs linked with such libtool
4063 *** libraries will work regardless of this problem.  Nevertheless, you
4064 *** may want to report the problem to your system manager and/or to
4065 *** bug-libtool@gnu.org
4066
4067 EOF
4068           fi ;;
4069         esac
4070       fi
4071       break
4072     fi
4073   done
4074   IFS="$ac_save_ifs"
4075   MAGIC_CMD="$ac_save_MAGIC_CMD"
4076   ;;
4077 esac
4078 fi
4079
4080 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
4081 if test -n "$MAGIC_CMD"; then
4082   echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
4083 echo "${ECHO_T}$MAGIC_CMD" >&6
4084 else
4085   echo "$as_me:$LINENO: result: no" >&5
4086 echo "${ECHO_T}no" >&6
4087 fi
4088
4089 if test -z "$lt_cv_path_MAGIC_CMD"; then
4090   if test -n "$ac_tool_prefix"; then
4091     echo "$as_me:$LINENO: checking for file" >&5
4092 echo $ECHO_N "checking for file... $ECHO_C" >&6
4093 if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
4094   echo $ECHO_N "(cached) $ECHO_C" >&6
4095 else
4096   case $MAGIC_CMD in
4097   /*)
4098   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
4099   ;;
4100   ?:/*)
4101   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
4102   ;;
4103   *)
4104   ac_save_MAGIC_CMD="$MAGIC_CMD"
4105   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4106   ac_dummy="/usr/bin:$PATH"
4107   for ac_dir in $ac_dummy; do
4108     test -z "$ac_dir" && ac_dir=.
4109     if test -f $ac_dir/file; then
4110       lt_cv_path_MAGIC_CMD="$ac_dir/file"
4111       if test -n "$file_magic_test_file"; then
4112         case $deplibs_check_method in
4113         "file_magic "*)
4114           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
4115           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
4116           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
4117             egrep "$file_magic_regex" > /dev/null; then
4118             :
4119           else
4120             cat <<EOF 1>&2
4121
4122 *** Warning: the command libtool uses to detect shared libraries,
4123 *** $file_magic_cmd, produces output that libtool cannot recognize.
4124 *** The result is that libtool may fail to recognize shared libraries
4125 *** as such.  This will affect the creation of libtool libraries that
4126 *** depend on shared libraries, but programs linked with such libtool
4127 *** libraries will work regardless of this problem.  Nevertheless, you
4128 *** may want to report the problem to your system manager and/or to
4129 *** bug-libtool@gnu.org
4130
4131 EOF
4132           fi ;;
4133         esac
4134       fi
4135       break
4136     fi
4137   done
4138   IFS="$ac_save_ifs"
4139   MAGIC_CMD="$ac_save_MAGIC_CMD"
4140   ;;
4141 esac
4142 fi
4143
4144 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
4145 if test -n "$MAGIC_CMD"; then
4146   echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
4147 echo "${ECHO_T}$MAGIC_CMD" >&6
4148 else
4149   echo "$as_me:$LINENO: result: no" >&5
4150 echo "${ECHO_T}no" >&6
4151 fi
4152
4153   else
4154     MAGIC_CMD=:
4155   fi
4156 fi
4157
4158   fi
4159   ;;
4160 esac
4161
4162 if test -n "$ac_tool_prefix"; then
4163   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
4164 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
4165 echo "$as_me:$LINENO: checking for $ac_word" >&5
4166 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4167 if test "${ac_cv_prog_RANLIB+set}" = set; then
4168   echo $ECHO_N "(cached) $ECHO_C" >&6
4169 else
4170   if test -n "$RANLIB"; then
4171   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
4172 else
4173 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4174 for as_dir in $PATH
4175 do
4176   IFS=$as_save_IFS
4177   test -z "$as_dir" && as_dir=.
4178   for ac_exec_ext in '' $ac_executable_extensions; do
4179   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4180     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
4181     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4182     break 2
4183   fi
4184 done
4185 done
4186
4187 fi
4188 fi
4189 RANLIB=$ac_cv_prog_RANLIB
4190 if test -n "$RANLIB"; then
4191   echo "$as_me:$LINENO: result: $RANLIB" >&5
4192 echo "${ECHO_T}$RANLIB" >&6
4193 else
4194   echo "$as_me:$LINENO: result: no" >&5
4195 echo "${ECHO_T}no" >&6
4196 fi
4197
4198 fi
4199 if test -z "$ac_cv_prog_RANLIB"; then
4200   ac_ct_RANLIB=$RANLIB
4201   # Extract the first word of "ranlib", so it can be a program name with args.
4202 set dummy ranlib; ac_word=$2
4203 echo "$as_me:$LINENO: checking for $ac_word" >&5
4204 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4205 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
4206   echo $ECHO_N "(cached) $ECHO_C" >&6
4207 else
4208   if test -n "$ac_ct_RANLIB"; then
4209   ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
4210 else
4211 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4212 for as_dir in $PATH
4213 do
4214   IFS=$as_save_IFS
4215   test -z "$as_dir" && as_dir=.
4216   for ac_exec_ext in '' $ac_executable_extensions; do
4217   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4218     ac_cv_prog_ac_ct_RANLIB="ranlib"
4219     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4220     break 2
4221   fi
4222 done
4223 done
4224
4225   test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
4226 fi
4227 fi
4228 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
4229 if test -n "$ac_ct_RANLIB"; then
4230   echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
4231 echo "${ECHO_T}$ac_ct_RANLIB" >&6
4232 else
4233   echo "$as_me:$LINENO: result: no" >&5
4234 echo "${ECHO_T}no" >&6
4235 fi
4236
4237   RANLIB=$ac_ct_RANLIB
4238 else
4239   RANLIB="$ac_cv_prog_RANLIB"
4240 fi
4241
4242 if test -n "$ac_tool_prefix"; then
4243   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
4244 set dummy ${ac_tool_prefix}strip; ac_word=$2
4245 echo "$as_me:$LINENO: checking for $ac_word" >&5
4246 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4247 if test "${ac_cv_prog_STRIP+set}" = set; then
4248   echo $ECHO_N "(cached) $ECHO_C" >&6
4249 else
4250   if test -n "$STRIP"; then
4251   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
4252 else
4253 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4254 for as_dir in $PATH
4255 do
4256   IFS=$as_save_IFS
4257   test -z "$as_dir" && as_dir=.
4258   for ac_exec_ext in '' $ac_executable_extensions; do
4259   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4260     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
4261     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4262     break 2
4263   fi
4264 done
4265 done
4266
4267 fi
4268 fi
4269 STRIP=$ac_cv_prog_STRIP
4270 if test -n "$STRIP"; then
4271   echo "$as_me:$LINENO: result: $STRIP" >&5
4272 echo "${ECHO_T}$STRIP" >&6
4273 else
4274   echo "$as_me:$LINENO: result: no" >&5
4275 echo "${ECHO_T}no" >&6
4276 fi
4277
4278 fi
4279 if test -z "$ac_cv_prog_STRIP"; then
4280   ac_ct_STRIP=$STRIP
4281   # Extract the first word of "strip", so it can be a program name with args.
4282 set dummy strip; ac_word=$2
4283 echo "$as_me:$LINENO: checking for $ac_word" >&5
4284 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4285 if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
4286   echo $ECHO_N "(cached) $ECHO_C" >&6
4287 else
4288   if test -n "$ac_ct_STRIP"; then
4289   ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
4290 else
4291 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4292 for as_dir in $PATH
4293 do
4294   IFS=$as_save_IFS
4295   test -z "$as_dir" && as_dir=.
4296   for ac_exec_ext in '' $ac_executable_extensions; do
4297   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4298     ac_cv_prog_ac_ct_STRIP="strip"
4299     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4300     break 2
4301   fi
4302 done
4303 done
4304
4305   test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
4306 fi
4307 fi
4308 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
4309 if test -n "$ac_ct_STRIP"; then
4310   echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
4311 echo "${ECHO_T}$ac_ct_STRIP" >&6
4312 else
4313   echo "$as_me:$LINENO: result: no" >&5
4314 echo "${ECHO_T}no" >&6
4315 fi
4316
4317   STRIP=$ac_ct_STRIP
4318 else
4319   STRIP="$ac_cv_prog_STRIP"
4320 fi
4321
4322
4323 # Check for any special flags to pass to ltconfig.
4324 libtool_flags="--cache-file=$cache_file"
4325 test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
4326 test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
4327 test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
4328 test "$GCC" = yes && libtool_flags="$libtool_flags --with-gcc"
4329 test "$lt_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
4330
4331
4332 # Check whether --enable-libtool-lock or --disable-libtool-lock was given.
4333 if test "${enable_libtool_lock+set}" = set; then
4334   enableval="$enable_libtool_lock"
4335
4336 fi;
4337 test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
4338 test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
4339
4340
4341 # Check whether --with-pic or --without-pic was given.
4342 if test "${with_pic+set}" = set; then
4343   withval="$with_pic"
4344   pic_mode="$withval"
4345 else
4346   pic_mode=default
4347 fi;
4348 test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic"
4349 test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
4350
4351 # Some flags need to be propagated to the compiler or linker for good
4352 # libtool support.
4353 case $host in
4354 *-*-irix6*)
4355   # Find out which ABI we are using.
4356   echo '#line 4356 "configure"' > conftest.$ac_ext
4357   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4358   (eval $ac_compile) 2>&5
4359   ac_status=$?
4360   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4361   (exit $ac_status); }; then
4362    if test "$lt_cv_prog_gnu_ld" = yes; then
4363     case `/usr/bin/file conftest.$ac_objext` in
4364     *32-bit*)
4365       LD="${LD-ld} -melf32bsmip"
4366       ;;
4367     *N32*)
4368       LD="${LD-ld} -melf32bmipn32"
4369       ;;
4370     *64-bit*)
4371       LD="${LD-ld} -melf64bmip"
4372       ;;
4373     esac
4374    else
4375     case `/usr/bin/file conftest.$ac_objext` in
4376     *32-bit*)
4377       LD="${LD-ld} -32"
4378       ;;
4379     *N32*)
4380       LD="${LD-ld} -n32"
4381       ;;
4382     *64-bit*)
4383       LD="${LD-ld} -64"
4384       ;;
4385     esac
4386    fi
4387   fi
4388   rm -rf conftest*
4389   ;;
4390
4391 ia64-*-hpux*)
4392   # Find out which ABI we are using.
4393   echo 'int i;' > conftest.$ac_ext
4394   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4395   (eval $ac_compile) 2>&5
4396   ac_status=$?
4397   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4398   (exit $ac_status); }; then
4399     case "`/usr/bin/file conftest.o`" in
4400     *ELF-32*)
4401       HPUX_IA64_MODE="32"
4402       ;;
4403     *ELF-64*)
4404       HPUX_IA64_MODE="64"
4405       ;;
4406     esac
4407   fi
4408   rm -rf conftest*
4409   ;;
4410
4411 x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*)
4412   # Find out which ABI we are using.
4413   echo 'int i;' > conftest.$ac_ext
4414   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4415   (eval $ac_compile) 2>&5
4416   ac_status=$?
4417   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4418   (exit $ac_status); }; then
4419     case "`/usr/bin/file conftest.o`" in
4420     *32-bit*)
4421       case $host in
4422         x86_64-*linux*)
4423           LD="${LD-ld} -m elf_i386"
4424           ;;
4425         ppc64-*linux*|powerpc64-*linux*)
4426           LD="${LD-ld} -m elf32ppclinux"
4427           ;;
4428         s390x-*linux*)
4429           LD="${LD-ld} -m elf_s390"
4430           ;;
4431         sparc64-*linux*)
4432           LD="${LD-ld} -m elf32_sparc"
4433           ;;
4434       esac
4435       ;;
4436     *64-bit*)
4437       case $host in
4438         x86_64-*linux*)
4439           LD="${LD-ld} -m elf_x86_64"
4440           ;;
4441         ppc*-*linux*|powerpc*-*linux*)
4442           LD="${LD-ld} -m elf64ppc"
4443           ;;
4444         s390*-*linux*)
4445           LD="${LD-ld} -m elf64_s390"
4446           ;;
4447         sparc*-*linux*)
4448           LD="${LD-ld} -m elf64_sparc"
4449           ;;
4450       esac
4451       ;;
4452     esac
4453   fi
4454   rm -rf conftest*
4455   ;;
4456
4457 *-*-sco3.2v5*)
4458   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
4459   SAVE_CFLAGS="$CFLAGS"
4460   CFLAGS="$CFLAGS -belf"
4461   echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
4462 echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6
4463 if test "${lt_cv_cc_needs_belf+set}" = set; then
4464   echo $ECHO_N "(cached) $ECHO_C" >&6
4465 else
4466
4467
4468      ac_ext=c
4469 ac_cpp='$CPP $CPPFLAGS'
4470 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4471 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4472 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4473
4474      if test x$gcc_no_link = xyes; then
4475   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
4476 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
4477    { (exit 1); exit 1; }; }
4478 fi
4479 cat >conftest.$ac_ext <<_ACEOF
4480 /* confdefs.h.  */
4481 _ACEOF
4482 cat confdefs.h >>conftest.$ac_ext
4483 cat >>conftest.$ac_ext <<_ACEOF
4484 /* end confdefs.h.  */
4485
4486 int
4487 main ()
4488 {
4489
4490   ;
4491   return 0;
4492 }
4493 _ACEOF
4494 rm -f conftest.$ac_objext conftest$ac_exeext
4495 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4496   (eval $ac_link) 2>conftest.er1
4497   ac_status=$?
4498   grep -v '^ *+' conftest.er1 >conftest.err
4499   rm -f conftest.er1
4500   cat conftest.err >&5
4501   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4502   (exit $ac_status); } &&
4503          { ac_try='test -z "$ac_c_werror_flag"
4504                          || test ! -s conftest.err'
4505   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4506   (eval $ac_try) 2>&5
4507   ac_status=$?
4508   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4509   (exit $ac_status); }; } &&
4510          { ac_try='test -s conftest$ac_exeext'
4511   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4512   (eval $ac_try) 2>&5
4513   ac_status=$?
4514   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4515   (exit $ac_status); }; }; then
4516   lt_cv_cc_needs_belf=yes
4517 else
4518   echo "$as_me: failed program was:" >&5
4519 sed 's/^/| /' conftest.$ac_ext >&5
4520
4521 lt_cv_cc_needs_belf=no
4522 fi
4523 rm -f conftest.err conftest.$ac_objext \
4524       conftest$ac_exeext conftest.$ac_ext
4525      ac_ext=c
4526 ac_cpp='$CPP $CPPFLAGS'
4527 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4528 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4529 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4530
4531 fi
4532 echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
4533 echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6
4534   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
4535     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
4536     CFLAGS="$SAVE_CFLAGS"
4537   fi
4538   ;;
4539
4540
4541 esac
4542
4543
4544 # Save cache, so that ltconfig can load it
4545 cat >confcache <<\_ACEOF
4546 # This file is a shell script that caches the results of configure
4547 # tests run on this system so they can be shared between configure
4548 # scripts and configure runs, see configure's option --config-cache.
4549 # It is not useful on other systems.  If it contains results you don't
4550 # want to keep, you may remove or edit it.
4551 #
4552 # config.status only pays attention to the cache file if you give it
4553 # the --recheck option to rerun configure.
4554 #
4555 # `ac_cv_env_foo' variables (set or unset) will be overridden when
4556 # loading this file, other *unset* `ac_cv_foo' will be assigned the
4557 # following values.
4558
4559 _ACEOF
4560
4561 # The following way of writing the cache mishandles newlines in values,
4562 # but we know of no workaround that is simple, portable, and efficient.
4563 # So, don't put newlines in cache variables' values.
4564 # Ultrix sh set writes to stderr and can't be redirected directly,
4565 # and sets the high bit in the cache file unless we assign to the vars.
4566 {
4567   (set) 2>&1 |
4568     case `(ac_space=' '; set | grep ac_space) 2>&1` in
4569     *ac_space=\ *)
4570       # `set' does not quote correctly, so add quotes (double-quote
4571       # substitution turns \\\\ into \\, and sed turns \\ into \).
4572       sed -n \
4573         "s/'/'\\\\''/g;
4574           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
4575       ;;
4576     *)
4577       # `set' quotes correctly as required by POSIX, so do not add quotes.
4578       sed -n \
4579         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
4580       ;;
4581     esac;
4582 } |
4583   sed '
4584      t clear
4585      : clear
4586      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
4587      t end
4588      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
4589      : end' >>confcache
4590 if diff $cache_file confcache >/dev/null 2>&1; then :; else
4591   if test -w $cache_file; then
4592     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
4593     cat confcache >$cache_file
4594   else
4595     echo "not updating unwritable cache $cache_file"
4596   fi
4597 fi
4598 rm -f confcache
4599
4600 # Actually configure libtool.  ac_aux_dir is where install-sh is found.
4601 AR="$AR" LTCC="$CC" CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
4602 MAGIC_CMD="$MAGIC_CMD" LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
4603 LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \
4604 AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \
4605 objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \
4606 deplibs_check_method="$deplibs_check_method" file_magic_cmd="$file_magic_cmd" \
4607 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
4608 $libtool_flags --no-verify --build="$build" $ac_aux_dir/ltmain.sh $host \
4609 || { { echo "$as_me:$LINENO: error: libtool configure failed" >&5
4610 echo "$as_me: error: libtool configure failed" >&2;}
4611    { (exit 1); exit 1; }; }
4612
4613 # Reload cache, that may have been modified by ltconfig
4614 if test -r "$cache_file"; then
4615   # Some versions of bash will fail to source /dev/null (special
4616   # files actually), so we avoid doing that.
4617   if test -f "$cache_file"; then
4618     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
4619 echo "$as_me: loading cache $cache_file" >&6;}
4620     case $cache_file in
4621       [\\/]* | ?:[\\/]* ) . $cache_file;;
4622       *)                      . ./$cache_file;;
4623     esac
4624   fi
4625 else
4626   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
4627 echo "$as_me: creating cache $cache_file" >&6;}
4628   >$cache_file
4629 fi
4630
4631
4632 # This can be used to rebuild libtool when needed
4633 LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh $ac_aux_dir/ltcf-c.sh"
4634
4635 # Always use our own libtool.
4636 LIBTOOL='$(SHELL) $(top_builddir)/libtool'
4637
4638 # Redirect the config.log output again, so that the ltconfig log is not
4639 # clobbered by the next message.
4640 exec 5>>./config.log
4641
4642
4643
4644
4645
4646
4647
4648
4649 #AC_MSG_NOTICE([====== Finished libtool configuration]) ; sleep 10
4650
4651 # We need gfortran to compile parts of the library
4652 #AC_PROG_FC(gfortran)
4653 FC="$GFORTRAN"
4654 ac_ext=${FC_SRCEXT-f}
4655 ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4656 ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4657 ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4658 if test -n "$ac_tool_prefix"; then
4659   for ac_prog in gfortran
4660   do
4661     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4662 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4663 echo "$as_me:$LINENO: checking for $ac_word" >&5
4664 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4665 if test "${ac_cv_prog_FC+set}" = set; then
4666   echo $ECHO_N "(cached) $ECHO_C" >&6
4667 else
4668   if test -n "$FC"; then
4669   ac_cv_prog_FC="$FC" # Let the user override the test.
4670 else
4671 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4672 for as_dir in $PATH
4673 do
4674   IFS=$as_save_IFS
4675   test -z "$as_dir" && as_dir=.
4676   for ac_exec_ext in '' $ac_executable_extensions; do
4677   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4678     ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
4679     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4680     break 2
4681   fi
4682 done
4683 done
4684
4685 fi
4686 fi
4687 FC=$ac_cv_prog_FC
4688 if test -n "$FC"; then
4689   echo "$as_me:$LINENO: result: $FC" >&5
4690 echo "${ECHO_T}$FC" >&6
4691 else
4692   echo "$as_me:$LINENO: result: no" >&5
4693 echo "${ECHO_T}no" >&6
4694 fi
4695
4696     test -n "$FC" && break
4697   done
4698 fi
4699 if test -z "$FC"; then
4700   ac_ct_FC=$FC
4701   for ac_prog in gfortran
4702 do
4703   # Extract the first word of "$ac_prog", so it can be a program name with args.
4704 set dummy $ac_prog; ac_word=$2
4705 echo "$as_me:$LINENO: checking for $ac_word" >&5
4706 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4707 if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
4708   echo $ECHO_N "(cached) $ECHO_C" >&6
4709 else
4710   if test -n "$ac_ct_FC"; then
4711   ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
4712 else
4713 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4714 for as_dir in $PATH
4715 do
4716   IFS=$as_save_IFS
4717   test -z "$as_dir" && as_dir=.
4718   for ac_exec_ext in '' $ac_executable_extensions; do
4719   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4720     ac_cv_prog_ac_ct_FC="$ac_prog"
4721     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4722     break 2
4723   fi
4724 done
4725 done
4726
4727 fi
4728 fi
4729 ac_ct_FC=$ac_cv_prog_ac_ct_FC
4730 if test -n "$ac_ct_FC"; then
4731   echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
4732 echo "${ECHO_T}$ac_ct_FC" >&6
4733 else
4734   echo "$as_me:$LINENO: result: no" >&5
4735 echo "${ECHO_T}no" >&6
4736 fi
4737
4738   test -n "$ac_ct_FC" && break
4739 done
4740
4741   FC=$ac_ct_FC
4742 fi
4743
4744
4745 # Provide some information about the compiler.
4746 echo "$as_me:4746:" \
4747      "checking for Fortran compiler version" >&5
4748 ac_compiler=`set X $ac_compile; echo $2`
4749 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
4750   (eval $ac_compiler --version </dev/null >&5) 2>&5
4751   ac_status=$?
4752   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4753   (exit $ac_status); }
4754 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
4755   (eval $ac_compiler -v </dev/null >&5) 2>&5
4756   ac_status=$?
4757   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4758   (exit $ac_status); }
4759 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
4760   (eval $ac_compiler -V </dev/null >&5) 2>&5
4761   ac_status=$?
4762   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4763   (exit $ac_status); }
4764 rm -f a.out
4765
4766 # If we don't use `.F' as extension, the preprocessor is not run on the
4767 # input file.  (Note that this only needs to work for GNU compilers.)
4768 ac_save_ext=$ac_ext
4769 ac_ext=F
4770 echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
4771 echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
4772 if test "${ac_cv_fc_compiler_gnu+set}" = set; then
4773   echo $ECHO_N "(cached) $ECHO_C" >&6
4774 else
4775   cat >conftest.$ac_ext <<_ACEOF
4776       program main
4777 #ifndef __GNUC__
4778        choke me
4779 #endif
4780
4781       end
4782 _ACEOF
4783 rm -f conftest.$ac_objext
4784 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4785   (eval $ac_compile) 2>conftest.er1
4786   ac_status=$?
4787   grep -v '^ *+' conftest.er1 >conftest.err
4788   rm -f conftest.er1
4789   cat conftest.err >&5
4790   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4791   (exit $ac_status); } &&
4792          { ac_try='test -z "$ac_fc_werror_flag"
4793                          || test ! -s conftest.err'
4794   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4795   (eval $ac_try) 2>&5
4796   ac_status=$?
4797   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4798   (exit $ac_status); }; } &&
4799          { ac_try='test -s conftest.$ac_objext'
4800   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4801   (eval $ac_try) 2>&5
4802   ac_status=$?
4803   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4804   (exit $ac_status); }; }; then
4805   ac_compiler_gnu=yes
4806 else
4807   echo "$as_me: failed program was:" >&5
4808 sed 's/^/| /' conftest.$ac_ext >&5
4809
4810 ac_compiler_gnu=no
4811 fi
4812 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4813 ac_cv_fc_compiler_gnu=$ac_compiler_gnu
4814
4815 fi
4816 echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
4817 echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
4818 ac_ext=$ac_save_ext
4819 ac_test_FFLAGS=${FCFLAGS+set}
4820 ac_save_FFLAGS=$FCFLAGS
4821 FCFLAGS=
4822 echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
4823 echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
4824 if test "${ac_cv_prog_fc_g+set}" = set; then
4825   echo $ECHO_N "(cached) $ECHO_C" >&6
4826 else
4827   FCFLAGS=-g
4828 cat >conftest.$ac_ext <<_ACEOF
4829       program main
4830
4831       end
4832 _ACEOF
4833 rm -f conftest.$ac_objext
4834 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4835   (eval $ac_compile) 2>conftest.er1
4836   ac_status=$?
4837   grep -v '^ *+' conftest.er1 >conftest.err
4838   rm -f conftest.er1
4839   cat conftest.err >&5
4840   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4841   (exit $ac_status); } &&
4842          { ac_try='test -z "$ac_fc_werror_flag"
4843                          || test ! -s conftest.err'
4844   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4845   (eval $ac_try) 2>&5
4846   ac_status=$?
4847   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4848   (exit $ac_status); }; } &&
4849          { ac_try='test -s conftest.$ac_objext'
4850   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4851   (eval $ac_try) 2>&5
4852   ac_status=$?
4853   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4854   (exit $ac_status); }; }; then
4855   ac_cv_prog_fc_g=yes
4856 else
4857   echo "$as_me: failed program was:" >&5
4858 sed 's/^/| /' conftest.$ac_ext >&5
4859
4860 ac_cv_prog_fc_g=no
4861 fi
4862 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4863
4864 fi
4865 echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
4866 echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
4867 if test "$ac_test_FFLAGS" = set; then
4868   FCFLAGS=$ac_save_FFLAGS
4869 elif test $ac_cv_prog_fc_g = yes; then
4870   if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4871     FCFLAGS="-g -O2"
4872   else
4873     FCFLAGS="-g"
4874   fi
4875 else
4876   if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4877     FCFLAGS="-O2"
4878   else
4879     FCFLAGS=
4880   fi
4881 fi
4882
4883 ac_ext=c
4884 ac_cpp='$CPP $CPPFLAGS'
4885 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4886 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4887 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4888
4889
4890 # extra LD Flags which are required for targets
4891 case "${host}" in
4892   *-darwin*)
4893     # Darwin needs -single_module when linking libgfortran
4894     extra_ldflags_libgfortran=-Wl,-single_module
4895     ;;
4896 esac
4897
4898
4899 # We need a working compiler at that point, otherwise give a clear
4900 # error message and bail out.
4901
4902
4903 echo "$as_me:$LINENO: checking whether the GNU Fortran compiler is working" >&5
4904 echo $ECHO_N "checking whether the GNU Fortran compiler is working... $ECHO_C" >&6
4905 ac_ext=${FC_SRCEXT-f}
4906 ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4907 ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4908 ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4909
4910 cat >conftest.$ac_ext <<_ACEOF
4911
4912       program foo
4913       real, parameter :: bar = sin (12.34 / 2.5)
4914       end program foo
4915 _ACEOF
4916 rm -f conftest.$ac_objext
4917 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4918   (eval $ac_compile) 2>conftest.er1
4919   ac_status=$?
4920   grep -v '^ *+' conftest.er1 >conftest.err
4921   rm -f conftest.er1
4922   cat conftest.err >&5
4923   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4924   (exit $ac_status); } &&
4925          { ac_try='test -z "$ac_fc_werror_flag"
4926                          || test ! -s conftest.err'
4927   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4928   (eval $ac_try) 2>&5
4929   ac_status=$?
4930   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4931   (exit $ac_status); }; } &&
4932          { ac_try='test -s conftest.$ac_objext'
4933   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4934   (eval $ac_try) 2>&5
4935   ac_status=$?
4936   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4937   (exit $ac_status); }; }; then
4938   echo "$as_me:$LINENO: result: yes" >&5
4939 echo "${ECHO_T}yes" >&6
4940 else
4941   echo "$as_me: failed program was:" >&5
4942 sed 's/^/| /' conftest.$ac_ext >&5
4943
4944 echo "$as_me:$LINENO: result: no" >&5
4945 echo "${ECHO_T}no" >&6
4946      { { echo "$as_me:$LINENO: error: GNU Fortran is not working; please report a bug in http://gcc.gnu.org/bugzilla, attaching $PWD/config.log" >&5
4947 echo "$as_me: error: GNU Fortran is not working; please report a bug in http://gcc.gnu.org/bugzilla, attaching $PWD/config.log" >&2;}
4948    { (exit 1); exit 1; }; }
4949
4950 fi
4951 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4952 ac_ext=c
4953 ac_cpp='$CPP $CPPFLAGS'
4954 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4955 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4956 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4957
4958
4959
4960 # Check whether --enable-largefile or --disable-largefile was given.
4961 if test "${enable_largefile+set}" = set; then
4962   enableval="$enable_largefile"
4963
4964 fi;
4965 if test "$enable_largefile" != no; then
4966
4967   echo "$as_me:$LINENO: checking for special C compiler options needed for large files" >&5
4968 echo $ECHO_N "checking for special C compiler options needed for large files... $ECHO_C" >&6
4969 if test "${ac_cv_sys_largefile_CC+set}" = set; then
4970   echo $ECHO_N "(cached) $ECHO_C" >&6
4971 else
4972   ac_cv_sys_largefile_CC=no
4973      if test "$GCC" != yes; then
4974        ac_save_CC=$CC
4975        while :; do
4976          # IRIX 6.2 and later do not support large files by default,
4977          # so use the C compiler's -n32 option if that helps.
4978          cat >conftest.$ac_ext <<_ACEOF
4979 /* confdefs.h.  */
4980 _ACEOF
4981 cat confdefs.h >>conftest.$ac_ext
4982 cat >>conftest.$ac_ext <<_ACEOF
4983 /* end confdefs.h.  */
4984 #include <sys/types.h>
4985  /* Check that off_t can represent 2**63 - 1 correctly.
4986     We can't simply define LARGE_OFF_T to be 9223372036854775807,
4987     since some C++ compilers masquerading as C compilers
4988     incorrectly reject 9223372036854775807.  */
4989 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4990   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4991                        && LARGE_OFF_T % 2147483647 == 1)
4992                       ? 1 : -1];
4993 int
4994 main ()
4995 {
4996
4997   ;
4998   return 0;
4999 }
5000 _ACEOF
5001          rm -f conftest.$ac_objext
5002 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5003   (eval $ac_compile) 2>conftest.er1
5004   ac_status=$?
5005   grep -v '^ *+' conftest.er1 >conftest.err
5006   rm -f conftest.er1
5007   cat conftest.err >&5
5008   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5009   (exit $ac_status); } &&
5010          { ac_try='test -z "$ac_c_werror_flag"
5011                          || test ! -s conftest.err'
5012   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5013   (eval $ac_try) 2>&5
5014   ac_status=$?
5015   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5016   (exit $ac_status); }; } &&
5017          { ac_try='test -s conftest.$ac_objext'
5018   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5019   (eval $ac_try) 2>&5
5020   ac_status=$?
5021   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5022   (exit $ac_status); }; }; then
5023   break
5024 else
5025   echo "$as_me: failed program was:" >&5
5026 sed 's/^/| /' conftest.$ac_ext >&5
5027
5028 fi
5029 rm -f conftest.err conftest.$ac_objext
5030          CC="$CC -n32"
5031          rm -f conftest.$ac_objext
5032 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5033   (eval $ac_compile) 2>conftest.er1
5034   ac_status=$?
5035   grep -v '^ *+' conftest.er1 >conftest.err
5036   rm -f conftest.er1
5037   cat conftest.err >&5
5038   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5039   (exit $ac_status); } &&
5040          { ac_try='test -z "$ac_c_werror_flag"
5041                          || test ! -s conftest.err'
5042   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5043   (eval $ac_try) 2>&5
5044   ac_status=$?
5045   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5046   (exit $ac_status); }; } &&
5047          { ac_try='test -s conftest.$ac_objext'
5048   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5049   (eval $ac_try) 2>&5
5050   ac_status=$?
5051   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5052   (exit $ac_status); }; }; then
5053   ac_cv_sys_largefile_CC=' -n32'; break
5054 else
5055   echo "$as_me: failed program was:" >&5
5056 sed 's/^/| /' conftest.$ac_ext >&5
5057
5058 fi
5059 rm -f conftest.err conftest.$ac_objext
5060          break
5061        done
5062        CC=$ac_save_CC
5063        rm -f conftest.$ac_ext
5064     fi
5065 fi
5066 echo "$as_me:$LINENO: result: $ac_cv_sys_largefile_CC" >&5
5067 echo "${ECHO_T}$ac_cv_sys_largefile_CC" >&6
5068   if test "$ac_cv_sys_largefile_CC" != no; then
5069     CC=$CC$ac_cv_sys_largefile_CC
5070   fi
5071
5072   echo "$as_me:$LINENO: checking for _FILE_OFFSET_BITS value needed for large files" >&5
5073 echo $ECHO_N "checking for _FILE_OFFSET_BITS value needed for large files... $ECHO_C" >&6
5074 if test "${ac_cv_sys_file_offset_bits+set}" = set; then
5075   echo $ECHO_N "(cached) $ECHO_C" >&6
5076 else
5077   while :; do
5078   ac_cv_sys_file_offset_bits=no
5079   cat >conftest.$ac_ext <<_ACEOF
5080 /* confdefs.h.  */
5081 _ACEOF
5082 cat confdefs.h >>conftest.$ac_ext
5083 cat >>conftest.$ac_ext <<_ACEOF
5084 /* end confdefs.h.  */
5085 #include <sys/types.h>
5086  /* Check that off_t can represent 2**63 - 1 correctly.
5087     We can't simply define LARGE_OFF_T to be 9223372036854775807,
5088     since some C++ compilers masquerading as C compilers
5089     incorrectly reject 9223372036854775807.  */
5090 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5091   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5092                        && LARGE_OFF_T % 2147483647 == 1)
5093                       ? 1 : -1];
5094 int
5095 main ()
5096 {
5097
5098   ;
5099   return 0;
5100 }
5101 _ACEOF
5102 rm -f conftest.$ac_objext
5103 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5104   (eval $ac_compile) 2>conftest.er1
5105   ac_status=$?
5106   grep -v '^ *+' conftest.er1 >conftest.err
5107   rm -f conftest.er1
5108   cat conftest.err >&5
5109   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5110   (exit $ac_status); } &&
5111          { ac_try='test -z "$ac_c_werror_flag"
5112                          || test ! -s conftest.err'
5113   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5114   (eval $ac_try) 2>&5
5115   ac_status=$?
5116   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5117   (exit $ac_status); }; } &&
5118          { ac_try='test -s conftest.$ac_objext'
5119   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5120   (eval $ac_try) 2>&5
5121   ac_status=$?
5122   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5123   (exit $ac_status); }; }; then
5124   break
5125 else
5126   echo "$as_me: failed program was:" >&5
5127 sed 's/^/| /' conftest.$ac_ext >&5
5128
5129 fi
5130 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5131   cat >conftest.$ac_ext <<_ACEOF
5132 /* confdefs.h.  */
5133 _ACEOF
5134 cat confdefs.h >>conftest.$ac_ext
5135 cat >>conftest.$ac_ext <<_ACEOF
5136 /* end confdefs.h.  */
5137 #define _FILE_OFFSET_BITS 64
5138 #include <sys/types.h>
5139  /* Check that off_t can represent 2**63 - 1 correctly.
5140     We can't simply define LARGE_OFF_T to be 9223372036854775807,
5141     since some C++ compilers masquerading as C compilers
5142     incorrectly reject 9223372036854775807.  */
5143 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5144   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5145                        && LARGE_OFF_T % 2147483647 == 1)
5146                       ? 1 : -1];
5147 int
5148 main ()
5149 {
5150
5151   ;
5152   return 0;
5153 }
5154 _ACEOF
5155 rm -f conftest.$ac_objext
5156 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5157   (eval $ac_compile) 2>conftest.er1
5158   ac_status=$?
5159   grep -v '^ *+' conftest.er1 >conftest.err
5160   rm -f conftest.er1
5161   cat conftest.err >&5
5162   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5163   (exit $ac_status); } &&
5164          { ac_try='test -z "$ac_c_werror_flag"
5165                          || test ! -s conftest.err'
5166   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5167   (eval $ac_try) 2>&5
5168   ac_status=$?
5169   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5170   (exit $ac_status); }; } &&
5171          { ac_try='test -s conftest.$ac_objext'
5172   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5173   (eval $ac_try) 2>&5
5174   ac_status=$?
5175   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5176   (exit $ac_status); }; }; then
5177   ac_cv_sys_file_offset_bits=64; break
5178 else
5179   echo "$as_me: failed program was:" >&5
5180 sed 's/^/| /' conftest.$ac_ext >&5
5181
5182 fi
5183 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5184   break
5185 done
5186 fi
5187 echo "$as_me:$LINENO: result: $ac_cv_sys_file_offset_bits" >&5
5188 echo "${ECHO_T}$ac_cv_sys_file_offset_bits" >&6
5189 if test "$ac_cv_sys_file_offset_bits" != no; then
5190
5191 cat >>confdefs.h <<_ACEOF
5192 #define _FILE_OFFSET_BITS $ac_cv_sys_file_offset_bits
5193 _ACEOF
5194
5195 fi
5196 rm -f conftest*
5197   echo "$as_me:$LINENO: checking for _LARGE_FILES value needed for large files" >&5
5198 echo $ECHO_N "checking for _LARGE_FILES value needed for large files... $ECHO_C" >&6
5199 if test "${ac_cv_sys_large_files+set}" = set; then
5200   echo $ECHO_N "(cached) $ECHO_C" >&6
5201 else
5202   while :; do
5203   ac_cv_sys_large_files=no
5204   cat >conftest.$ac_ext <<_ACEOF
5205 /* confdefs.h.  */
5206 _ACEOF
5207 cat confdefs.h >>conftest.$ac_ext
5208 cat >>conftest.$ac_ext <<_ACEOF
5209 /* end confdefs.h.  */
5210 #include <sys/types.h>
5211  /* Check that off_t can represent 2**63 - 1 correctly.
5212     We can't simply define LARGE_OFF_T to be 9223372036854775807,
5213     since some C++ compilers masquerading as C compilers
5214     incorrectly reject 9223372036854775807.  */
5215 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5216   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5217                        && LARGE_OFF_T % 2147483647 == 1)
5218                       ? 1 : -1];
5219 int
5220 main ()
5221 {
5222
5223   ;
5224   return 0;
5225 }
5226 _ACEOF
5227 rm -f conftest.$ac_objext
5228 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5229   (eval $ac_compile) 2>conftest.er1
5230   ac_status=$?
5231   grep -v '^ *+' conftest.er1 >conftest.err
5232   rm -f conftest.er1
5233   cat conftest.err >&5
5234   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5235   (exit $ac_status); } &&
5236          { ac_try='test -z "$ac_c_werror_flag"
5237                          || test ! -s conftest.err'
5238   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5239   (eval $ac_try) 2>&5
5240   ac_status=$?
5241   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5242   (exit $ac_status); }; } &&
5243          { ac_try='test -s conftest.$ac_objext'
5244   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5245   (eval $ac_try) 2>&5
5246   ac_status=$?
5247   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5248   (exit $ac_status); }; }; then
5249   break
5250 else
5251   echo "$as_me: failed program was:" >&5
5252 sed 's/^/| /' conftest.$ac_ext >&5
5253
5254 fi
5255 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5256   cat >conftest.$ac_ext <<_ACEOF
5257 /* confdefs.h.  */
5258 _ACEOF
5259 cat confdefs.h >>conftest.$ac_ext
5260 cat >>conftest.$ac_ext <<_ACEOF
5261 /* end confdefs.h.  */
5262 #define _LARGE_FILES 1
5263 #include <sys/types.h>
5264  /* Check that off_t can represent 2**63 - 1 correctly.
5265     We can't simply define LARGE_OFF_T to be 9223372036854775807,
5266     since some C++ compilers masquerading as C compilers
5267     incorrectly reject 9223372036854775807.  */
5268 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5269   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5270                        && LARGE_OFF_T % 2147483647 == 1)
5271                       ? 1 : -1];
5272 int
5273 main ()
5274 {
5275
5276   ;
5277   return 0;
5278 }
5279 _ACEOF
5280 rm -f conftest.$ac_objext
5281 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5282   (eval $ac_compile) 2>conftest.er1
5283   ac_status=$?
5284   grep -v '^ *+' conftest.er1 >conftest.err
5285   rm -f conftest.er1
5286   cat conftest.err >&5
5287   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5288   (exit $ac_status); } &&
5289          { ac_try='test -z "$ac_c_werror_flag"
5290                          || test ! -s conftest.err'
5291   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5292   (eval $ac_try) 2>&5
5293   ac_status=$?
5294   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5295   (exit $ac_status); }; } &&
5296          { ac_try='test -s conftest.$ac_objext'
5297   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5298   (eval $ac_try) 2>&5
5299   ac_status=$?
5300   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5301   (exit $ac_status); }; }; then
5302   ac_cv_sys_large_files=1; break
5303 else
5304   echo "$as_me: failed program was:" >&5
5305 sed 's/^/| /' conftest.$ac_ext >&5
5306
5307 fi
5308 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5309   break
5310 done
5311 fi
5312 echo "$as_me:$LINENO: result: $ac_cv_sys_large_files" >&5
5313 echo "${ECHO_T}$ac_cv_sys_large_files" >&6
5314 if test "$ac_cv_sys_large_files" != no; then
5315
5316 cat >>confdefs.h <<_ACEOF
5317 #define _LARGE_FILES $ac_cv_sys_large_files
5318 _ACEOF
5319
5320 fi
5321 rm -f conftest*
5322 fi
5323
5324 ac_ext=c
5325 ac_cpp='$CPP $CPPFLAGS'
5326 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5327 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5328 ac_compiler_gnu=$ac_cv_c_compiler_gnu
5329 echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
5330 echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
5331 # On Suns, sometimes $CPP names a directory.
5332 if test -n "$CPP" && test -d "$CPP"; then
5333   CPP=
5334 fi
5335 if test -z "$CPP"; then
5336   if test "${ac_cv_prog_CPP+set}" = set; then
5337   echo $ECHO_N "(cached) $ECHO_C" >&6
5338 else
5339       # Double quotes because CPP needs to be expanded
5340     for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
5341     do
5342       ac_preproc_ok=false
5343 for ac_c_preproc_warn_flag in '' yes
5344 do
5345   # Use a header file that comes with gcc, so configuring glibc
5346   # with a fresh cross-compiler works.
5347   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5348   # <limits.h> exists even on freestanding compilers.
5349   # On the NeXT, cc -E runs the code through the compiler's parser,
5350   # not just through cpp. "Syntax error" is here to catch this case.
5351   cat >conftest.$ac_ext <<_ACEOF
5352 /* confdefs.h.  */
5353 _ACEOF
5354 cat confdefs.h >>conftest.$ac_ext
5355 cat >>conftest.$ac_ext <<_ACEOF
5356 /* end confdefs.h.  */
5357 #ifdef __STDC__
5358 # include <limits.h>
5359 #else
5360 # include <assert.h>
5361 #endif
5362                      Syntax error
5363 _ACEOF
5364 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5365   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5366   ac_status=$?
5367   grep -v '^ *+' conftest.er1 >conftest.err
5368   rm -f conftest.er1
5369   cat conftest.err >&5
5370   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5371   (exit $ac_status); } >/dev/null; then
5372   if test -s conftest.err; then
5373     ac_cpp_err=$ac_c_preproc_warn_flag
5374     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5375   else
5376     ac_cpp_err=
5377   fi
5378 else
5379   ac_cpp_err=yes
5380 fi
5381 if test -z "$ac_cpp_err"; then
5382   :
5383 else
5384   echo "$as_me: failed program was:" >&5
5385 sed 's/^/| /' conftest.$ac_ext >&5
5386
5387   # Broken: fails on valid input.
5388 continue
5389 fi
5390 rm -f conftest.err conftest.$ac_ext
5391
5392   # OK, works on sane cases.  Now check whether non-existent headers
5393   # can be detected and how.
5394   cat >conftest.$ac_ext <<_ACEOF
5395 /* confdefs.h.  */
5396 _ACEOF
5397 cat confdefs.h >>conftest.$ac_ext
5398 cat >>conftest.$ac_ext <<_ACEOF
5399 /* end confdefs.h.  */
5400 #include <ac_nonexistent.h>
5401 _ACEOF
5402 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5403   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5404   ac_status=$?
5405   grep -v '^ *+' conftest.er1 >conftest.err
5406   rm -f conftest.er1
5407   cat conftest.err >&5
5408   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5409   (exit $ac_status); } >/dev/null; then
5410   if test -s conftest.err; then
5411     ac_cpp_err=$ac_c_preproc_warn_flag
5412     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5413   else
5414     ac_cpp_err=
5415   fi
5416 else
5417   ac_cpp_err=yes
5418 fi
5419 if test -z "$ac_cpp_err"; then
5420   # Broken: success on invalid input.
5421 continue
5422 else
5423   echo "$as_me: failed program was:" >&5
5424 sed 's/^/| /' conftest.$ac_ext >&5
5425
5426   # Passes both tests.
5427 ac_preproc_ok=:
5428 break
5429 fi
5430 rm -f conftest.err conftest.$ac_ext
5431
5432 done
5433 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5434 rm -f conftest.err conftest.$ac_ext
5435 if $ac_preproc_ok; then
5436   break
5437 fi
5438
5439     done
5440     ac_cv_prog_CPP=$CPP
5441
5442 fi
5443   CPP=$ac_cv_prog_CPP
5444 else
5445   ac_cv_prog_CPP=$CPP
5446 fi
5447 echo "$as_me:$LINENO: result: $CPP" >&5
5448 echo "${ECHO_T}$CPP" >&6
5449 ac_preproc_ok=false
5450 for ac_c_preproc_warn_flag in '' yes
5451 do
5452   # Use a header file that comes with gcc, so configuring glibc
5453   # with a fresh cross-compiler works.
5454   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5455   # <limits.h> exists even on freestanding compilers.
5456   # On the NeXT, cc -E runs the code through the compiler's parser,
5457   # not just through cpp. "Syntax error" is here to catch this case.
5458   cat >conftest.$ac_ext <<_ACEOF
5459 /* confdefs.h.  */
5460 _ACEOF
5461 cat confdefs.h >>conftest.$ac_ext
5462 cat >>conftest.$ac_ext <<_ACEOF
5463 /* end confdefs.h.  */
5464 #ifdef __STDC__
5465 # include <limits.h>
5466 #else
5467 # include <assert.h>
5468 #endif
5469                      Syntax error
5470 _ACEOF
5471 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5472   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5473   ac_status=$?
5474   grep -v '^ *+' conftest.er1 >conftest.err
5475   rm -f conftest.er1
5476   cat conftest.err >&5
5477   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5478   (exit $ac_status); } >/dev/null; then
5479   if test -s conftest.err; then
5480     ac_cpp_err=$ac_c_preproc_warn_flag
5481     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5482   else
5483     ac_cpp_err=
5484   fi
5485 else
5486   ac_cpp_err=yes
5487 fi
5488 if test -z "$ac_cpp_err"; then
5489   :
5490 else
5491   echo "$as_me: failed program was:" >&5
5492 sed 's/^/| /' conftest.$ac_ext >&5
5493
5494   # Broken: fails on valid input.
5495 continue
5496 fi
5497 rm -f conftest.err conftest.$ac_ext
5498
5499   # OK, works on sane cases.  Now check whether non-existent headers
5500   # can be detected and how.
5501   cat >conftest.$ac_ext <<_ACEOF
5502 /* confdefs.h.  */
5503 _ACEOF
5504 cat confdefs.h >>conftest.$ac_ext
5505 cat >>conftest.$ac_ext <<_ACEOF
5506 /* end confdefs.h.  */
5507 #include <ac_nonexistent.h>
5508 _ACEOF
5509 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5510   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5511   ac_status=$?
5512   grep -v '^ *+' conftest.er1 >conftest.err
5513   rm -f conftest.er1
5514   cat conftest.err >&5
5515   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5516   (exit $ac_status); } >/dev/null; then
5517   if test -s conftest.err; then
5518     ac_cpp_err=$ac_c_preproc_warn_flag
5519     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5520   else
5521     ac_cpp_err=
5522   fi
5523 else
5524   ac_cpp_err=yes
5525 fi
5526 if test -z "$ac_cpp_err"; then
5527   # Broken: success on invalid input.
5528 continue
5529 else
5530   echo "$as_me: failed program was:" >&5
5531 sed 's/^/| /' conftest.$ac_ext >&5
5532
5533   # Passes both tests.
5534 ac_preproc_ok=:
5535 break
5536 fi
5537 rm -f conftest.err conftest.$ac_ext
5538
5539 done
5540 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5541 rm -f conftest.err conftest.$ac_ext
5542 if $ac_preproc_ok; then
5543   :
5544 else
5545   { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
5546 See \`config.log' for more details." >&5
5547 echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
5548 See \`config.log' for more details." >&2;}
5549    { (exit 1); exit 1; }; }
5550 fi
5551
5552 ac_ext=c
5553 ac_cpp='$CPP $CPPFLAGS'
5554 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5555 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5556 ac_compiler_gnu=$ac_cv_c_compiler_gnu
5557
5558
5559 echo "$as_me:$LINENO: checking for egrep" >&5
5560 echo $ECHO_N "checking for egrep... $ECHO_C" >&6
5561 if test "${ac_cv_prog_egrep+set}" = set; then
5562   echo $ECHO_N "(cached) $ECHO_C" >&6
5563 else
5564   if echo a | (grep -E '(a|b)') >/dev/null 2>&1
5565     then ac_cv_prog_egrep='grep -E'
5566     else ac_cv_prog_egrep='egrep'
5567     fi
5568 fi
5569 echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
5570 echo "${ECHO_T}$ac_cv_prog_egrep" >&6
5571  EGREP=$ac_cv_prog_egrep
5572
5573
5574 echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5575 echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5576 if test "${ac_cv_header_stdc+set}" = set; then
5577   echo $ECHO_N "(cached) $ECHO_C" >&6
5578 else
5579   cat >conftest.$ac_ext <<_ACEOF
5580 /* confdefs.h.  */
5581 _ACEOF
5582 cat confdefs.h >>conftest.$ac_ext
5583 cat >>conftest.$ac_ext <<_ACEOF
5584 /* end confdefs.h.  */
5585 #include <stdlib.h>
5586 #include <stdarg.h>
5587 #include <string.h>
5588 #include <float.h>
5589
5590 int
5591 main ()
5592 {
5593
5594   ;
5595   return 0;
5596 }
5597 _ACEOF
5598 rm -f conftest.$ac_objext
5599 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5600   (eval $ac_compile) 2>conftest.er1
5601   ac_status=$?
5602   grep -v '^ *+' conftest.er1 >conftest.err
5603   rm -f conftest.er1
5604   cat conftest.err >&5
5605   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5606   (exit $ac_status); } &&
5607          { ac_try='test -z "$ac_c_werror_flag"
5608                          || test ! -s conftest.err'
5609   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5610   (eval $ac_try) 2>&5
5611   ac_status=$?
5612   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5613   (exit $ac_status); }; } &&
5614          { ac_try='test -s conftest.$ac_objext'
5615   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5616   (eval $ac_try) 2>&5
5617   ac_status=$?
5618   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5619   (exit $ac_status); }; }; then
5620   ac_cv_header_stdc=yes
5621 else
5622   echo "$as_me: failed program was:" >&5
5623 sed 's/^/| /' conftest.$ac_ext >&5
5624
5625 ac_cv_header_stdc=no
5626 fi
5627 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5628
5629 if test $ac_cv_header_stdc = yes; then
5630   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5631   cat >conftest.$ac_ext <<_ACEOF
5632 /* confdefs.h.  */
5633 _ACEOF
5634 cat confdefs.h >>conftest.$ac_ext
5635 cat >>conftest.$ac_ext <<_ACEOF
5636 /* end confdefs.h.  */
5637 #include <string.h>
5638
5639 _ACEOF
5640 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5641   $EGREP "memchr" >/dev/null 2>&1; then
5642   :
5643 else
5644   ac_cv_header_stdc=no
5645 fi
5646 rm -f conftest*
5647
5648 fi
5649
5650 if test $ac_cv_header_stdc = yes; then
5651   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5652   cat >conftest.$ac_ext <<_ACEOF
5653 /* confdefs.h.  */
5654 _ACEOF
5655 cat confdefs.h >>conftest.$ac_ext
5656 cat >>conftest.$ac_ext <<_ACEOF
5657 /* end confdefs.h.  */
5658 #include <stdlib.h>
5659
5660 _ACEOF
5661 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5662   $EGREP "free" >/dev/null 2>&1; then
5663   :
5664 else
5665   ac_cv_header_stdc=no
5666 fi
5667 rm -f conftest*
5668
5669 fi
5670
5671 if test $ac_cv_header_stdc = yes; then
5672   # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5673   if test "$cross_compiling" = yes; then
5674   :
5675 else
5676   cat >conftest.$ac_ext <<_ACEOF
5677 /* confdefs.h.  */
5678 _ACEOF
5679 cat confdefs.h >>conftest.$ac_ext
5680 cat >>conftest.$ac_ext <<_ACEOF
5681 /* end confdefs.h.  */
5682 #include <ctype.h>
5683 #if ((' ' & 0x0FF) == 0x020)
5684 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5685 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5686 #else
5687 # define ISLOWER(c) \
5688                    (('a' <= (c) && (c) <= 'i') \
5689                      || ('j' <= (c) && (c) <= 'r') \
5690                      || ('s' <= (c) && (c) <= 'z'))
5691 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5692 #endif
5693
5694 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5695 int
5696 main ()
5697 {
5698   int i;
5699   for (i = 0; i < 256; i++)
5700     if (XOR (islower (i), ISLOWER (i))
5701         || toupper (i) != TOUPPER (i))
5702       exit(2);
5703   exit (0);
5704 }
5705 _ACEOF
5706 rm -f conftest$ac_exeext
5707 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5708   (eval $ac_link) 2>&5
5709   ac_status=$?
5710   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5711   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5712   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5713   (eval $ac_try) 2>&5
5714   ac_status=$?
5715   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5716   (exit $ac_status); }; }; then
5717   :
5718 else
5719   echo "$as_me: program exited with status $ac_status" >&5
5720 echo "$as_me: failed program was:" >&5
5721 sed 's/^/| /' conftest.$ac_ext >&5
5722
5723 ( exit $ac_status )
5724 ac_cv_header_stdc=no
5725 fi
5726 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5727 fi
5728 fi
5729 fi
5730 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5731 echo "${ECHO_T}$ac_cv_header_stdc" >&6
5732 if test $ac_cv_header_stdc = yes; then
5733
5734 cat >>confdefs.h <<\_ACEOF
5735 #define STDC_HEADERS 1
5736 _ACEOF
5737
5738 fi
5739
5740 # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5741
5742
5743
5744
5745
5746
5747
5748
5749
5750 for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5751                   inttypes.h stdint.h unistd.h
5752 do
5753 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5754 echo "$as_me:$LINENO: checking for $ac_header" >&5
5755 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5756 if eval "test \"\${$as_ac_Header+set}\" = set"; then
5757   echo $ECHO_N "(cached) $ECHO_C" >&6
5758 else
5759   cat >conftest.$ac_ext <<_ACEOF
5760 /* confdefs.h.  */
5761 _ACEOF
5762 cat confdefs.h >>conftest.$ac_ext
5763 cat >>conftest.$ac_ext <<_ACEOF
5764 /* end confdefs.h.  */
5765 $ac_includes_default
5766
5767 #include <$ac_header>
5768 _ACEOF
5769 rm -f conftest.$ac_objext
5770 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5771   (eval $ac_compile) 2>conftest.er1
5772   ac_status=$?
5773   grep -v '^ *+' conftest.er1 >conftest.err
5774   rm -f conftest.er1
5775   cat conftest.err >&5
5776   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5777   (exit $ac_status); } &&
5778          { ac_try='test -z "$ac_c_werror_flag"
5779                          || test ! -s conftest.err'
5780   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5781   (eval $ac_try) 2>&5
5782   ac_status=$?
5783   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5784   (exit $ac_status); }; } &&
5785          { ac_try='test -s conftest.$ac_objext'
5786   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5787   (eval $ac_try) 2>&5
5788   ac_status=$?
5789   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5790   (exit $ac_status); }; }; then
5791   eval "$as_ac_Header=yes"
5792 else
5793   echo "$as_me: failed program was:" >&5
5794 sed 's/^/| /' conftest.$ac_ext >&5
5795
5796 eval "$as_ac_Header=no"
5797 fi
5798 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5799 fi
5800 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5801 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5802 if test `eval echo '${'$as_ac_Header'}'` = yes; then
5803   cat >>confdefs.h <<_ACEOF
5804 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5805 _ACEOF
5806
5807 fi
5808
5809 done
5810
5811
5812 echo "$as_me:$LINENO: checking for off_t" >&5
5813 echo $ECHO_N "checking for off_t... $ECHO_C" >&6
5814 if test "${ac_cv_type_off_t+set}" = set; then
5815   echo $ECHO_N "(cached) $ECHO_C" >&6
5816 else
5817   cat >conftest.$ac_ext <<_ACEOF
5818 /* confdefs.h.  */
5819 _ACEOF
5820 cat confdefs.h >>conftest.$ac_ext
5821 cat >>conftest.$ac_ext <<_ACEOF
5822 /* end confdefs.h.  */
5823 $ac_includes_default
5824 int
5825 main ()
5826 {
5827 if ((off_t *) 0)
5828   return 0;
5829 if (sizeof (off_t))
5830   return 0;
5831   ;
5832   return 0;
5833 }
5834 _ACEOF
5835 rm -f conftest.$ac_objext
5836 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5837   (eval $ac_compile) 2>conftest.er1
5838   ac_status=$?
5839   grep -v '^ *+' conftest.er1 >conftest.err
5840   rm -f conftest.er1
5841   cat conftest.err >&5
5842   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5843   (exit $ac_status); } &&
5844          { ac_try='test -z "$ac_c_werror_flag"
5845                          || test ! -s conftest.err'
5846   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5847   (eval $ac_try) 2>&5
5848   ac_status=$?
5849   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5850   (exit $ac_status); }; } &&
5851          { ac_try='test -s conftest.$ac_objext'
5852   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5853   (eval $ac_try) 2>&5
5854   ac_status=$?
5855   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5856   (exit $ac_status); }; }; then
5857   ac_cv_type_off_t=yes
5858 else
5859   echo "$as_me: failed program was:" >&5
5860 sed 's/^/| /' conftest.$ac_ext >&5
5861
5862 ac_cv_type_off_t=no
5863 fi
5864 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5865 fi
5866 echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5
5867 echo "${ECHO_T}$ac_cv_type_off_t" >&6
5868 if test $ac_cv_type_off_t = yes; then
5869   :
5870 else
5871
5872 cat >>confdefs.h <<_ACEOF
5873 #define off_t long
5874 _ACEOF
5875
5876 fi
5877
5878
5879 # check header files
5880 echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5881 echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5882 if test "${ac_cv_header_stdc+set}" = set; then
5883   echo $ECHO_N "(cached) $ECHO_C" >&6
5884 else
5885   cat >conftest.$ac_ext <<_ACEOF
5886 /* confdefs.h.  */
5887 _ACEOF
5888 cat confdefs.h >>conftest.$ac_ext
5889 cat >>conftest.$ac_ext <<_ACEOF
5890 /* end confdefs.h.  */
5891 #include <stdlib.h>
5892 #include <stdarg.h>
5893 #include <string.h>
5894 #include <float.h>
5895
5896 int
5897 main ()
5898 {
5899
5900   ;
5901   return 0;
5902 }
5903 _ACEOF
5904 rm -f conftest.$ac_objext
5905 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5906   (eval $ac_compile) 2>conftest.er1
5907   ac_status=$?
5908   grep -v '^ *+' conftest.er1 >conftest.err
5909   rm -f conftest.er1
5910   cat conftest.err >&5
5911   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5912   (exit $ac_status); } &&
5913          { ac_try='test -z "$ac_c_werror_flag"
5914                          || test ! -s conftest.err'
5915   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5916   (eval $ac_try) 2>&5
5917   ac_status=$?
5918   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5919   (exit $ac_status); }; } &&
5920          { ac_try='test -s conftest.$ac_objext'
5921   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5922   (eval $ac_try) 2>&5
5923   ac_status=$?
5924   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5925   (exit $ac_status); }; }; then
5926   ac_cv_header_stdc=yes
5927 else
5928   echo "$as_me: failed program was:" >&5
5929 sed 's/^/| /' conftest.$ac_ext >&5
5930
5931 ac_cv_header_stdc=no
5932 fi
5933 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5934
5935 if test $ac_cv_header_stdc = yes; then
5936   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5937   cat >conftest.$ac_ext <<_ACEOF
5938 /* confdefs.h.  */
5939 _ACEOF
5940 cat confdefs.h >>conftest.$ac_ext
5941 cat >>conftest.$ac_ext <<_ACEOF
5942 /* end confdefs.h.  */
5943 #include <string.h>
5944
5945 _ACEOF
5946 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5947   $EGREP "memchr" >/dev/null 2>&1; then
5948   :
5949 else
5950   ac_cv_header_stdc=no
5951 fi
5952 rm -f conftest*
5953
5954 fi
5955
5956 if test $ac_cv_header_stdc = yes; then
5957   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5958   cat >conftest.$ac_ext <<_ACEOF
5959 /* confdefs.h.  */
5960 _ACEOF
5961 cat confdefs.h >>conftest.$ac_ext
5962 cat >>conftest.$ac_ext <<_ACEOF
5963 /* end confdefs.h.  */
5964 #include <stdlib.h>
5965
5966 _ACEOF
5967 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5968   $EGREP "free" >/dev/null 2>&1; then
5969   :
5970 else
5971   ac_cv_header_stdc=no
5972 fi
5973 rm -f conftest*
5974
5975 fi
5976
5977 if test $ac_cv_header_stdc = yes; then
5978   # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5979   if test "$cross_compiling" = yes; then
5980   :
5981 else
5982   cat >conftest.$ac_ext <<_ACEOF
5983 /* confdefs.h.  */
5984 _ACEOF
5985 cat confdefs.h >>conftest.$ac_ext
5986 cat >>conftest.$ac_ext <<_ACEOF
5987 /* end confdefs.h.  */
5988 #include <ctype.h>
5989 #if ((' ' & 0x0FF) == 0x020)
5990 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5991 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5992 #else
5993 # define ISLOWER(c) \
5994                    (('a' <= (c) && (c) <= 'i') \
5995                      || ('j' <= (c) && (c) <= 'r') \
5996                      || ('s' <= (c) && (c) <= 'z'))
5997 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5998 #endif
5999
6000 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
6001 int
6002 main ()
6003 {
6004   int i;
6005   for (i = 0; i < 256; i++)
6006     if (XOR (islower (i), ISLOWER (i))
6007         || toupper (i) != TOUPPER (i))
6008       exit(2);
6009   exit (0);
6010 }
6011 _ACEOF
6012 rm -f conftest$ac_exeext
6013 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6014   (eval $ac_link) 2>&5
6015   ac_status=$?
6016   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6017   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
6018   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6019   (eval $ac_try) 2>&5
6020   ac_status=$?
6021   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6022   (exit $ac_status); }; }; then
6023   :
6024 else
6025   echo "$as_me: program exited with status $ac_status" >&5
6026 echo "$as_me: failed program was:" >&5
6027 sed 's/^/| /' conftest.$ac_ext >&5
6028
6029 ( exit $ac_status )
6030 ac_cv_header_stdc=no
6031 fi
6032 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
6033 fi
6034 fi
6035 fi
6036 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
6037 echo "${ECHO_T}$ac_cv_header_stdc" >&6
6038 if test $ac_cv_header_stdc = yes; then
6039
6040 cat >>confdefs.h <<\_ACEOF
6041 #define STDC_HEADERS 1
6042 _ACEOF
6043
6044 fi
6045
6046 echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
6047 echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
6048 if test "${ac_cv_header_time+set}" = set; then
6049   echo $ECHO_N "(cached) $ECHO_C" >&6
6050 else
6051   cat >conftest.$ac_ext <<_ACEOF
6052 /* confdefs.h.  */
6053 _ACEOF
6054 cat confdefs.h >>conftest.$ac_ext
6055 cat >>conftest.$ac_ext <<_ACEOF
6056 /* end confdefs.h.  */
6057 #include <sys/types.h>
6058 #include <sys/time.h>
6059 #include <time.h>
6060
6061 int
6062 main ()
6063 {
6064 if ((struct tm *) 0)
6065 return 0;
6066   ;
6067   return 0;
6068 }
6069 _ACEOF
6070 rm -f conftest.$ac_objext
6071 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6072   (eval $ac_compile) 2>conftest.er1
6073   ac_status=$?
6074   grep -v '^ *+' conftest.er1 >conftest.err
6075   rm -f conftest.er1
6076   cat conftest.err >&5
6077   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6078   (exit $ac_status); } &&
6079          { ac_try='test -z "$ac_c_werror_flag"
6080                          || test ! -s conftest.err'
6081   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6082   (eval $ac_try) 2>&5
6083   ac_status=$?
6084   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6085   (exit $ac_status); }; } &&
6086          { ac_try='test -s conftest.$ac_objext'
6087   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6088   (eval $ac_try) 2>&5
6089   ac_status=$?
6090   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6091   (exit $ac_status); }; }; then
6092   ac_cv_header_time=yes
6093 else
6094   echo "$as_me: failed program was:" >&5
6095 sed 's/^/| /' conftest.$ac_ext >&5
6096
6097 ac_cv_header_time=no
6098 fi
6099 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6100 fi
6101 echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
6102 echo "${ECHO_T}$ac_cv_header_time" >&6
6103 if test $ac_cv_header_time = yes; then
6104
6105 cat >>confdefs.h <<\_ACEOF
6106 #define TIME_WITH_SYS_TIME 1
6107 _ACEOF
6108
6109 fi
6110
6111
6112
6113
6114
6115
6116
6117
6118 for ac_header in stdlib.h stdio.h string.h stddef.h math.h unistd.h signal.h
6119 do
6120 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6121 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6122   echo "$as_me:$LINENO: checking for $ac_header" >&5
6123 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6124 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6125   echo $ECHO_N "(cached) $ECHO_C" >&6
6126 fi
6127 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6128 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6129 else
6130   # Is the header compilable?
6131 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6132 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6133 cat >conftest.$ac_ext <<_ACEOF
6134 /* confdefs.h.  */
6135 _ACEOF
6136 cat confdefs.h >>conftest.$ac_ext
6137 cat >>conftest.$ac_ext <<_ACEOF
6138 /* end confdefs.h.  */
6139 $ac_includes_default
6140 #include <$ac_header>
6141 _ACEOF
6142 rm -f conftest.$ac_objext
6143 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6144   (eval $ac_compile) 2>conftest.er1
6145   ac_status=$?
6146   grep -v '^ *+' conftest.er1 >conftest.err
6147   rm -f conftest.er1
6148   cat conftest.err >&5
6149   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6150   (exit $ac_status); } &&
6151          { ac_try='test -z "$ac_c_werror_flag"
6152                          || test ! -s conftest.err'
6153   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6154   (eval $ac_try) 2>&5
6155   ac_status=$?
6156   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6157   (exit $ac_status); }; } &&
6158          { ac_try='test -s conftest.$ac_objext'
6159   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6160   (eval $ac_try) 2>&5
6161   ac_status=$?
6162   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6163   (exit $ac_status); }; }; then
6164   ac_header_compiler=yes
6165 else
6166   echo "$as_me: failed program was:" >&5
6167 sed 's/^/| /' conftest.$ac_ext >&5
6168
6169 ac_header_compiler=no
6170 fi
6171 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6172 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6173 echo "${ECHO_T}$ac_header_compiler" >&6
6174
6175 # Is the header present?
6176 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6177 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6178 cat >conftest.$ac_ext <<_ACEOF
6179 /* confdefs.h.  */
6180 _ACEOF
6181 cat confdefs.h >>conftest.$ac_ext
6182 cat >>conftest.$ac_ext <<_ACEOF
6183 /* end confdefs.h.  */
6184 #include <$ac_header>
6185 _ACEOF
6186 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6187   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6188   ac_status=$?
6189   grep -v '^ *+' conftest.er1 >conftest.err
6190   rm -f conftest.er1
6191   cat conftest.err >&5
6192   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6193   (exit $ac_status); } >/dev/null; then
6194   if test -s conftest.err; then
6195     ac_cpp_err=$ac_c_preproc_warn_flag
6196     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6197   else
6198     ac_cpp_err=
6199   fi
6200 else
6201   ac_cpp_err=yes
6202 fi
6203 if test -z "$ac_cpp_err"; then
6204   ac_header_preproc=yes
6205 else
6206   echo "$as_me: failed program was:" >&5
6207 sed 's/^/| /' conftest.$ac_ext >&5
6208
6209   ac_header_preproc=no
6210 fi
6211 rm -f conftest.err conftest.$ac_ext
6212 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6213 echo "${ECHO_T}$ac_header_preproc" >&6
6214
6215 # So?  What about this header?
6216 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6217   yes:no: )
6218     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6219 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6220     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6221 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6222     ac_header_preproc=yes
6223     ;;
6224   no:yes:* )
6225     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6226 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6227     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6228 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6229     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6230 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6231     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6232 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6233     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6234 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6235     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6236 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6237     (
6238       cat <<\_ASBOX
6239 ## ------------------------------------------------------ ##
6240 ## Report this to the GNU Fortran Runtime Library lists.  ##
6241 ## ------------------------------------------------------ ##
6242 _ASBOX
6243     ) |
6244       sed "s/^/$as_me: WARNING:     /" >&2
6245     ;;
6246 esac
6247 echo "$as_me:$LINENO: checking for $ac_header" >&5
6248 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6249 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6250   echo $ECHO_N "(cached) $ECHO_C" >&6
6251 else
6252   eval "$as_ac_Header=\$ac_header_preproc"
6253 fi
6254 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6255 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6256
6257 fi
6258 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6259   cat >>confdefs.h <<_ACEOF
6260 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6261 _ACEOF
6262
6263 fi
6264
6265 done
6266
6267
6268
6269
6270
6271
6272 for ac_header in time.h sys/params.h sys/time.h sys/times.h sys/resource.h
6273 do
6274 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6275 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6276   echo "$as_me:$LINENO: checking for $ac_header" >&5
6277 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6278 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6279   echo $ECHO_N "(cached) $ECHO_C" >&6
6280 fi
6281 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6282 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6283 else
6284   # Is the header compilable?
6285 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6286 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6287 cat >conftest.$ac_ext <<_ACEOF
6288 /* confdefs.h.  */
6289 _ACEOF
6290 cat confdefs.h >>conftest.$ac_ext
6291 cat >>conftest.$ac_ext <<_ACEOF
6292 /* end confdefs.h.  */
6293 $ac_includes_default
6294 #include <$ac_header>
6295 _ACEOF
6296 rm -f conftest.$ac_objext
6297 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6298   (eval $ac_compile) 2>conftest.er1
6299   ac_status=$?
6300   grep -v '^ *+' conftest.er1 >conftest.err
6301   rm -f conftest.er1
6302   cat conftest.err >&5
6303   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6304   (exit $ac_status); } &&
6305          { ac_try='test -z "$ac_c_werror_flag"
6306                          || test ! -s conftest.err'
6307   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6308   (eval $ac_try) 2>&5
6309   ac_status=$?
6310   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6311   (exit $ac_status); }; } &&
6312          { ac_try='test -s conftest.$ac_objext'
6313   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6314   (eval $ac_try) 2>&5
6315   ac_status=$?
6316   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6317   (exit $ac_status); }; }; then
6318   ac_header_compiler=yes
6319 else
6320   echo "$as_me: failed program was:" >&5
6321 sed 's/^/| /' conftest.$ac_ext >&5
6322
6323 ac_header_compiler=no
6324 fi
6325 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6326 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6327 echo "${ECHO_T}$ac_header_compiler" >&6
6328
6329 # Is the header present?
6330 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6331 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6332 cat >conftest.$ac_ext <<_ACEOF
6333 /* confdefs.h.  */
6334 _ACEOF
6335 cat confdefs.h >>conftest.$ac_ext
6336 cat >>conftest.$ac_ext <<_ACEOF
6337 /* end confdefs.h.  */
6338 #include <$ac_header>
6339 _ACEOF
6340 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6341   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6342   ac_status=$?
6343   grep -v '^ *+' conftest.er1 >conftest.err
6344   rm -f conftest.er1
6345   cat conftest.err >&5
6346   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6347   (exit $ac_status); } >/dev/null; then
6348   if test -s conftest.err; then
6349     ac_cpp_err=$ac_c_preproc_warn_flag
6350     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6351   else
6352     ac_cpp_err=
6353   fi
6354 else
6355   ac_cpp_err=yes
6356 fi
6357 if test -z "$ac_cpp_err"; then
6358   ac_header_preproc=yes
6359 else
6360   echo "$as_me: failed program was:" >&5
6361 sed 's/^/| /' conftest.$ac_ext >&5
6362
6363   ac_header_preproc=no
6364 fi
6365 rm -f conftest.err conftest.$ac_ext
6366 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6367 echo "${ECHO_T}$ac_header_preproc" >&6
6368
6369 # So?  What about this header?
6370 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6371   yes:no: )
6372     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6373 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6374     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6375 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6376     ac_header_preproc=yes
6377     ;;
6378   no:yes:* )
6379     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6380 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6381     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6382 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6383     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6384 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6385     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6386 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6387     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6388 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6389     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6390 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6391     (
6392       cat <<\_ASBOX
6393 ## ------------------------------------------------------ ##
6394 ## Report this to the GNU Fortran Runtime Library lists.  ##
6395 ## ------------------------------------------------------ ##
6396 _ASBOX
6397     ) |
6398       sed "s/^/$as_me: WARNING:     /" >&2
6399     ;;
6400 esac
6401 echo "$as_me:$LINENO: checking for $ac_header" >&5
6402 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6403 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6404   echo $ECHO_N "(cached) $ECHO_C" >&6
6405 else
6406   eval "$as_ac_Header=\$ac_header_preproc"
6407 fi
6408 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6409 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6410
6411 fi
6412 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6413   cat >>confdefs.h <<_ACEOF
6414 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6415 _ACEOF
6416
6417 fi
6418
6419 done
6420
6421
6422
6423
6424
6425
6426 for ac_header in sys/types.h sys/stat.h sys/wait.h floatingpoint.h ieeefp.h
6427 do
6428 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6429 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6430   echo "$as_me:$LINENO: checking for $ac_header" >&5
6431 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6432 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6433   echo $ECHO_N "(cached) $ECHO_C" >&6
6434 fi
6435 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6436 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6437 else
6438   # Is the header compilable?
6439 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6440 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6441 cat >conftest.$ac_ext <<_ACEOF
6442 /* confdefs.h.  */
6443 _ACEOF
6444 cat confdefs.h >>conftest.$ac_ext
6445 cat >>conftest.$ac_ext <<_ACEOF
6446 /* end confdefs.h.  */
6447 $ac_includes_default
6448 #include <$ac_header>
6449 _ACEOF
6450 rm -f conftest.$ac_objext
6451 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6452   (eval $ac_compile) 2>conftest.er1
6453   ac_status=$?
6454   grep -v '^ *+' conftest.er1 >conftest.err
6455   rm -f conftest.er1
6456   cat conftest.err >&5
6457   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6458   (exit $ac_status); } &&
6459          { ac_try='test -z "$ac_c_werror_flag"
6460                          || test ! -s conftest.err'
6461   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6462   (eval $ac_try) 2>&5
6463   ac_status=$?
6464   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6465   (exit $ac_status); }; } &&
6466          { ac_try='test -s conftest.$ac_objext'
6467   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6468   (eval $ac_try) 2>&5
6469   ac_status=$?
6470   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6471   (exit $ac_status); }; }; then
6472   ac_header_compiler=yes
6473 else
6474   echo "$as_me: failed program was:" >&5
6475 sed 's/^/| /' conftest.$ac_ext >&5
6476
6477 ac_header_compiler=no
6478 fi
6479 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6480 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6481 echo "${ECHO_T}$ac_header_compiler" >&6
6482
6483 # Is the header present?
6484 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6485 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6486 cat >conftest.$ac_ext <<_ACEOF
6487 /* confdefs.h.  */
6488 _ACEOF
6489 cat confdefs.h >>conftest.$ac_ext
6490 cat >>conftest.$ac_ext <<_ACEOF
6491 /* end confdefs.h.  */
6492 #include <$ac_header>
6493 _ACEOF
6494 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6495   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6496   ac_status=$?
6497   grep -v '^ *+' conftest.er1 >conftest.err
6498   rm -f conftest.er1
6499   cat conftest.err >&5
6500   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6501   (exit $ac_status); } >/dev/null; then
6502   if test -s conftest.err; then
6503     ac_cpp_err=$ac_c_preproc_warn_flag
6504     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6505   else
6506     ac_cpp_err=
6507   fi
6508 else
6509   ac_cpp_err=yes
6510 fi
6511 if test -z "$ac_cpp_err"; then
6512   ac_header_preproc=yes
6513 else
6514   echo "$as_me: failed program was:" >&5
6515 sed 's/^/| /' conftest.$ac_ext >&5
6516
6517   ac_header_preproc=no
6518 fi
6519 rm -f conftest.err conftest.$ac_ext
6520 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6521 echo "${ECHO_T}$ac_header_preproc" >&6
6522
6523 # So?  What about this header?
6524 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6525   yes:no: )
6526     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6527 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6528     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6529 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6530     ac_header_preproc=yes
6531     ;;
6532   no:yes:* )
6533     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6534 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6535     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6536 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6537     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6538 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6539     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6540 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6541     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6542 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6543     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6544 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6545     (
6546       cat <<\_ASBOX
6547 ## ------------------------------------------------------ ##
6548 ## Report this to the GNU Fortran Runtime Library lists.  ##
6549 ## ------------------------------------------------------ ##
6550 _ASBOX
6551     ) |
6552       sed "s/^/$as_me: WARNING:     /" >&2
6553     ;;
6554 esac
6555 echo "$as_me:$LINENO: checking for $ac_header" >&5
6556 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6557 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6558   echo $ECHO_N "(cached) $ECHO_C" >&6
6559 else
6560   eval "$as_ac_Header=\$ac_header_preproc"
6561 fi
6562 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6563 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6564
6565 fi
6566 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6567   cat >>confdefs.h <<_ACEOF
6568 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6569 _ACEOF
6570
6571 fi
6572
6573 done
6574
6575
6576
6577
6578
6579 for ac_header in fenv.h fptrap.h float.h execinfo.h
6580 do
6581 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6582 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6583   echo "$as_me:$LINENO: checking for $ac_header" >&5
6584 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6585 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6586   echo $ECHO_N "(cached) $ECHO_C" >&6
6587 fi
6588 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6589 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6590 else
6591   # Is the header compilable?
6592 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6593 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6594 cat >conftest.$ac_ext <<_ACEOF
6595 /* confdefs.h.  */
6596 _ACEOF
6597 cat confdefs.h >>conftest.$ac_ext
6598 cat >>conftest.$ac_ext <<_ACEOF
6599 /* end confdefs.h.  */
6600 $ac_includes_default
6601 #include <$ac_header>
6602 _ACEOF
6603 rm -f conftest.$ac_objext
6604 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6605   (eval $ac_compile) 2>conftest.er1
6606   ac_status=$?
6607   grep -v '^ *+' conftest.er1 >conftest.err
6608   rm -f conftest.er1
6609   cat conftest.err >&5
6610   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6611   (exit $ac_status); } &&
6612          { ac_try='test -z "$ac_c_werror_flag"
6613                          || test ! -s conftest.err'
6614   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6615   (eval $ac_try) 2>&5
6616   ac_status=$?
6617   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6618   (exit $ac_status); }; } &&
6619          { ac_try='test -s conftest.$ac_objext'
6620   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6621   (eval $ac_try) 2>&5
6622   ac_status=$?
6623   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6624   (exit $ac_status); }; }; then
6625   ac_header_compiler=yes
6626 else
6627   echo "$as_me: failed program was:" >&5
6628 sed 's/^/| /' conftest.$ac_ext >&5
6629
6630 ac_header_compiler=no
6631 fi
6632 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6633 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6634 echo "${ECHO_T}$ac_header_compiler" >&6
6635
6636 # Is the header present?
6637 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6638 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6639 cat >conftest.$ac_ext <<_ACEOF
6640 /* confdefs.h.  */
6641 _ACEOF
6642 cat confdefs.h >>conftest.$ac_ext
6643 cat >>conftest.$ac_ext <<_ACEOF
6644 /* end confdefs.h.  */
6645 #include <$ac_header>
6646 _ACEOF
6647 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6648   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6649   ac_status=$?
6650   grep -v '^ *+' conftest.er1 >conftest.err
6651   rm -f conftest.er1
6652   cat conftest.err >&5
6653   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6654   (exit $ac_status); } >/dev/null; then
6655   if test -s conftest.err; then
6656     ac_cpp_err=$ac_c_preproc_warn_flag
6657     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6658   else
6659     ac_cpp_err=
6660   fi
6661 else
6662   ac_cpp_err=yes
6663 fi
6664 if test -z "$ac_cpp_err"; then
6665   ac_header_preproc=yes
6666 else
6667   echo "$as_me: failed program was:" >&5
6668 sed 's/^/| /' conftest.$ac_ext >&5
6669
6670   ac_header_preproc=no
6671 fi
6672 rm -f conftest.err conftest.$ac_ext
6673 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6674 echo "${ECHO_T}$ac_header_preproc" >&6
6675
6676 # So?  What about this header?
6677 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6678   yes:no: )
6679     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6680 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6681     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6682 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6683     ac_header_preproc=yes
6684     ;;
6685   no:yes:* )
6686     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6687 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6688     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6689 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6690     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6691 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6692     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6693 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6694     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6695 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6696     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6697 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6698     (
6699       cat <<\_ASBOX
6700 ## ------------------------------------------------------ ##
6701 ## Report this to the GNU Fortran Runtime Library lists.  ##
6702 ## ------------------------------------------------------ ##
6703 _ASBOX
6704     ) |
6705       sed "s/^/$as_me: WARNING:     /" >&2
6706     ;;
6707 esac
6708 echo "$as_me:$LINENO: checking for $ac_header" >&5
6709 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6710 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6711   echo $ECHO_N "(cached) $ECHO_C" >&6
6712 else
6713   eval "$as_ac_Header=\$ac_header_preproc"
6714 fi
6715 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6716 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6717
6718 fi
6719 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6720   cat >>confdefs.h <<_ACEOF
6721 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6722 _ACEOF
6723
6724 fi
6725
6726 done
6727
6728 if test "${ac_cv_header_complex_h+set}" = set; then
6729   echo "$as_me:$LINENO: checking for complex.h" >&5
6730 echo $ECHO_N "checking for complex.h... $ECHO_C" >&6
6731 if test "${ac_cv_header_complex_h+set}" = set; then
6732   echo $ECHO_N "(cached) $ECHO_C" >&6
6733 fi
6734 echo "$as_me:$LINENO: result: $ac_cv_header_complex_h" >&5
6735 echo "${ECHO_T}$ac_cv_header_complex_h" >&6
6736 else
6737   # Is the header compilable?
6738 echo "$as_me:$LINENO: checking complex.h usability" >&5
6739 echo $ECHO_N "checking complex.h usability... $ECHO_C" >&6
6740 cat >conftest.$ac_ext <<_ACEOF
6741 /* confdefs.h.  */
6742 _ACEOF
6743 cat confdefs.h >>conftest.$ac_ext
6744 cat >>conftest.$ac_ext <<_ACEOF
6745 /* end confdefs.h.  */
6746 $ac_includes_default
6747 #include <complex.h>
6748 _ACEOF
6749 rm -f conftest.$ac_objext
6750 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6751   (eval $ac_compile) 2>conftest.er1
6752   ac_status=$?
6753   grep -v '^ *+' conftest.er1 >conftest.err
6754   rm -f conftest.er1
6755   cat conftest.err >&5
6756   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6757   (exit $ac_status); } &&
6758          { ac_try='test -z "$ac_c_werror_flag"
6759                          || test ! -s conftest.err'
6760   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6761   (eval $ac_try) 2>&5
6762   ac_status=$?
6763   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6764   (exit $ac_status); }; } &&
6765          { ac_try='test -s conftest.$ac_objext'
6766   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6767   (eval $ac_try) 2>&5
6768   ac_status=$?
6769   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6770   (exit $ac_status); }; }; then
6771   ac_header_compiler=yes
6772 else
6773   echo "$as_me: failed program was:" >&5
6774 sed 's/^/| /' conftest.$ac_ext >&5
6775
6776 ac_header_compiler=no
6777 fi
6778 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6779 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6780 echo "${ECHO_T}$ac_header_compiler" >&6
6781
6782 # Is the header present?
6783 echo "$as_me:$LINENO: checking complex.h presence" >&5
6784 echo $ECHO_N "checking complex.h presence... $ECHO_C" >&6
6785 cat >conftest.$ac_ext <<_ACEOF
6786 /* confdefs.h.  */
6787 _ACEOF
6788 cat confdefs.h >>conftest.$ac_ext
6789 cat >>conftest.$ac_ext <<_ACEOF
6790 /* end confdefs.h.  */
6791 #include <complex.h>
6792 _ACEOF
6793 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6794   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6795   ac_status=$?
6796   grep -v '^ *+' conftest.er1 >conftest.err
6797   rm -f conftest.er1
6798   cat conftest.err >&5
6799   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6800   (exit $ac_status); } >/dev/null; then
6801   if test -s conftest.err; then
6802     ac_cpp_err=$ac_c_preproc_warn_flag
6803     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6804   else
6805     ac_cpp_err=
6806   fi
6807 else
6808   ac_cpp_err=yes
6809 fi
6810 if test -z "$ac_cpp_err"; then
6811   ac_header_preproc=yes
6812 else
6813   echo "$as_me: failed program was:" >&5
6814 sed 's/^/| /' conftest.$ac_ext >&5
6815
6816   ac_header_preproc=no
6817 fi
6818 rm -f conftest.err conftest.$ac_ext
6819 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6820 echo "${ECHO_T}$ac_header_preproc" >&6
6821
6822 # So?  What about this header?
6823 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6824   yes:no: )
6825     { echo "$as_me:$LINENO: WARNING: complex.h: accepted by the compiler, rejected by the preprocessor!" >&5
6826 echo "$as_me: WARNING: complex.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6827     { echo "$as_me:$LINENO: WARNING: complex.h: proceeding with the compiler's result" >&5
6828 echo "$as_me: WARNING: complex.h: proceeding with the compiler's result" >&2;}
6829     ac_header_preproc=yes
6830     ;;
6831   no:yes:* )
6832     { echo "$as_me:$LINENO: WARNING: complex.h: present but cannot be compiled" >&5
6833 echo "$as_me: WARNING: complex.h: present but cannot be compiled" >&2;}
6834     { echo "$as_me:$LINENO: WARNING: complex.h:     check for missing prerequisite headers?" >&5
6835 echo "$as_me: WARNING: complex.h:     check for missing prerequisite headers?" >&2;}
6836     { echo "$as_me:$LINENO: WARNING: complex.h: see the Autoconf documentation" >&5
6837 echo "$as_me: WARNING: complex.h: see the Autoconf documentation" >&2;}
6838     { echo "$as_me:$LINENO: WARNING: complex.h:     section \"Present But Cannot Be Compiled\"" >&5
6839 echo "$as_me: WARNING: complex.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6840     { echo "$as_me:$LINENO: WARNING: complex.h: proceeding with the preprocessor's result" >&5
6841 echo "$as_me: WARNING: complex.h: proceeding with the preprocessor's result" >&2;}
6842     { echo "$as_me:$LINENO: WARNING: complex.h: in the future, the compiler will take precedence" >&5
6843 echo "$as_me: WARNING: complex.h: in the future, the compiler will take precedence" >&2;}
6844     (
6845       cat <<\_ASBOX
6846 ## ------------------------------------------------------ ##
6847 ## Report this to the GNU Fortran Runtime Library lists.  ##
6848 ## ------------------------------------------------------ ##
6849 _ASBOX
6850     ) |
6851       sed "s/^/$as_me: WARNING:     /" >&2
6852     ;;
6853 esac
6854 echo "$as_me:$LINENO: checking for complex.h" >&5
6855 echo $ECHO_N "checking for complex.h... $ECHO_C" >&6
6856 if test "${ac_cv_header_complex_h+set}" = set; then
6857   echo $ECHO_N "(cached) $ECHO_C" >&6
6858 else
6859   ac_cv_header_complex_h=$ac_header_preproc
6860 fi
6861 echo "$as_me:$LINENO: result: $ac_cv_header_complex_h" >&5
6862 echo "${ECHO_T}$ac_cv_header_complex_h" >&6
6863
6864 fi
6865 if test $ac_cv_header_complex_h = yes; then
6866
6867 cat >>confdefs.h <<\_ACEOF
6868 #define HAVE_COMPLEX_H 1
6869 _ACEOF
6870
6871 fi
6872
6873
6874
6875
6876 inttype_headers=`echo inttypes.h sys/inttypes.h  | sed -e 's/,/ /g'`
6877
6878 acx_cv_header_stdint=stddef.h
6879 acx_cv_header_stdint_kind="(already complete)"
6880 for i in stdint.h $inttype_headers; do
6881   unset ac_cv_type_uintptr_t
6882   unset ac_cv_type_uintmax_t
6883   unset ac_cv_type_int_least32_t
6884   unset ac_cv_type_int_fast32_t
6885   unset ac_cv_type_uint64_t
6886   echo $ECHO_N "looking for a compliant stdint.h in $i, $ECHO_C" >&6
6887   echo "$as_me:$LINENO: checking for uintmax_t" >&5
6888 echo $ECHO_N "checking for uintmax_t... $ECHO_C" >&6
6889 if test "${ac_cv_type_uintmax_t+set}" = set; then
6890   echo $ECHO_N "(cached) $ECHO_C" >&6
6891 else
6892   cat >conftest.$ac_ext <<_ACEOF
6893 /* confdefs.h.  */
6894 _ACEOF
6895 cat confdefs.h >>conftest.$ac_ext
6896 cat >>conftest.$ac_ext <<_ACEOF
6897 /* end confdefs.h.  */
6898 #include <sys/types.h>
6899 #include <$i>
6900
6901 int
6902 main ()
6903 {
6904 if ((uintmax_t *) 0)
6905   return 0;
6906 if (sizeof (uintmax_t))
6907   return 0;
6908   ;
6909   return 0;
6910 }
6911 _ACEOF
6912 rm -f conftest.$ac_objext
6913 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6914   (eval $ac_compile) 2>conftest.er1
6915   ac_status=$?
6916   grep -v '^ *+' conftest.er1 >conftest.err
6917   rm -f conftest.er1
6918   cat conftest.err >&5
6919   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6920   (exit $ac_status); } &&
6921          { ac_try='test -z "$ac_c_werror_flag"
6922                          || test ! -s conftest.err'
6923   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6924   (eval $ac_try) 2>&5
6925   ac_status=$?
6926   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6927   (exit $ac_status); }; } &&
6928          { ac_try='test -s conftest.$ac_objext'
6929   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6930   (eval $ac_try) 2>&5
6931   ac_status=$?
6932   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6933   (exit $ac_status); }; }; then
6934   ac_cv_type_uintmax_t=yes
6935 else
6936   echo "$as_me: failed program was:" >&5
6937 sed 's/^/| /' conftest.$ac_ext >&5
6938
6939 ac_cv_type_uintmax_t=no
6940 fi
6941 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6942 fi
6943 echo "$as_me:$LINENO: result: $ac_cv_type_uintmax_t" >&5
6944 echo "${ECHO_T}$ac_cv_type_uintmax_t" >&6
6945 if test $ac_cv_type_uintmax_t = yes; then
6946   acx_cv_header_stdint=$i
6947 else
6948   continue
6949 fi
6950
6951   echo "$as_me:$LINENO: checking for uintptr_t" >&5
6952 echo $ECHO_N "checking for uintptr_t... $ECHO_C" >&6
6953 if test "${ac_cv_type_uintptr_t+set}" = set; then
6954   echo $ECHO_N "(cached) $ECHO_C" >&6
6955 else
6956   cat >conftest.$ac_ext <<_ACEOF
6957 /* confdefs.h.  */
6958 _ACEOF
6959 cat confdefs.h >>conftest.$ac_ext
6960 cat >>conftest.$ac_ext <<_ACEOF
6961 /* end confdefs.h.  */
6962 #include <sys/types.h>
6963 #include <$i>
6964
6965 int
6966 main ()
6967 {
6968 if ((uintptr_t *) 0)
6969   return 0;
6970 if (sizeof (uintptr_t))
6971   return 0;
6972   ;
6973   return 0;
6974 }
6975 _ACEOF
6976 rm -f conftest.$ac_objext
6977 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6978   (eval $ac_compile) 2>conftest.er1
6979   ac_status=$?
6980   grep -v '^ *+' conftest.er1 >conftest.err
6981   rm -f conftest.er1
6982   cat conftest.err >&5
6983   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6984   (exit $ac_status); } &&
6985          { ac_try='test -z "$ac_c_werror_flag"
6986                          || test ! -s conftest.err'
6987   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6988   (eval $ac_try) 2>&5
6989   ac_status=$?
6990   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6991   (exit $ac_status); }; } &&
6992          { ac_try='test -s conftest.$ac_objext'
6993   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6994   (eval $ac_try) 2>&5
6995   ac_status=$?
6996   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6997   (exit $ac_status); }; }; then
6998   ac_cv_type_uintptr_t=yes
6999 else
7000   echo "$as_me: failed program was:" >&5
7001 sed 's/^/| /' conftest.$ac_ext >&5
7002
7003 ac_cv_type_uintptr_t=no
7004 fi
7005 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7006 fi
7007 echo "$as_me:$LINENO: result: $ac_cv_type_uintptr_t" >&5
7008 echo "${ECHO_T}$ac_cv_type_uintptr_t" >&6
7009 if test $ac_cv_type_uintptr_t = yes; then
7010   :
7011 else
7012   acx_cv_header_stdint_kind="(mostly complete)"
7013 fi
7014
7015   echo "$as_me:$LINENO: checking for int_least32_t" >&5
7016 echo $ECHO_N "checking for int_least32_t... $ECHO_C" >&6
7017 if test "${ac_cv_type_int_least32_t+set}" = set; then
7018   echo $ECHO_N "(cached) $ECHO_C" >&6
7019 else
7020   cat >conftest.$ac_ext <<_ACEOF
7021 /* confdefs.h.  */
7022 _ACEOF
7023 cat confdefs.h >>conftest.$ac_ext
7024 cat >>conftest.$ac_ext <<_ACEOF
7025 /* end confdefs.h.  */
7026 #include <sys/types.h>
7027 #include <$i>
7028
7029 int
7030 main ()
7031 {
7032 if ((int_least32_t *) 0)
7033   return 0;
7034 if (sizeof (int_least32_t))
7035   return 0;
7036   ;
7037   return 0;
7038 }
7039 _ACEOF
7040 rm -f conftest.$ac_objext
7041 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7042   (eval $ac_compile) 2>conftest.er1
7043   ac_status=$?
7044   grep -v '^ *+' conftest.er1 >conftest.err
7045   rm -f conftest.er1
7046   cat conftest.err >&5
7047   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7048   (exit $ac_status); } &&
7049          { ac_try='test -z "$ac_c_werror_flag"
7050                          || test ! -s conftest.err'
7051   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7052   (eval $ac_try) 2>&5
7053   ac_status=$?
7054   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7055   (exit $ac_status); }; } &&
7056          { ac_try='test -s conftest.$ac_objext'
7057   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7058   (eval $ac_try) 2>&5
7059   ac_status=$?
7060   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7061   (exit $ac_status); }; }; then
7062   ac_cv_type_int_least32_t=yes
7063 else
7064   echo "$as_me: failed program was:" >&5
7065 sed 's/^/| /' conftest.$ac_ext >&5
7066
7067 ac_cv_type_int_least32_t=no
7068 fi
7069 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7070 fi
7071 echo "$as_me:$LINENO: result: $ac_cv_type_int_least32_t" >&5
7072 echo "${ECHO_T}$ac_cv_type_int_least32_t" >&6
7073 if test $ac_cv_type_int_least32_t = yes; then
7074   :
7075 else
7076   acx_cv_header_stdint_kind="(mostly complete)"
7077 fi
7078
7079   echo "$as_me:$LINENO: checking for int_fast32_t" >&5
7080 echo $ECHO_N "checking for int_fast32_t... $ECHO_C" >&6
7081 if test "${ac_cv_type_int_fast32_t+set}" = set; then
7082   echo $ECHO_N "(cached) $ECHO_C" >&6
7083 else
7084   cat >conftest.$ac_ext <<_ACEOF
7085 /* confdefs.h.  */
7086 _ACEOF
7087 cat confdefs.h >>conftest.$ac_ext
7088 cat >>conftest.$ac_ext <<_ACEOF
7089 /* end confdefs.h.  */
7090 #include <sys/types.h>
7091 #include <$i>
7092
7093 int
7094 main ()
7095 {
7096 if ((int_fast32_t *) 0)
7097   return 0;
7098 if (sizeof (int_fast32_t))
7099   return 0;
7100   ;
7101   return 0;
7102 }
7103 _ACEOF
7104 rm -f conftest.$ac_objext
7105 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7106   (eval $ac_compile) 2>conftest.er1
7107   ac_status=$?
7108   grep -v '^ *+' conftest.er1 >conftest.err
7109   rm -f conftest.er1
7110   cat conftest.err >&5
7111   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7112   (exit $ac_status); } &&
7113          { ac_try='test -z "$ac_c_werror_flag"
7114                          || test ! -s conftest.err'
7115   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7116   (eval $ac_try) 2>&5
7117   ac_status=$?
7118   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7119   (exit $ac_status); }; } &&
7120          { ac_try='test -s conftest.$ac_objext'
7121   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7122   (eval $ac_try) 2>&5
7123   ac_status=$?
7124   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7125   (exit $ac_status); }; }; then
7126   ac_cv_type_int_fast32_t=yes
7127 else
7128   echo "$as_me: failed program was:" >&5
7129 sed 's/^/| /' conftest.$ac_ext >&5
7130
7131 ac_cv_type_int_fast32_t=no
7132 fi
7133 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7134 fi
7135 echo "$as_me:$LINENO: result: $ac_cv_type_int_fast32_t" >&5
7136 echo "${ECHO_T}$ac_cv_type_int_fast32_t" >&6
7137 if test $ac_cv_type_int_fast32_t = yes; then
7138   :
7139 else
7140   acx_cv_header_stdint_kind="(mostly complete)"
7141 fi
7142
7143   echo "$as_me:$LINENO: checking for uint64_t" >&5
7144 echo $ECHO_N "checking for uint64_t... $ECHO_C" >&6
7145 if test "${ac_cv_type_uint64_t+set}" = set; then
7146   echo $ECHO_N "(cached) $ECHO_C" >&6
7147 else
7148   cat >conftest.$ac_ext <<_ACEOF
7149 /* confdefs.h.  */
7150 _ACEOF
7151 cat confdefs.h >>conftest.$ac_ext
7152 cat >>conftest.$ac_ext <<_ACEOF
7153 /* end confdefs.h.  */
7154 #include <sys/types.h>
7155 #include <$i>
7156
7157 int
7158 main ()
7159 {
7160 if ((uint64_t *) 0)
7161   return 0;
7162 if (sizeof (uint64_t))
7163   return 0;
7164   ;
7165   return 0;
7166 }
7167 _ACEOF
7168 rm -f conftest.$ac_objext
7169 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7170   (eval $ac_compile) 2>conftest.er1
7171   ac_status=$?
7172   grep -v '^ *+' conftest.er1 >conftest.err
7173   rm -f conftest.er1
7174   cat conftest.err >&5
7175   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7176   (exit $ac_status); } &&
7177          { ac_try='test -z "$ac_c_werror_flag"
7178                          || test ! -s conftest.err'
7179   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7180   (eval $ac_try) 2>&5
7181   ac_status=$?
7182   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7183   (exit $ac_status); }; } &&
7184          { ac_try='test -s conftest.$ac_objext'
7185   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7186   (eval $ac_try) 2>&5
7187   ac_status=$?
7188   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7189   (exit $ac_status); }; }; then
7190   ac_cv_type_uint64_t=yes
7191 else
7192   echo "$as_me: failed program was:" >&5
7193 sed 's/^/| /' conftest.$ac_ext >&5
7194
7195 ac_cv_type_uint64_t=no
7196 fi
7197 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7198 fi
7199 echo "$as_me:$LINENO: result: $ac_cv_type_uint64_t" >&5
7200 echo "${ECHO_T}$ac_cv_type_uint64_t" >&6
7201 if test $ac_cv_type_uint64_t = yes; then
7202   :
7203 else
7204   acx_cv_header_stdint_kind="(lacks uint64_t)"
7205 fi
7206
7207   break
7208 done
7209 if test "$acx_cv_header_stdint" = stddef.h; then
7210   acx_cv_header_stdint_kind="(lacks uintmax_t)"
7211   for i in stdint.h $inttype_headers; do
7212     unset ac_cv_type_uintptr_t
7213     unset ac_cv_type_uint32_t
7214     unset ac_cv_type_uint64_t
7215     echo $ECHO_N "looking for an incomplete stdint.h in $i, $ECHO_C" >&6
7216     echo "$as_me:$LINENO: checking for uint32_t" >&5
7217 echo $ECHO_N "checking for uint32_t... $ECHO_C" >&6
7218 if test "${ac_cv_type_uint32_t+set}" = set; then
7219   echo $ECHO_N "(cached) $ECHO_C" >&6
7220 else
7221   cat >conftest.$ac_ext <<_ACEOF
7222 /* confdefs.h.  */
7223 _ACEOF
7224 cat confdefs.h >>conftest.$ac_ext
7225 cat >>conftest.$ac_ext <<_ACEOF
7226 /* end confdefs.h.  */
7227 #include <sys/types.h>
7228 #include <$i>
7229
7230 int
7231 main ()
7232 {
7233 if ((uint32_t *) 0)
7234   return 0;
7235 if (sizeof (uint32_t))
7236   return 0;
7237   ;
7238   return 0;
7239 }
7240 _ACEOF
7241 rm -f conftest.$ac_objext
7242 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7243   (eval $ac_compile) 2>conftest.er1
7244   ac_status=$?
7245   grep -v '^ *+' conftest.er1 >conftest.err
7246   rm -f conftest.er1
7247   cat conftest.err >&5
7248   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7249   (exit $ac_status); } &&
7250          { ac_try='test -z "$ac_c_werror_flag"
7251                          || test ! -s conftest.err'
7252   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7253   (eval $ac_try) 2>&5
7254   ac_status=$?
7255   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7256   (exit $ac_status); }; } &&
7257          { ac_try='test -s conftest.$ac_objext'
7258   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7259   (eval $ac_try) 2>&5
7260   ac_status=$?
7261   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7262   (exit $ac_status); }; }; then
7263   ac_cv_type_uint32_t=yes
7264 else
7265   echo "$as_me: failed program was:" >&5
7266 sed 's/^/| /' conftest.$ac_ext >&5
7267
7268 ac_cv_type_uint32_t=no
7269 fi
7270 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7271 fi
7272 echo "$as_me:$LINENO: result: $ac_cv_type_uint32_t" >&5
7273 echo "${ECHO_T}$ac_cv_type_uint32_t" >&6
7274 if test $ac_cv_type_uint32_t = yes; then
7275   acx_cv_header_stdint=$i
7276 else
7277   continue
7278 fi
7279
7280     echo "$as_me:$LINENO: checking for uint64_t" >&5
7281 echo $ECHO_N "checking for uint64_t... $ECHO_C" >&6
7282 if test "${ac_cv_type_uint64_t+set}" = set; then
7283   echo $ECHO_N "(cached) $ECHO_C" >&6
7284 else
7285   cat >conftest.$ac_ext <<_ACEOF
7286 /* confdefs.h.  */
7287 _ACEOF
7288 cat confdefs.h >>conftest.$ac_ext
7289 cat >>conftest.$ac_ext <<_ACEOF
7290 /* end confdefs.h.  */
7291 #include <sys/types.h>
7292 #include <$i>
7293
7294 int
7295 main ()
7296 {
7297 if ((uint64_t *) 0)
7298   return 0;
7299 if (sizeof (uint64_t))
7300   return 0;
7301   ;
7302   return 0;
7303 }
7304 _ACEOF
7305 rm -f conftest.$ac_objext
7306 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7307   (eval $ac_compile) 2>conftest.er1
7308   ac_status=$?
7309   grep -v '^ *+' conftest.er1 >conftest.err
7310   rm -f conftest.er1
7311   cat conftest.err >&5
7312   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7313   (exit $ac_status); } &&
7314          { ac_try='test -z "$ac_c_werror_flag"
7315                          || test ! -s conftest.err'
7316   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7317   (eval $ac_try) 2>&5
7318   ac_status=$?
7319   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7320   (exit $ac_status); }; } &&
7321          { ac_try='test -s conftest.$ac_objext'
7322   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7323   (eval $ac_try) 2>&5
7324   ac_status=$?
7325   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7326   (exit $ac_status); }; }; then
7327   ac_cv_type_uint64_t=yes
7328 else
7329   echo "$as_me: failed program was:" >&5
7330 sed 's/^/| /' conftest.$ac_ext >&5
7331
7332 ac_cv_type_uint64_t=no
7333 fi
7334 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7335 fi
7336 echo "$as_me:$LINENO: result: $ac_cv_type_uint64_t" >&5
7337 echo "${ECHO_T}$ac_cv_type_uint64_t" >&6
7338
7339     echo "$as_me:$LINENO: checking for uintptr_t" >&5
7340 echo $ECHO_N "checking for uintptr_t... $ECHO_C" >&6
7341 if test "${ac_cv_type_uintptr_t+set}" = set; then
7342   echo $ECHO_N "(cached) $ECHO_C" >&6
7343 else
7344   cat >conftest.$ac_ext <<_ACEOF
7345 /* confdefs.h.  */
7346 _ACEOF
7347 cat confdefs.h >>conftest.$ac_ext
7348 cat >>conftest.$ac_ext <<_ACEOF
7349 /* end confdefs.h.  */
7350 #include <sys/types.h>
7351 #include <$i>
7352
7353 int
7354 main ()
7355 {
7356 if ((uintptr_t *) 0)
7357   return 0;
7358 if (sizeof (uintptr_t))
7359   return 0;
7360   ;
7361   return 0;
7362 }
7363 _ACEOF
7364 rm -f conftest.$ac_objext
7365 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7366   (eval $ac_compile) 2>conftest.er1
7367   ac_status=$?
7368   grep -v '^ *+' conftest.er1 >conftest.err
7369   rm -f conftest.er1
7370   cat conftest.err >&5
7371   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7372   (exit $ac_status); } &&
7373          { ac_try='test -z "$ac_c_werror_flag"
7374                          || test ! -s conftest.err'
7375   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7376   (eval $ac_try) 2>&5
7377   ac_status=$?
7378   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7379   (exit $ac_status); }; } &&
7380          { ac_try='test -s conftest.$ac_objext'
7381   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7382   (eval $ac_try) 2>&5
7383   ac_status=$?
7384   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7385   (exit $ac_status); }; }; then
7386   ac_cv_type_uintptr_t=yes
7387 else
7388   echo "$as_me: failed program was:" >&5
7389 sed 's/^/| /' conftest.$ac_ext >&5
7390
7391 ac_cv_type_uintptr_t=no
7392 fi
7393 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7394 fi
7395 echo "$as_me:$LINENO: result: $ac_cv_type_uintptr_t" >&5
7396 echo "${ECHO_T}$ac_cv_type_uintptr_t" >&6
7397
7398     break
7399   done
7400 fi
7401 if test "$acx_cv_header_stdint" = stddef.h; then
7402   acx_cv_header_stdint_kind="(u_intXX_t style)"
7403   for i in sys/types.h $inttype_headers; do
7404     unset ac_cv_type_u_int32_t
7405     unset ac_cv_type_u_int64_t
7406     echo $ECHO_N "looking for u_intXX_t types in $i, $ECHO_C" >&6
7407     echo "$as_me:$LINENO: checking for u_int32_t" >&5
7408 echo $ECHO_N "checking for u_int32_t... $ECHO_C" >&6
7409 if test "${ac_cv_type_u_int32_t+set}" = set; then
7410   echo $ECHO_N "(cached) $ECHO_C" >&6
7411 else
7412   cat >conftest.$ac_ext <<_ACEOF
7413 /* confdefs.h.  */
7414 _ACEOF
7415 cat confdefs.h >>conftest.$ac_ext
7416 cat >>conftest.$ac_ext <<_ACEOF
7417 /* end confdefs.h.  */
7418 #include <sys/types.h>
7419 #include <$i>
7420
7421 int
7422 main ()
7423 {
7424 if ((u_int32_t *) 0)
7425   return 0;
7426 if (sizeof (u_int32_t))
7427   return 0;
7428   ;
7429   return 0;
7430 }
7431 _ACEOF
7432 rm -f conftest.$ac_objext
7433 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7434   (eval $ac_compile) 2>conftest.er1
7435   ac_status=$?
7436   grep -v '^ *+' conftest.er1 >conftest.err
7437   rm -f conftest.er1
7438   cat conftest.err >&5
7439   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7440   (exit $ac_status); } &&
7441          { ac_try='test -z "$ac_c_werror_flag"
7442                          || test ! -s conftest.err'
7443   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7444   (eval $ac_try) 2>&5
7445   ac_status=$?
7446   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7447   (exit $ac_status); }; } &&
7448          { ac_try='test -s conftest.$ac_objext'
7449   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7450   (eval $ac_try) 2>&5
7451   ac_status=$?
7452   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7453   (exit $ac_status); }; }; then
7454   ac_cv_type_u_int32_t=yes
7455 else
7456   echo "$as_me: failed program was:" >&5
7457 sed 's/^/| /' conftest.$ac_ext >&5
7458
7459 ac_cv_type_u_int32_t=no
7460 fi
7461 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7462 fi
7463 echo "$as_me:$LINENO: result: $ac_cv_type_u_int32_t" >&5
7464 echo "${ECHO_T}$ac_cv_type_u_int32_t" >&6
7465 if test $ac_cv_type_u_int32_t = yes; then
7466   acx_cv_header_stdint=$i
7467 else
7468   continue
7469 fi
7470
7471     echo "$as_me:$LINENO: checking for u_int64_t" >&5
7472 echo $ECHO_N "checking for u_int64_t... $ECHO_C" >&6
7473 if test "${ac_cv_type_u_int64_t+set}" = set; then
7474   echo $ECHO_N "(cached) $ECHO_C" >&6
7475 else
7476   cat >conftest.$ac_ext <<_ACEOF
7477 /* confdefs.h.  */
7478 _ACEOF
7479 cat confdefs.h >>conftest.$ac_ext
7480 cat >>conftest.$ac_ext <<_ACEOF
7481 /* end confdefs.h.  */
7482 #include <sys/types.h>
7483 #include <$i>
7484
7485 int
7486 main ()
7487 {
7488 if ((u_int64_t *) 0)
7489   return 0;
7490 if (sizeof (u_int64_t))
7491   return 0;
7492   ;
7493   return 0;
7494 }
7495 _ACEOF
7496 rm -f conftest.$ac_objext
7497 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7498   (eval $ac_compile) 2>conftest.er1
7499   ac_status=$?
7500   grep -v '^ *+' conftest.er1 >conftest.err
7501   rm -f conftest.er1
7502   cat conftest.err >&5
7503   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7504   (exit $ac_status); } &&
7505          { ac_try='test -z "$ac_c_werror_flag"
7506                          || test ! -s conftest.err'
7507   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7508   (eval $ac_try) 2>&5
7509   ac_status=$?
7510   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7511   (exit $ac_status); }; } &&
7512          { ac_try='test -s conftest.$ac_objext'
7513   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7514   (eval $ac_try) 2>&5
7515   ac_status=$?
7516   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7517   (exit $ac_status); }; }; then
7518   ac_cv_type_u_int64_t=yes
7519 else
7520   echo "$as_me: failed program was:" >&5
7521 sed 's/^/| /' conftest.$ac_ext >&5
7522
7523 ac_cv_type_u_int64_t=no
7524 fi
7525 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7526 fi
7527 echo "$as_me:$LINENO: result: $ac_cv_type_u_int64_t" >&5
7528 echo "${ECHO_T}$ac_cv_type_u_int64_t" >&6
7529
7530     break
7531   done
7532 fi
7533 if test "$acx_cv_header_stdint" = stddef.h; then
7534   acx_cv_header_stdint_kind="(using manual detection)"
7535 fi
7536
7537 test -z "$ac_cv_type_uintptr_t" && ac_cv_type_uintptr_t=no
7538 test -z "$ac_cv_type_uint64_t" && ac_cv_type_uint64_t=no
7539 test -z "$ac_cv_type_u_int64_t" && ac_cv_type_u_int64_t=no
7540 test -z "$ac_cv_type_int_least32_t" && ac_cv_type_int_least32_t=no
7541 test -z "$ac_cv_type_int_fast32_t" && ac_cv_type_int_fast32_t=no
7542
7543 # ----------------- Summarize what we found so far
7544
7545 echo "$as_me:$LINENO: checking what to include in gstdint.h" >&5
7546 echo $ECHO_N "checking what to include in gstdint.h... $ECHO_C" >&6
7547
7548 case `$as_basename gstdint.h ||
7549 $as_expr X/gstdint.h : '.*/\([^/][^/]*\)/*$' \| \
7550          Xgstdint.h : 'X\(//\)$' \| \
7551          Xgstdint.h : 'X\(/\)$' \| \
7552          .     : '\(.\)' 2>/dev/null ||
7553 echo X/gstdint.h |
7554     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
7555           /^X\/\(\/\/\)$/{ s//\1/; q; }
7556           /^X\/\(\/\).*/{ s//\1/; q; }
7557           s/.*/./; q'` in
7558   stdint.h) { echo "$as_me:$LINENO: WARNING: are you sure you want it there?" >&5
7559 echo "$as_me: WARNING: are you sure you want it there?" >&2;} ;;
7560   inttypes.h) { echo "$as_me:$LINENO: WARNING: are you sure you want it there?" >&5
7561 echo "$as_me: WARNING: are you sure you want it there?" >&2;} ;;
7562   *) ;;
7563 esac
7564
7565 echo "$as_me:$LINENO: result: $acx_cv_header_stdint $acx_cv_header_stdint_kind" >&5
7566 echo "${ECHO_T}$acx_cv_header_stdint $acx_cv_header_stdint_kind" >&6
7567
7568 # ----------------- done included file, check C basic types --------
7569
7570 # Lacking an uintptr_t?  Test size of void *
7571 case "$acx_cv_header_stdint:$ac_cv_type_uintptr_t" in
7572   stddef.h:* | *:no) echo "$as_me:$LINENO: checking for void *" >&5
7573 echo $ECHO_N "checking for void *... $ECHO_C" >&6
7574 if test "${ac_cv_type_void_p+set}" = set; then
7575   echo $ECHO_N "(cached) $ECHO_C" >&6
7576 else
7577   cat >conftest.$ac_ext <<_ACEOF
7578 /* confdefs.h.  */
7579 _ACEOF
7580 cat confdefs.h >>conftest.$ac_ext
7581 cat >>conftest.$ac_ext <<_ACEOF
7582 /* end confdefs.h.  */
7583 $ac_includes_default
7584 int
7585 main ()
7586 {
7587 if ((void * *) 0)
7588   return 0;
7589 if (sizeof (void *))
7590   return 0;
7591   ;
7592   return 0;
7593 }
7594 _ACEOF
7595 rm -f conftest.$ac_objext
7596 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7597   (eval $ac_compile) 2>conftest.er1
7598   ac_status=$?
7599   grep -v '^ *+' conftest.er1 >conftest.err
7600   rm -f conftest.er1
7601   cat conftest.err >&5
7602   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7603   (exit $ac_status); } &&
7604          { ac_try='test -z "$ac_c_werror_flag"
7605                          || test ! -s conftest.err'
7606   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7607   (eval $ac_try) 2>&5
7608   ac_status=$?
7609   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7610   (exit $ac_status); }; } &&
7611          { ac_try='test -s conftest.$ac_objext'
7612   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7613   (eval $ac_try) 2>&5
7614   ac_status=$?
7615   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7616   (exit $ac_status); }; }; then
7617   ac_cv_type_void_p=yes
7618 else
7619   echo "$as_me: failed program was:" >&5
7620 sed 's/^/| /' conftest.$ac_ext >&5
7621
7622 ac_cv_type_void_p=no
7623 fi
7624 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7625 fi
7626 echo "$as_me:$LINENO: result: $ac_cv_type_void_p" >&5
7627 echo "${ECHO_T}$ac_cv_type_void_p" >&6
7628
7629 echo "$as_me:$LINENO: checking size of void *" >&5
7630 echo $ECHO_N "checking size of void *... $ECHO_C" >&6
7631 if test "${ac_cv_sizeof_void_p+set}" = set; then
7632   echo $ECHO_N "(cached) $ECHO_C" >&6
7633 else
7634   if test "$ac_cv_type_void_p" = yes; then
7635   # The cast to unsigned long works around a bug in the HP C Compiler
7636   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
7637   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
7638   # This bug is HP SR number 8606223364.
7639   if test "$cross_compiling" = yes; then
7640   # Depending upon the size, compute the lo and hi bounds.
7641 cat >conftest.$ac_ext <<_ACEOF
7642 /* confdefs.h.  */
7643 _ACEOF
7644 cat confdefs.h >>conftest.$ac_ext
7645 cat >>conftest.$ac_ext <<_ACEOF
7646 /* end confdefs.h.  */
7647 $ac_includes_default
7648 int
7649 main ()
7650 {
7651 static int test_array [1 - 2 * !(((long) (sizeof (void *))) >= 0)];
7652 test_array [0] = 0
7653
7654   ;
7655   return 0;
7656 }
7657 _ACEOF
7658 rm -f conftest.$ac_objext
7659 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7660   (eval $ac_compile) 2>conftest.er1
7661   ac_status=$?
7662   grep -v '^ *+' conftest.er1 >conftest.err
7663   rm -f conftest.er1
7664   cat conftest.err >&5
7665   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7666   (exit $ac_status); } &&
7667          { ac_try='test -z "$ac_c_werror_flag"
7668                          || test ! -s conftest.err'
7669   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7670   (eval $ac_try) 2>&5
7671   ac_status=$?
7672   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7673   (exit $ac_status); }; } &&
7674          { ac_try='test -s conftest.$ac_objext'
7675   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7676   (eval $ac_try) 2>&5
7677   ac_status=$?
7678   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7679   (exit $ac_status); }; }; then
7680   ac_lo=0 ac_mid=0
7681   while :; do
7682     cat >conftest.$ac_ext <<_ACEOF
7683 /* confdefs.h.  */
7684 _ACEOF
7685 cat confdefs.h >>conftest.$ac_ext
7686 cat >>conftest.$ac_ext <<_ACEOF
7687 /* end confdefs.h.  */
7688 $ac_includes_default
7689 int
7690 main ()
7691 {
7692 static int test_array [1 - 2 * !(((long) (sizeof (void *))) <= $ac_mid)];
7693 test_array [0] = 0
7694
7695   ;
7696   return 0;
7697 }
7698 _ACEOF
7699 rm -f conftest.$ac_objext
7700 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7701   (eval $ac_compile) 2>conftest.er1
7702   ac_status=$?
7703   grep -v '^ *+' conftest.er1 >conftest.err
7704   rm -f conftest.er1
7705   cat conftest.err >&5
7706   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7707   (exit $ac_status); } &&
7708          { ac_try='test -z "$ac_c_werror_flag"
7709                          || test ! -s conftest.err'
7710   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7711   (eval $ac_try) 2>&5
7712   ac_status=$?
7713   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7714   (exit $ac_status); }; } &&
7715          { ac_try='test -s conftest.$ac_objext'
7716   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7717   (eval $ac_try) 2>&5
7718   ac_status=$?
7719   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7720   (exit $ac_status); }; }; then
7721   ac_hi=$ac_mid; break
7722 else
7723   echo "$as_me: failed program was:" >&5
7724 sed 's/^/| /' conftest.$ac_ext >&5
7725
7726 ac_lo=`expr $ac_mid + 1`
7727                     if test $ac_lo -le $ac_mid; then
7728                       ac_lo= ac_hi=
7729                       break
7730                     fi
7731                     ac_mid=`expr 2 '*' $ac_mid + 1`
7732 fi
7733 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7734   done
7735 else
7736   echo "$as_me: failed program was:" >&5
7737 sed 's/^/| /' conftest.$ac_ext >&5
7738
7739 cat >conftest.$ac_ext <<_ACEOF
7740 /* confdefs.h.  */
7741 _ACEOF
7742 cat confdefs.h >>conftest.$ac_ext
7743 cat >>conftest.$ac_ext <<_ACEOF
7744 /* end confdefs.h.  */
7745 $ac_includes_default
7746 int
7747 main ()
7748 {
7749 static int test_array [1 - 2 * !(((long) (sizeof (void *))) < 0)];
7750 test_array [0] = 0
7751
7752   ;
7753   return 0;
7754 }
7755 _ACEOF
7756 rm -f conftest.$ac_objext
7757 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7758   (eval $ac_compile) 2>conftest.er1
7759   ac_status=$?
7760   grep -v '^ *+' conftest.er1 >conftest.err
7761   rm -f conftest.er1
7762   cat conftest.err >&5
7763   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7764   (exit $ac_status); } &&
7765          { ac_try='test -z "$ac_c_werror_flag"
7766                          || test ! -s conftest.err'
7767   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7768   (eval $ac_try) 2>&5
7769   ac_status=$?
7770   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7771   (exit $ac_status); }; } &&
7772          { ac_try='test -s conftest.$ac_objext'
7773   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7774   (eval $ac_try) 2>&5
7775   ac_status=$?
7776   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7777   (exit $ac_status); }; }; then
7778   ac_hi=-1 ac_mid=-1
7779   while :; do
7780     cat >conftest.$ac_ext <<_ACEOF
7781 /* confdefs.h.  */
7782 _ACEOF
7783 cat confdefs.h >>conftest.$ac_ext
7784 cat >>conftest.$ac_ext <<_ACEOF
7785 /* end confdefs.h.  */
7786 $ac_includes_default
7787 int
7788 main ()
7789 {
7790 static int test_array [1 - 2 * !(((long) (sizeof (void *))) >= $ac_mid)];
7791 test_array [0] = 0
7792
7793   ;
7794   return 0;
7795 }
7796 _ACEOF
7797 rm -f conftest.$ac_objext
7798 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7799   (eval $ac_compile) 2>conftest.er1
7800   ac_status=$?
7801   grep -v '^ *+' conftest.er1 >conftest.err
7802   rm -f conftest.er1
7803   cat conftest.err >&5
7804   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7805   (exit $ac_status); } &&
7806          { ac_try='test -z "$ac_c_werror_flag"
7807                          || test ! -s conftest.err'
7808   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7809   (eval $ac_try) 2>&5
7810   ac_status=$?
7811   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7812   (exit $ac_status); }; } &&
7813          { ac_try='test -s conftest.$ac_objext'
7814   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7815   (eval $ac_try) 2>&5
7816   ac_status=$?
7817   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7818   (exit $ac_status); }; }; then
7819   ac_lo=$ac_mid; break
7820 else
7821   echo "$as_me: failed program was:" >&5
7822 sed 's/^/| /' conftest.$ac_ext >&5
7823
7824 ac_hi=`expr '(' $ac_mid ')' - 1`
7825                        if test $ac_mid -le $ac_hi; then
7826                          ac_lo= ac_hi=
7827                          break
7828                        fi
7829                        ac_mid=`expr 2 '*' $ac_mid`
7830 fi
7831 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7832   done
7833 else
7834   echo "$as_me: failed program was:" >&5
7835 sed 's/^/| /' conftest.$ac_ext >&5
7836
7837 ac_lo= ac_hi=
7838 fi
7839 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7840 fi
7841 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7842 # Binary search between lo and hi bounds.
7843 while test "x$ac_lo" != "x$ac_hi"; do
7844   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
7845   cat >conftest.$ac_ext <<_ACEOF
7846 /* confdefs.h.  */
7847 _ACEOF
7848 cat confdefs.h >>conftest.$ac_ext
7849 cat >>conftest.$ac_ext <<_ACEOF
7850 /* end confdefs.h.  */
7851 $ac_includes_default
7852 int
7853 main ()
7854 {
7855 static int test_array [1 - 2 * !(((long) (sizeof (void *))) <= $ac_mid)];
7856 test_array [0] = 0
7857
7858   ;
7859   return 0;
7860 }
7861 _ACEOF
7862 rm -f conftest.$ac_objext
7863 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7864   (eval $ac_compile) 2>conftest.er1
7865   ac_status=$?
7866   grep -v '^ *+' conftest.er1 >conftest.err
7867   rm -f conftest.er1
7868   cat conftest.err >&5
7869   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7870   (exit $ac_status); } &&
7871          { ac_try='test -z "$ac_c_werror_flag"
7872                          || test ! -s conftest.err'
7873   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7874   (eval $ac_try) 2>&5
7875   ac_status=$?
7876   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7877   (exit $ac_status); }; } &&
7878          { ac_try='test -s conftest.$ac_objext'
7879   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7880   (eval $ac_try) 2>&5
7881   ac_status=$?
7882   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7883   (exit $ac_status); }; }; then
7884   ac_hi=$ac_mid
7885 else
7886   echo "$as_me: failed program was:" >&5
7887 sed 's/^/| /' conftest.$ac_ext >&5
7888
7889 ac_lo=`expr '(' $ac_mid ')' + 1`
7890 fi
7891 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7892 done
7893 case $ac_lo in
7894 ?*) ac_cv_sizeof_void_p=$ac_lo;;
7895 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (void *), 77
7896 See \`config.log' for more details." >&5
7897 echo "$as_me: error: cannot compute sizeof (void *), 77
7898 See \`config.log' for more details." >&2;}
7899    { (exit 1); exit 1; }; } ;;
7900 esac
7901 else
7902   if test "$cross_compiling" = yes; then
7903   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
7904 See \`config.log' for more details." >&5
7905 echo "$as_me: error: cannot run test program while cross compiling
7906 See \`config.log' for more details." >&2;}
7907    { (exit 1); exit 1; }; }
7908 else
7909   cat >conftest.$ac_ext <<_ACEOF
7910 /* confdefs.h.  */
7911 _ACEOF
7912 cat confdefs.h >>conftest.$ac_ext
7913 cat >>conftest.$ac_ext <<_ACEOF
7914 /* end confdefs.h.  */
7915 $ac_includes_default
7916 long longval () { return (long) (sizeof (void *)); }
7917 unsigned long ulongval () { return (long) (sizeof (void *)); }
7918 #include <stdio.h>
7919 #include <stdlib.h>
7920 int
7921 main ()
7922 {
7923
7924   FILE *f = fopen ("conftest.val", "w");
7925   if (! f)
7926     exit (1);
7927   if (((long) (sizeof (void *))) < 0)
7928     {
7929       long i = longval ();
7930       if (i != ((long) (sizeof (void *))))
7931         exit (1);
7932       fprintf (f, "%ld\n", i);
7933     }
7934   else
7935     {
7936       unsigned long i = ulongval ();
7937       if (i != ((long) (sizeof (void *))))
7938         exit (1);
7939       fprintf (f, "%lu\n", i);
7940     }
7941   exit (ferror (f) || fclose (f) != 0);
7942
7943   ;
7944   return 0;
7945 }
7946 _ACEOF
7947 rm -f conftest$ac_exeext
7948 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7949   (eval $ac_link) 2>&5
7950   ac_status=$?
7951   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7952   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7953   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7954   (eval $ac_try) 2>&5
7955   ac_status=$?
7956   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7957   (exit $ac_status); }; }; then
7958   ac_cv_sizeof_void_p=`cat conftest.val`
7959 else
7960   echo "$as_me: program exited with status $ac_status" >&5
7961 echo "$as_me: failed program was:" >&5
7962 sed 's/^/| /' conftest.$ac_ext >&5
7963
7964 ( exit $ac_status )
7965 { { echo "$as_me:$LINENO: error: cannot compute sizeof (void *), 77
7966 See \`config.log' for more details." >&5
7967 echo "$as_me: error: cannot compute sizeof (void *), 77
7968 See \`config.log' for more details." >&2;}
7969    { (exit 1); exit 1; }; }
7970 fi
7971 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7972 fi
7973 fi
7974 rm -f conftest.val
7975 else
7976   ac_cv_sizeof_void_p=0
7977 fi
7978 fi
7979 echo "$as_me:$LINENO: result: $ac_cv_sizeof_void_p" >&5
7980 echo "${ECHO_T}$ac_cv_sizeof_void_p" >&6
7981 cat >>confdefs.h <<_ACEOF
7982 #define SIZEOF_VOID_P $ac_cv_sizeof_void_p
7983 _ACEOF
7984
7985  ;;
7986 esac
7987
7988 # Lacking an uint64_t?  Test size of long
7989 case "$acx_cv_header_stdint:$ac_cv_type_uint64_t:$ac_cv_type_u_int64_t" in
7990   stddef.h:*:* | *:no:no) echo "$as_me:$LINENO: checking for long" >&5
7991 echo $ECHO_N "checking for long... $ECHO_C" >&6
7992 if test "${ac_cv_type_long+set}" = set; then
7993   echo $ECHO_N "(cached) $ECHO_C" >&6
7994 else
7995   cat >conftest.$ac_ext <<_ACEOF
7996 /* confdefs.h.  */
7997 _ACEOF
7998 cat confdefs.h >>conftest.$ac_ext
7999 cat >>conftest.$ac_ext <<_ACEOF
8000 /* end confdefs.h.  */
8001 $ac_includes_default
8002 int
8003 main ()
8004 {
8005 if ((long *) 0)
8006   return 0;
8007 if (sizeof (long))
8008   return 0;
8009   ;
8010   return 0;
8011 }
8012 _ACEOF
8013 rm -f conftest.$ac_objext
8014 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8015   (eval $ac_compile) 2>conftest.er1
8016   ac_status=$?
8017   grep -v '^ *+' conftest.er1 >conftest.err
8018   rm -f conftest.er1
8019   cat conftest.err >&5
8020   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8021   (exit $ac_status); } &&
8022          { ac_try='test -z "$ac_c_werror_flag"
8023                          || test ! -s conftest.err'
8024   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8025   (eval $ac_try) 2>&5
8026   ac_status=$?
8027   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8028   (exit $ac_status); }; } &&
8029          { ac_try='test -s conftest.$ac_objext'
8030   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8031   (eval $ac_try) 2>&5
8032   ac_status=$?
8033   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8034   (exit $ac_status); }; }; then
8035   ac_cv_type_long=yes
8036 else
8037   echo "$as_me: failed program was:" >&5
8038 sed 's/^/| /' conftest.$ac_ext >&5
8039
8040 ac_cv_type_long=no
8041 fi
8042 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8043 fi
8044 echo "$as_me:$LINENO: result: $ac_cv_type_long" >&5
8045 echo "${ECHO_T}$ac_cv_type_long" >&6
8046
8047 echo "$as_me:$LINENO: checking size of long" >&5
8048 echo $ECHO_N "checking size of long... $ECHO_C" >&6
8049 if test "${ac_cv_sizeof_long+set}" = set; then
8050   echo $ECHO_N "(cached) $ECHO_C" >&6
8051 else
8052   if test "$ac_cv_type_long" = yes; then
8053   # The cast to unsigned long works around a bug in the HP C Compiler
8054   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
8055   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
8056   # This bug is HP SR number 8606223364.
8057   if test "$cross_compiling" = yes; then
8058   # Depending upon the size, compute the lo and hi bounds.
8059 cat >conftest.$ac_ext <<_ACEOF
8060 /* confdefs.h.  */
8061 _ACEOF
8062 cat confdefs.h >>conftest.$ac_ext
8063 cat >>conftest.$ac_ext <<_ACEOF
8064 /* end confdefs.h.  */
8065 $ac_includes_default
8066 int
8067 main ()
8068 {
8069 static int test_array [1 - 2 * !(((long) (sizeof (long))) >= 0)];
8070 test_array [0] = 0
8071
8072   ;
8073   return 0;
8074 }
8075 _ACEOF
8076 rm -f conftest.$ac_objext
8077 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8078   (eval $ac_compile) 2>conftest.er1
8079   ac_status=$?
8080   grep -v '^ *+' conftest.er1 >conftest.err
8081   rm -f conftest.er1
8082   cat conftest.err >&5
8083   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8084   (exit $ac_status); } &&
8085          { ac_try='test -z "$ac_c_werror_flag"
8086                          || test ! -s conftest.err'
8087   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8088   (eval $ac_try) 2>&5
8089   ac_status=$?
8090   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8091   (exit $ac_status); }; } &&
8092          { ac_try='test -s conftest.$ac_objext'
8093   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8094   (eval $ac_try) 2>&5
8095   ac_status=$?
8096   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8097   (exit $ac_status); }; }; then
8098   ac_lo=0 ac_mid=0
8099   while :; do
8100     cat >conftest.$ac_ext <<_ACEOF
8101 /* confdefs.h.  */
8102 _ACEOF
8103 cat confdefs.h >>conftest.$ac_ext
8104 cat >>conftest.$ac_ext <<_ACEOF
8105 /* end confdefs.h.  */
8106 $ac_includes_default
8107 int
8108 main ()
8109 {
8110 static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];
8111 test_array [0] = 0
8112
8113   ;
8114   return 0;
8115 }
8116 _ACEOF
8117 rm -f conftest.$ac_objext
8118 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8119   (eval $ac_compile) 2>conftest.er1
8120   ac_status=$?
8121   grep -v '^ *+' conftest.er1 >conftest.err
8122   rm -f conftest.er1
8123   cat conftest.err >&5
8124   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8125   (exit $ac_status); } &&
8126          { ac_try='test -z "$ac_c_werror_flag"
8127                          || test ! -s conftest.err'
8128   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8129   (eval $ac_try) 2>&5
8130   ac_status=$?
8131   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8132   (exit $ac_status); }; } &&
8133          { ac_try='test -s conftest.$ac_objext'
8134   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8135   (eval $ac_try) 2>&5
8136   ac_status=$?
8137   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8138   (exit $ac_status); }; }; then
8139   ac_hi=$ac_mid; break
8140 else
8141   echo "$as_me: failed program was:" >&5
8142 sed 's/^/| /' conftest.$ac_ext >&5
8143
8144 ac_lo=`expr $ac_mid + 1`
8145                     if test $ac_lo -le $ac_mid; then
8146                       ac_lo= ac_hi=
8147                       break
8148                     fi
8149                     ac_mid=`expr 2 '*' $ac_mid + 1`
8150 fi
8151 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8152   done
8153 else
8154   echo "$as_me: failed program was:" >&5
8155 sed 's/^/| /' conftest.$ac_ext >&5
8156
8157 cat >conftest.$ac_ext <<_ACEOF
8158 /* confdefs.h.  */
8159 _ACEOF
8160 cat confdefs.h >>conftest.$ac_ext
8161 cat >>conftest.$ac_ext <<_ACEOF
8162 /* end confdefs.h.  */
8163 $ac_includes_default
8164 int
8165 main ()
8166 {
8167 static int test_array [1 - 2 * !(((long) (sizeof (long))) < 0)];
8168 test_array [0] = 0
8169
8170   ;
8171   return 0;
8172 }
8173 _ACEOF
8174 rm -f conftest.$ac_objext
8175 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8176   (eval $ac_compile) 2>conftest.er1
8177   ac_status=$?
8178   grep -v '^ *+' conftest.er1 >conftest.err
8179   rm -f conftest.er1
8180   cat conftest.err >&5
8181   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8182   (exit $ac_status); } &&
8183          { ac_try='test -z "$ac_c_werror_flag"
8184                          || test ! -s conftest.err'
8185   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8186   (eval $ac_try) 2>&5
8187   ac_status=$?
8188   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8189   (exit $ac_status); }; } &&
8190          { ac_try='test -s conftest.$ac_objext'
8191   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8192   (eval $ac_try) 2>&5
8193   ac_status=$?
8194   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8195   (exit $ac_status); }; }; then
8196   ac_hi=-1 ac_mid=-1
8197   while :; do
8198     cat >conftest.$ac_ext <<_ACEOF
8199 /* confdefs.h.  */
8200 _ACEOF
8201 cat confdefs.h >>conftest.$ac_ext
8202 cat >>conftest.$ac_ext <<_ACEOF
8203 /* end confdefs.h.  */
8204 $ac_includes_default
8205 int
8206 main ()
8207 {
8208 static int test_array [1 - 2 * !(((long) (sizeof (long))) >= $ac_mid)];
8209 test_array [0] = 0
8210
8211   ;
8212   return 0;
8213 }
8214 _ACEOF
8215 rm -f conftest.$ac_objext
8216 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8217   (eval $ac_compile) 2>conftest.er1
8218   ac_status=$?
8219   grep -v '^ *+' conftest.er1 >conftest.err
8220   rm -f conftest.er1
8221   cat conftest.err >&5
8222   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8223   (exit $ac_status); } &&
8224          { ac_try='test -z "$ac_c_werror_flag"
8225                          || test ! -s conftest.err'
8226   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8227   (eval $ac_try) 2>&5
8228   ac_status=$?
8229   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8230   (exit $ac_status); }; } &&
8231          { ac_try='test -s conftest.$ac_objext'
8232   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8233   (eval $ac_try) 2>&5
8234   ac_status=$?
8235   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8236   (exit $ac_status); }; }; then
8237   ac_lo=$ac_mid; break
8238 else
8239   echo "$as_me: failed program was:" >&5
8240 sed 's/^/| /' conftest.$ac_ext >&5
8241
8242 ac_hi=`expr '(' $ac_mid ')' - 1`
8243                        if test $ac_mid -le $ac_hi; then
8244                          ac_lo= ac_hi=
8245                          break
8246                        fi
8247                        ac_mid=`expr 2 '*' $ac_mid`
8248 fi
8249 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8250   done
8251 else
8252   echo "$as_me: failed program was:" >&5
8253 sed 's/^/| /' conftest.$ac_ext >&5
8254
8255 ac_lo= ac_hi=
8256 fi
8257 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8258 fi
8259 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8260 # Binary search between lo and hi bounds.
8261 while test "x$ac_lo" != "x$ac_hi"; do
8262   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
8263   cat >conftest.$ac_ext <<_ACEOF
8264 /* confdefs.h.  */
8265 _ACEOF
8266 cat confdefs.h >>conftest.$ac_ext
8267 cat >>conftest.$ac_ext <<_ACEOF
8268 /* end confdefs.h.  */
8269 $ac_includes_default
8270 int
8271 main ()
8272 {
8273 static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];
8274 test_array [0] = 0
8275
8276   ;
8277   return 0;
8278 }
8279 _ACEOF
8280 rm -f conftest.$ac_objext
8281 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8282   (eval $ac_compile) 2>conftest.er1
8283   ac_status=$?
8284   grep -v '^ *+' conftest.er1 >conftest.err
8285   rm -f conftest.er1
8286   cat conftest.err >&5
8287   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8288   (exit $ac_status); } &&
8289          { ac_try='test -z "$ac_c_werror_flag"
8290                          || test ! -s conftest.err'
8291   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8292   (eval $ac_try) 2>&5
8293   ac_status=$?
8294   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8295   (exit $ac_status); }; } &&
8296          { ac_try='test -s conftest.$ac_objext'
8297   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8298   (eval $ac_try) 2>&5
8299   ac_status=$?
8300   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8301   (exit $ac_status); }; }; then
8302   ac_hi=$ac_mid
8303 else
8304   echo "$as_me: failed program was:" >&5
8305 sed 's/^/| /' conftest.$ac_ext >&5
8306
8307 ac_lo=`expr '(' $ac_mid ')' + 1`
8308 fi
8309 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8310 done
8311 case $ac_lo in
8312 ?*) ac_cv_sizeof_long=$ac_lo;;
8313 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77
8314 See \`config.log' for more details." >&5
8315 echo "$as_me: error: cannot compute sizeof (long), 77
8316 See \`config.log' for more details." >&2;}
8317    { (exit 1); exit 1; }; } ;;
8318 esac
8319 else
8320   if test "$cross_compiling" = yes; then
8321   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
8322 See \`config.log' for more details." >&5
8323 echo "$as_me: error: cannot run test program while cross compiling
8324 See \`config.log' for more details." >&2;}
8325    { (exit 1); exit 1; }; }
8326 else
8327   cat >conftest.$ac_ext <<_ACEOF
8328 /* confdefs.h.  */
8329 _ACEOF
8330 cat confdefs.h >>conftest.$ac_ext
8331 cat >>conftest.$ac_ext <<_ACEOF
8332 /* end confdefs.h.  */
8333 $ac_includes_default
8334 long longval () { return (long) (sizeof (long)); }
8335 unsigned long ulongval () { return (long) (sizeof (long)); }
8336 #include <stdio.h>
8337 #include <stdlib.h>
8338 int
8339 main ()
8340 {
8341
8342   FILE *f = fopen ("conftest.val", "w");
8343   if (! f)
8344     exit (1);
8345   if (((long) (sizeof (long))) < 0)
8346     {
8347       long i = longval ();
8348       if (i != ((long) (sizeof (long))))
8349         exit (1);
8350       fprintf (f, "%ld\n", i);
8351     }
8352   else
8353     {
8354       unsigned long i = ulongval ();
8355       if (i != ((long) (sizeof (long))))
8356         exit (1);
8357       fprintf (f, "%lu\n", i);
8358     }
8359   exit (ferror (f) || fclose (f) != 0);
8360
8361   ;
8362   return 0;
8363 }
8364 _ACEOF
8365 rm -f conftest$ac_exeext
8366 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8367   (eval $ac_link) 2>&5
8368   ac_status=$?
8369   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8370   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8371   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8372   (eval $ac_try) 2>&5
8373   ac_status=$?
8374   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8375   (exit $ac_status); }; }; then
8376   ac_cv_sizeof_long=`cat conftest.val`
8377 else
8378   echo "$as_me: program exited with status $ac_status" >&5
8379 echo "$as_me: failed program was:" >&5
8380 sed 's/^/| /' conftest.$ac_ext >&5
8381
8382 ( exit $ac_status )
8383 { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77
8384 See \`config.log' for more details." >&5
8385 echo "$as_me: error: cannot compute sizeof (long), 77
8386 See \`config.log' for more details." >&2;}
8387    { (exit 1); exit 1; }; }
8388 fi
8389 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8390 fi
8391 fi
8392 rm -f conftest.val
8393 else
8394   ac_cv_sizeof_long=0
8395 fi
8396 fi
8397 echo "$as_me:$LINENO: result: $ac_cv_sizeof_long" >&5
8398 echo "${ECHO_T}$ac_cv_sizeof_long" >&6
8399 cat >>confdefs.h <<_ACEOF
8400 #define SIZEOF_LONG $ac_cv_sizeof_long
8401 _ACEOF
8402
8403  ;;
8404 esac
8405
8406 if test $acx_cv_header_stdint = stddef.h; then
8407   # Lacking a good header?  Test size of everything and deduce all types.
8408   echo "$as_me:$LINENO: checking for int" >&5
8409 echo $ECHO_N "checking for int... $ECHO_C" >&6
8410 if test "${ac_cv_type_int+set}" = set; then
8411   echo $ECHO_N "(cached) $ECHO_C" >&6
8412 else
8413   cat >conftest.$ac_ext <<_ACEOF
8414 /* confdefs.h.  */
8415 _ACEOF
8416 cat confdefs.h >>conftest.$ac_ext
8417 cat >>conftest.$ac_ext <<_ACEOF
8418 /* end confdefs.h.  */
8419 $ac_includes_default
8420 int
8421 main ()
8422 {
8423 if ((int *) 0)
8424   return 0;
8425 if (sizeof (int))
8426   return 0;
8427   ;
8428   return 0;
8429 }
8430 _ACEOF
8431 rm -f conftest.$ac_objext
8432 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8433   (eval $ac_compile) 2>conftest.er1
8434   ac_status=$?
8435   grep -v '^ *+' conftest.er1 >conftest.err
8436   rm -f conftest.er1
8437   cat conftest.err >&5
8438   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8439   (exit $ac_status); } &&
8440          { ac_try='test -z "$ac_c_werror_flag"
8441                          || test ! -s conftest.err'
8442   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8443   (eval $ac_try) 2>&5
8444   ac_status=$?
8445   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8446   (exit $ac_status); }; } &&
8447          { ac_try='test -s conftest.$ac_objext'
8448   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8449   (eval $ac_try) 2>&5
8450   ac_status=$?
8451   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8452   (exit $ac_status); }; }; then
8453   ac_cv_type_int=yes
8454 else
8455   echo "$as_me: failed program was:" >&5
8456 sed 's/^/| /' conftest.$ac_ext >&5
8457
8458 ac_cv_type_int=no
8459 fi
8460 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8461 fi
8462 echo "$as_me:$LINENO: result: $ac_cv_type_int" >&5
8463 echo "${ECHO_T}$ac_cv_type_int" >&6
8464
8465 echo "$as_me:$LINENO: checking size of int" >&5
8466 echo $ECHO_N "checking size of int... $ECHO_C" >&6
8467 if test "${ac_cv_sizeof_int+set}" = set; then
8468   echo $ECHO_N "(cached) $ECHO_C" >&6
8469 else
8470   if test "$ac_cv_type_int" = yes; then
8471   # The cast to unsigned long works around a bug in the HP C Compiler
8472   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
8473   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
8474   # This bug is HP SR number 8606223364.
8475   if test "$cross_compiling" = yes; then
8476   # Depending upon the size, compute the lo and hi bounds.
8477 cat >conftest.$ac_ext <<_ACEOF
8478 /* confdefs.h.  */
8479 _ACEOF
8480 cat confdefs.h >>conftest.$ac_ext
8481 cat >>conftest.$ac_ext <<_ACEOF
8482 /* end confdefs.h.  */
8483 $ac_includes_default
8484 int
8485 main ()
8486 {
8487 static int test_array [1 - 2 * !(((long) (sizeof (int))) >= 0)];
8488 test_array [0] = 0
8489
8490   ;
8491   return 0;
8492 }
8493 _ACEOF
8494 rm -f conftest.$ac_objext
8495 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8496   (eval $ac_compile) 2>conftest.er1
8497   ac_status=$?
8498   grep -v '^ *+' conftest.er1 >conftest.err
8499   rm -f conftest.er1
8500   cat conftest.err >&5
8501   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8502   (exit $ac_status); } &&
8503          { ac_try='test -z "$ac_c_werror_flag"
8504                          || test ! -s conftest.err'
8505   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8506   (eval $ac_try) 2>&5
8507   ac_status=$?
8508   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8509   (exit $ac_status); }; } &&
8510          { ac_try='test -s conftest.$ac_objext'
8511   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8512   (eval $ac_try) 2>&5
8513   ac_status=$?
8514   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8515   (exit $ac_status); }; }; then
8516   ac_lo=0 ac_mid=0
8517   while :; do
8518     cat >conftest.$ac_ext <<_ACEOF
8519 /* confdefs.h.  */
8520 _ACEOF
8521 cat confdefs.h >>conftest.$ac_ext
8522 cat >>conftest.$ac_ext <<_ACEOF
8523 /* end confdefs.h.  */
8524 $ac_includes_default
8525 int
8526 main ()
8527 {
8528 static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)];
8529 test_array [0] = 0
8530
8531   ;
8532   return 0;
8533 }
8534 _ACEOF
8535 rm -f conftest.$ac_objext
8536 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8537   (eval $ac_compile) 2>conftest.er1
8538   ac_status=$?
8539   grep -v '^ *+' conftest.er1 >conftest.err
8540   rm -f conftest.er1
8541   cat conftest.err >&5
8542   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8543   (exit $ac_status); } &&
8544          { ac_try='test -z "$ac_c_werror_flag"
8545                          || test ! -s conftest.err'
8546   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8547   (eval $ac_try) 2>&5
8548   ac_status=$?
8549   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8550   (exit $ac_status); }; } &&
8551          { ac_try='test -s conftest.$ac_objext'
8552   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8553   (eval $ac_try) 2>&5
8554   ac_status=$?
8555   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8556   (exit $ac_status); }; }; then
8557   ac_hi=$ac_mid; break
8558 else
8559   echo "$as_me: failed program was:" >&5
8560 sed 's/^/| /' conftest.$ac_ext >&5
8561
8562 ac_lo=`expr $ac_mid + 1`
8563                     if test $ac_lo -le $ac_mid; then
8564                       ac_lo= ac_hi=
8565                       break
8566                     fi
8567                     ac_mid=`expr 2 '*' $ac_mid + 1`
8568 fi
8569 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8570   done
8571 else
8572   echo "$as_me: failed program was:" >&5
8573 sed 's/^/| /' conftest.$ac_ext >&5
8574
8575 cat >conftest.$ac_ext <<_ACEOF
8576 /* confdefs.h.  */
8577 _ACEOF
8578 cat confdefs.h >>conftest.$ac_ext
8579 cat >>conftest.$ac_ext <<_ACEOF
8580 /* end confdefs.h.  */
8581 $ac_includes_default
8582 int
8583 main ()
8584 {
8585 static int test_array [1 - 2 * !(((long) (sizeof (int))) < 0)];
8586 test_array [0] = 0
8587
8588   ;
8589   return 0;
8590 }
8591 _ACEOF
8592 rm -f conftest.$ac_objext
8593 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8594   (eval $ac_compile) 2>conftest.er1
8595   ac_status=$?
8596   grep -v '^ *+' conftest.er1 >conftest.err
8597   rm -f conftest.er1
8598   cat conftest.err >&5
8599   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8600   (exit $ac_status); } &&
8601          { ac_try='test -z "$ac_c_werror_flag"
8602                          || test ! -s conftest.err'
8603   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8604   (eval $ac_try) 2>&5
8605   ac_status=$?
8606   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8607   (exit $ac_status); }; } &&
8608          { ac_try='test -s conftest.$ac_objext'
8609   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8610   (eval $ac_try) 2>&5
8611   ac_status=$?
8612   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8613   (exit $ac_status); }; }; then
8614   ac_hi=-1 ac_mid=-1
8615   while :; do
8616     cat >conftest.$ac_ext <<_ACEOF
8617 /* confdefs.h.  */
8618 _ACEOF
8619 cat confdefs.h >>conftest.$ac_ext
8620 cat >>conftest.$ac_ext <<_ACEOF
8621 /* end confdefs.h.  */
8622 $ac_includes_default
8623 int
8624 main ()
8625 {
8626 static int test_array [1 - 2 * !(((long) (sizeof (int))) >= $ac_mid)];
8627 test_array [0] = 0
8628
8629   ;
8630   return 0;
8631 }
8632 _ACEOF
8633 rm -f conftest.$ac_objext
8634 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8635   (eval $ac_compile) 2>conftest.er1
8636   ac_status=$?
8637   grep -v '^ *+' conftest.er1 >conftest.err
8638   rm -f conftest.er1
8639   cat conftest.err >&5
8640   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8641   (exit $ac_status); } &&
8642          { ac_try='test -z "$ac_c_werror_flag"
8643                          || test ! -s conftest.err'
8644   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8645   (eval $ac_try) 2>&5
8646   ac_status=$?
8647   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8648   (exit $ac_status); }; } &&
8649          { ac_try='test -s conftest.$ac_objext'
8650   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8651   (eval $ac_try) 2>&5
8652   ac_status=$?
8653   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8654   (exit $ac_status); }; }; then
8655   ac_lo=$ac_mid; break
8656 else
8657   echo "$as_me: failed program was:" >&5
8658 sed 's/^/| /' conftest.$ac_ext >&5
8659
8660 ac_hi=`expr '(' $ac_mid ')' - 1`
8661                        if test $ac_mid -le $ac_hi; then
8662                          ac_lo= ac_hi=
8663                          break
8664                        fi
8665                        ac_mid=`expr 2 '*' $ac_mid`
8666 fi
8667 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8668   done
8669 else
8670   echo "$as_me: failed program was:" >&5
8671 sed 's/^/| /' conftest.$ac_ext >&5
8672
8673 ac_lo= ac_hi=
8674 fi
8675 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8676 fi
8677 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8678 # Binary search between lo and hi bounds.
8679 while test "x$ac_lo" != "x$ac_hi"; do
8680   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
8681   cat >conftest.$ac_ext <<_ACEOF
8682 /* confdefs.h.  */
8683 _ACEOF
8684 cat confdefs.h >>conftest.$ac_ext
8685 cat >>conftest.$ac_ext <<_ACEOF
8686 /* end confdefs.h.  */
8687 $ac_includes_default
8688 int
8689 main ()
8690 {
8691 static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)];
8692 test_array [0] = 0
8693
8694   ;
8695   return 0;
8696 }
8697 _ACEOF
8698 rm -f conftest.$ac_objext
8699 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8700   (eval $ac_compile) 2>conftest.er1
8701   ac_status=$?
8702   grep -v '^ *+' conftest.er1 >conftest.err
8703   rm -f conftest.er1
8704   cat conftest.err >&5
8705   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8706   (exit $ac_status); } &&
8707          { ac_try='test -z "$ac_c_werror_flag"
8708                          || test ! -s conftest.err'
8709   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8710   (eval $ac_try) 2>&5
8711   ac_status=$?
8712   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8713   (exit $ac_status); }; } &&
8714          { ac_try='test -s conftest.$ac_objext'
8715   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8716   (eval $ac_try) 2>&5
8717   ac_status=$?
8718   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8719   (exit $ac_status); }; }; then
8720   ac_hi=$ac_mid
8721 else
8722   echo "$as_me: failed program was:" >&5
8723 sed 's/^/| /' conftest.$ac_ext >&5
8724
8725 ac_lo=`expr '(' $ac_mid ')' + 1`
8726 fi
8727 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8728 done
8729 case $ac_lo in
8730 ?*) ac_cv_sizeof_int=$ac_lo;;
8731 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77
8732 See \`config.log' for more details." >&5
8733 echo "$as_me: error: cannot compute sizeof (int), 77
8734 See \`config.log' for more details." >&2;}
8735    { (exit 1); exit 1; }; } ;;
8736 esac
8737 else
8738   if test "$cross_compiling" = yes; then
8739   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
8740 See \`config.log' for more details." >&5
8741 echo "$as_me: error: cannot run test program while cross compiling
8742 See \`config.log' for more details." >&2;}
8743    { (exit 1); exit 1; }; }
8744 else
8745   cat >conftest.$ac_ext <<_ACEOF
8746 /* confdefs.h.  */
8747 _ACEOF
8748 cat confdefs.h >>conftest.$ac_ext
8749 cat >>conftest.$ac_ext <<_ACEOF
8750 /* end confdefs.h.  */
8751 $ac_includes_default
8752 long longval () { return (long) (sizeof (int)); }
8753 unsigned long ulongval () { return (long) (sizeof (int)); }
8754 #include <stdio.h>
8755 #include <stdlib.h>
8756 int
8757 main ()
8758 {
8759
8760   FILE *f = fopen ("conftest.val", "w");
8761   if (! f)
8762     exit (1);
8763   if (((long) (sizeof (int))) < 0)
8764     {
8765       long i = longval ();
8766       if (i != ((long) (sizeof (int))))
8767         exit (1);
8768       fprintf (f, "%ld\n", i);
8769     }
8770   else
8771     {
8772       unsigned long i = ulongval ();
8773       if (i != ((long) (sizeof (int))))
8774         exit (1);
8775       fprintf (f, "%lu\n", i);
8776     }
8777   exit (ferror (f) || fclose (f) != 0);
8778
8779   ;
8780   return 0;
8781 }
8782 _ACEOF
8783 rm -f conftest$ac_exeext
8784 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8785   (eval $ac_link) 2>&5
8786   ac_status=$?
8787   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8788   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8789   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8790   (eval $ac_try) 2>&5
8791   ac_status=$?
8792   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8793   (exit $ac_status); }; }; then
8794   ac_cv_sizeof_int=`cat conftest.val`
8795 else
8796   echo "$as_me: program exited with status $ac_status" >&5
8797 echo "$as_me: failed program was:" >&5
8798 sed 's/^/| /' conftest.$ac_ext >&5
8799
8800 ( exit $ac_status )
8801 { { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77
8802 See \`config.log' for more details." >&5
8803 echo "$as_me: error: cannot compute sizeof (int), 77
8804 See \`config.log' for more details." >&2;}
8805    { (exit 1); exit 1; }; }
8806 fi
8807 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8808 fi
8809 fi
8810 rm -f conftest.val
8811 else
8812   ac_cv_sizeof_int=0
8813 fi
8814 fi
8815 echo "$as_me:$LINENO: result: $ac_cv_sizeof_int" >&5
8816 echo "${ECHO_T}$ac_cv_sizeof_int" >&6
8817 cat >>confdefs.h <<_ACEOF
8818 #define SIZEOF_INT $ac_cv_sizeof_int
8819 _ACEOF
8820
8821
8822   echo "$as_me:$LINENO: checking for short" >&5
8823 echo $ECHO_N "checking for short... $ECHO_C" >&6
8824 if test "${ac_cv_type_short+set}" = set; then
8825   echo $ECHO_N "(cached) $ECHO_C" >&6
8826 else
8827   cat >conftest.$ac_ext <<_ACEOF
8828 /* confdefs.h.  */
8829 _ACEOF
8830 cat confdefs.h >>conftest.$ac_ext
8831 cat >>conftest.$ac_ext <<_ACEOF
8832 /* end confdefs.h.  */
8833 $ac_includes_default
8834 int
8835 main ()
8836 {
8837 if ((short *) 0)
8838   return 0;
8839 if (sizeof (short))
8840   return 0;
8841   ;
8842   return 0;
8843 }
8844 _ACEOF
8845 rm -f conftest.$ac_objext
8846 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8847   (eval $ac_compile) 2>conftest.er1
8848   ac_status=$?
8849   grep -v '^ *+' conftest.er1 >conftest.err
8850   rm -f conftest.er1
8851   cat conftest.err >&5
8852   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8853   (exit $ac_status); } &&
8854          { ac_try='test -z "$ac_c_werror_flag"
8855                          || test ! -s conftest.err'
8856   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8857   (eval $ac_try) 2>&5
8858   ac_status=$?
8859   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8860   (exit $ac_status); }; } &&
8861          { ac_try='test -s conftest.$ac_objext'
8862   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8863   (eval $ac_try) 2>&5
8864   ac_status=$?
8865   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8866   (exit $ac_status); }; }; then
8867   ac_cv_type_short=yes
8868 else
8869   echo "$as_me: failed program was:" >&5
8870 sed 's/^/| /' conftest.$ac_ext >&5
8871
8872 ac_cv_type_short=no
8873 fi
8874 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8875 fi
8876 echo "$as_me:$LINENO: result: $ac_cv_type_short" >&5
8877 echo "${ECHO_T}$ac_cv_type_short" >&6
8878
8879 echo "$as_me:$LINENO: checking size of short" >&5
8880 echo $ECHO_N "checking size of short... $ECHO_C" >&6
8881 if test "${ac_cv_sizeof_short+set}" = set; then
8882   echo $ECHO_N "(cached) $ECHO_C" >&6
8883 else
8884   if test "$ac_cv_type_short" = yes; then
8885   # The cast to unsigned long works around a bug in the HP C Compiler
8886   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
8887   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
8888   # This bug is HP SR number 8606223364.
8889   if test "$cross_compiling" = yes; then
8890   # Depending upon the size, compute the lo and hi bounds.
8891 cat >conftest.$ac_ext <<_ACEOF
8892 /* confdefs.h.  */
8893 _ACEOF
8894 cat confdefs.h >>conftest.$ac_ext
8895 cat >>conftest.$ac_ext <<_ACEOF
8896 /* end confdefs.h.  */
8897 $ac_includes_default
8898 int
8899 main ()
8900 {
8901 static int test_array [1 - 2 * !(((long) (sizeof (short))) >= 0)];
8902 test_array [0] = 0
8903
8904   ;
8905   return 0;
8906 }
8907 _ACEOF
8908 rm -f conftest.$ac_objext
8909 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8910   (eval $ac_compile) 2>conftest.er1
8911   ac_status=$?
8912   grep -v '^ *+' conftest.er1 >conftest.err
8913   rm -f conftest.er1
8914   cat conftest.err >&5
8915   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8916   (exit $ac_status); } &&
8917          { ac_try='test -z "$ac_c_werror_flag"
8918                          || test ! -s conftest.err'
8919   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8920   (eval $ac_try) 2>&5
8921   ac_status=$?
8922   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8923   (exit $ac_status); }; } &&
8924          { ac_try='test -s conftest.$ac_objext'
8925   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8926   (eval $ac_try) 2>&5
8927   ac_status=$?
8928   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8929   (exit $ac_status); }; }; then
8930   ac_lo=0 ac_mid=0
8931   while :; do
8932     cat >conftest.$ac_ext <<_ACEOF
8933 /* confdefs.h.  */
8934 _ACEOF
8935 cat confdefs.h >>conftest.$ac_ext
8936 cat >>conftest.$ac_ext <<_ACEOF
8937 /* end confdefs.h.  */
8938 $ac_includes_default
8939 int
8940 main ()
8941 {
8942 static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)];
8943 test_array [0] = 0
8944
8945   ;
8946   return 0;
8947 }
8948 _ACEOF
8949 rm -f conftest.$ac_objext
8950 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8951   (eval $ac_compile) 2>conftest.er1
8952   ac_status=$?
8953   grep -v '^ *+' conftest.er1 >conftest.err
8954   rm -f conftest.er1
8955   cat conftest.err >&5
8956   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8957   (exit $ac_status); } &&
8958          { ac_try='test -z "$ac_c_werror_flag"
8959                          || test ! -s conftest.err'
8960   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8961   (eval $ac_try) 2>&5
8962   ac_status=$?
8963   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8964   (exit $ac_status); }; } &&
8965          { ac_try='test -s conftest.$ac_objext'
8966   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8967   (eval $ac_try) 2>&5
8968   ac_status=$?
8969   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8970   (exit $ac_status); }; }; then
8971   ac_hi=$ac_mid; break
8972 else
8973   echo "$as_me: failed program was:" >&5
8974 sed 's/^/| /' conftest.$ac_ext >&5
8975
8976 ac_lo=`expr $ac_mid + 1`
8977                     if test $ac_lo -le $ac_mid; then
8978                       ac_lo= ac_hi=
8979                       break
8980                     fi
8981                     ac_mid=`expr 2 '*' $ac_mid + 1`
8982 fi
8983 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8984   done
8985 else
8986   echo "$as_me: failed program was:" >&5
8987 sed 's/^/| /' conftest.$ac_ext >&5
8988
8989 cat >conftest.$ac_ext <<_ACEOF
8990 /* confdefs.h.  */
8991 _ACEOF
8992 cat confdefs.h >>conftest.$ac_ext
8993 cat >>conftest.$ac_ext <<_ACEOF
8994 /* end confdefs.h.  */
8995 $ac_includes_default
8996 int
8997 main ()
8998 {
8999 static int test_array [1 - 2 * !(((long) (sizeof (short))) < 0)];
9000 test_array [0] = 0
9001
9002   ;
9003   return 0;
9004 }
9005 _ACEOF
9006 rm -f conftest.$ac_objext
9007 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9008   (eval $ac_compile) 2>conftest.er1
9009   ac_status=$?
9010   grep -v '^ *+' conftest.er1 >conftest.err
9011   rm -f conftest.er1
9012   cat conftest.err >&5
9013   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9014   (exit $ac_status); } &&
9015          { ac_try='test -z "$ac_c_werror_flag"
9016                          || test ! -s conftest.err'
9017   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9018   (eval $ac_try) 2>&5
9019   ac_status=$?
9020   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9021   (exit $ac_status); }; } &&
9022          { ac_try='test -s conftest.$ac_objext'
9023   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9024   (eval $ac_try) 2>&5
9025   ac_status=$?
9026   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9027   (exit $ac_status); }; }; then
9028   ac_hi=-1 ac_mid=-1
9029   while :; do
9030     cat >conftest.$ac_ext <<_ACEOF
9031 /* confdefs.h.  */
9032 _ACEOF
9033 cat confdefs.h >>conftest.$ac_ext
9034 cat >>conftest.$ac_ext <<_ACEOF
9035 /* end confdefs.h.  */
9036 $ac_includes_default
9037 int
9038 main ()
9039 {
9040 static int test_array [1 - 2 * !(((long) (sizeof (short))) >= $ac_mid)];
9041 test_array [0] = 0
9042
9043   ;
9044   return 0;
9045 }
9046 _ACEOF
9047 rm -f conftest.$ac_objext
9048 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9049   (eval $ac_compile) 2>conftest.er1
9050   ac_status=$?
9051   grep -v '^ *+' conftest.er1 >conftest.err
9052   rm -f conftest.er1
9053   cat conftest.err >&5
9054   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9055   (exit $ac_status); } &&
9056          { ac_try='test -z "$ac_c_werror_flag"
9057                          || test ! -s conftest.err'
9058   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9059   (eval $ac_try) 2>&5
9060   ac_status=$?
9061   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9062   (exit $ac_status); }; } &&
9063          { ac_try='test -s conftest.$ac_objext'
9064   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9065   (eval $ac_try) 2>&5
9066   ac_status=$?
9067   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9068   (exit $ac_status); }; }; then
9069   ac_lo=$ac_mid; break
9070 else
9071   echo "$as_me: failed program was:" >&5
9072 sed 's/^/| /' conftest.$ac_ext >&5
9073
9074 ac_hi=`expr '(' $ac_mid ')' - 1`
9075                        if test $ac_mid -le $ac_hi; then
9076                          ac_lo= ac_hi=
9077                          break
9078                        fi
9079                        ac_mid=`expr 2 '*' $ac_mid`
9080 fi
9081 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9082   done
9083 else
9084   echo "$as_me: failed program was:" >&5
9085 sed 's/^/| /' conftest.$ac_ext >&5
9086
9087 ac_lo= ac_hi=
9088 fi
9089 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9090 fi
9091 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9092 # Binary search between lo and hi bounds.
9093 while test "x$ac_lo" != "x$ac_hi"; do
9094   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
9095   cat >conftest.$ac_ext <<_ACEOF
9096 /* confdefs.h.  */
9097 _ACEOF
9098 cat confdefs.h >>conftest.$ac_ext
9099 cat >>conftest.$ac_ext <<_ACEOF
9100 /* end confdefs.h.  */
9101 $ac_includes_default
9102 int
9103 main ()
9104 {
9105 static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)];
9106 test_array [0] = 0
9107
9108   ;
9109   return 0;
9110 }
9111 _ACEOF
9112 rm -f conftest.$ac_objext
9113 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9114   (eval $ac_compile) 2>conftest.er1
9115   ac_status=$?
9116   grep -v '^ *+' conftest.er1 >conftest.err
9117   rm -f conftest.er1
9118   cat conftest.err >&5
9119   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9120   (exit $ac_status); } &&
9121          { ac_try='test -z "$ac_c_werror_flag"
9122                          || test ! -s conftest.err'
9123   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9124   (eval $ac_try) 2>&5
9125   ac_status=$?
9126   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9127   (exit $ac_status); }; } &&
9128          { ac_try='test -s conftest.$ac_objext'
9129   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9130   (eval $ac_try) 2>&5
9131   ac_status=$?
9132   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9133   (exit $ac_status); }; }; then
9134   ac_hi=$ac_mid
9135 else
9136   echo "$as_me: failed program was:" >&5
9137 sed 's/^/| /' conftest.$ac_ext >&5
9138
9139 ac_lo=`expr '(' $ac_mid ')' + 1`
9140 fi
9141 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9142 done
9143 case $ac_lo in
9144 ?*) ac_cv_sizeof_short=$ac_lo;;
9145 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77
9146 See \`config.log' for more details." >&5
9147 echo "$as_me: error: cannot compute sizeof (short), 77
9148 See \`config.log' for more details." >&2;}
9149    { (exit 1); exit 1; }; } ;;
9150 esac
9151 else
9152   if test "$cross_compiling" = yes; then
9153   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
9154 See \`config.log' for more details." >&5
9155 echo "$as_me: error: cannot run test program while cross compiling
9156 See \`config.log' for more details." >&2;}
9157    { (exit 1); exit 1; }; }
9158 else
9159   cat >conftest.$ac_ext <<_ACEOF
9160 /* confdefs.h.  */
9161 _ACEOF
9162 cat confdefs.h >>conftest.$ac_ext
9163 cat >>conftest.$ac_ext <<_ACEOF
9164 /* end confdefs.h.  */
9165 $ac_includes_default
9166 long longval () { return (long) (sizeof (short)); }
9167 unsigned long ulongval () { return (long) (sizeof (short)); }
9168 #include <stdio.h>
9169 #include <stdlib.h>
9170 int
9171 main ()
9172 {
9173
9174   FILE *f = fopen ("conftest.val", "w");
9175   if (! f)
9176     exit (1);
9177   if (((long) (sizeof (short))) < 0)
9178     {
9179       long i = longval ();
9180       if (i != ((long) (sizeof (short))))
9181         exit (1);
9182       fprintf (f, "%ld\n", i);
9183     }
9184   else
9185     {
9186       unsigned long i = ulongval ();
9187       if (i != ((long) (sizeof (short))))
9188         exit (1);
9189       fprintf (f, "%lu\n", i);
9190     }
9191   exit (ferror (f) || fclose (f) != 0);
9192
9193   ;
9194   return 0;
9195 }
9196 _ACEOF
9197 rm -f conftest$ac_exeext
9198 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9199   (eval $ac_link) 2>&5
9200   ac_status=$?
9201   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9202   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9203   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9204   (eval $ac_try) 2>&5
9205   ac_status=$?
9206   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9207   (exit $ac_status); }; }; then
9208   ac_cv_sizeof_short=`cat conftest.val`
9209 else
9210   echo "$as_me: program exited with status $ac_status" >&5
9211 echo "$as_me: failed program was:" >&5
9212 sed 's/^/| /' conftest.$ac_ext >&5
9213
9214 ( exit $ac_status )
9215 { { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77
9216 See \`config.log' for more details." >&5
9217 echo "$as_me: error: cannot compute sizeof (short), 77
9218 See \`config.log' for more details." >&2;}
9219    { (exit 1); exit 1; }; }
9220 fi
9221 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9222 fi
9223 fi
9224 rm -f conftest.val
9225 else
9226   ac_cv_sizeof_short=0
9227 fi
9228 fi
9229 echo "$as_me:$LINENO: result: $ac_cv_sizeof_short" >&5
9230 echo "${ECHO_T}$ac_cv_sizeof_short" >&6
9231 cat >>confdefs.h <<_ACEOF
9232 #define SIZEOF_SHORT $ac_cv_sizeof_short
9233 _ACEOF
9234
9235
9236   echo "$as_me:$LINENO: checking for char" >&5
9237 echo $ECHO_N "checking for char... $ECHO_C" >&6
9238 if test "${ac_cv_type_char+set}" = set; then
9239   echo $ECHO_N "(cached) $ECHO_C" >&6
9240 else
9241   cat >conftest.$ac_ext <<_ACEOF
9242 /* confdefs.h.  */
9243 _ACEOF
9244 cat confdefs.h >>conftest.$ac_ext
9245 cat >>conftest.$ac_ext <<_ACEOF
9246 /* end confdefs.h.  */
9247 $ac_includes_default
9248 int
9249 main ()
9250 {
9251 if ((char *) 0)
9252   return 0;
9253 if (sizeof (char))
9254   return 0;
9255   ;
9256   return 0;
9257 }
9258 _ACEOF
9259 rm -f conftest.$ac_objext
9260 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9261   (eval $ac_compile) 2>conftest.er1
9262   ac_status=$?
9263   grep -v '^ *+' conftest.er1 >conftest.err
9264   rm -f conftest.er1
9265   cat conftest.err >&5
9266   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9267   (exit $ac_status); } &&
9268          { ac_try='test -z "$ac_c_werror_flag"
9269                          || test ! -s conftest.err'
9270   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9271   (eval $ac_try) 2>&5
9272   ac_status=$?
9273   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9274   (exit $ac_status); }; } &&
9275          { ac_try='test -s conftest.$ac_objext'
9276   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9277   (eval $ac_try) 2>&5
9278   ac_status=$?
9279   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9280   (exit $ac_status); }; }; then
9281   ac_cv_type_char=yes
9282 else
9283   echo "$as_me: failed program was:" >&5
9284 sed 's/^/| /' conftest.$ac_ext >&5
9285
9286 ac_cv_type_char=no
9287 fi
9288 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9289 fi
9290 echo "$as_me:$LINENO: result: $ac_cv_type_char" >&5
9291 echo "${ECHO_T}$ac_cv_type_char" >&6
9292
9293 echo "$as_me:$LINENO: checking size of char" >&5
9294 echo $ECHO_N "checking size of char... $ECHO_C" >&6
9295 if test "${ac_cv_sizeof_char+set}" = set; then
9296   echo $ECHO_N "(cached) $ECHO_C" >&6
9297 else
9298   if test "$ac_cv_type_char" = yes; then
9299   # The cast to unsigned long works around a bug in the HP C Compiler
9300   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
9301   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
9302   # This bug is HP SR number 8606223364.
9303   if test "$cross_compiling" = yes; then
9304   # Depending upon the size, compute the lo and hi bounds.
9305 cat >conftest.$ac_ext <<_ACEOF
9306 /* confdefs.h.  */
9307 _ACEOF
9308 cat confdefs.h >>conftest.$ac_ext
9309 cat >>conftest.$ac_ext <<_ACEOF
9310 /* end confdefs.h.  */
9311 $ac_includes_default
9312 int
9313 main ()
9314 {
9315 static int test_array [1 - 2 * !(((long) (sizeof (char))) >= 0)];
9316 test_array [0] = 0
9317
9318   ;
9319   return 0;
9320 }
9321 _ACEOF
9322 rm -f conftest.$ac_objext
9323 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9324   (eval $ac_compile) 2>conftest.er1
9325   ac_status=$?
9326   grep -v '^ *+' conftest.er1 >conftest.err
9327   rm -f conftest.er1
9328   cat conftest.err >&5
9329   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9330   (exit $ac_status); } &&
9331          { ac_try='test -z "$ac_c_werror_flag"
9332                          || test ! -s conftest.err'
9333   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9334   (eval $ac_try) 2>&5
9335   ac_status=$?
9336   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9337   (exit $ac_status); }; } &&
9338          { ac_try='test -s conftest.$ac_objext'
9339   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9340   (eval $ac_try) 2>&5
9341   ac_status=$?
9342   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9343   (exit $ac_status); }; }; then
9344   ac_lo=0 ac_mid=0
9345   while :; do
9346     cat >conftest.$ac_ext <<_ACEOF
9347 /* confdefs.h.  */
9348 _ACEOF
9349 cat confdefs.h >>conftest.$ac_ext
9350 cat >>conftest.$ac_ext <<_ACEOF
9351 /* end confdefs.h.  */
9352 $ac_includes_default
9353 int
9354 main ()
9355 {
9356 static int test_array [1 - 2 * !(((long) (sizeof (char))) <= $ac_mid)];
9357 test_array [0] = 0
9358
9359   ;
9360   return 0;
9361 }
9362 _ACEOF
9363 rm -f conftest.$ac_objext
9364 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9365   (eval $ac_compile) 2>conftest.er1
9366   ac_status=$?
9367   grep -v '^ *+' conftest.er1 >conftest.err
9368   rm -f conftest.er1
9369   cat conftest.err >&5
9370   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9371   (exit $ac_status); } &&
9372          { ac_try='test -z "$ac_c_werror_flag"
9373                          || test ! -s conftest.err'
9374   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9375   (eval $ac_try) 2>&5
9376   ac_status=$?
9377   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9378   (exit $ac_status); }; } &&
9379          { ac_try='test -s conftest.$ac_objext'
9380   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9381   (eval $ac_try) 2>&5
9382   ac_status=$?
9383   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9384   (exit $ac_status); }; }; then
9385   ac_hi=$ac_mid; break
9386 else
9387   echo "$as_me: failed program was:" >&5
9388 sed 's/^/| /' conftest.$ac_ext >&5
9389
9390 ac_lo=`expr $ac_mid + 1`
9391                     if test $ac_lo -le $ac_mid; then
9392                       ac_lo= ac_hi=
9393                       break
9394                     fi
9395                     ac_mid=`expr 2 '*' $ac_mid + 1`
9396 fi
9397 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9398   done
9399 else
9400   echo "$as_me: failed program was:" >&5
9401 sed 's/^/| /' conftest.$ac_ext >&5
9402
9403 cat >conftest.$ac_ext <<_ACEOF
9404 /* confdefs.h.  */
9405 _ACEOF
9406 cat confdefs.h >>conftest.$ac_ext
9407 cat >>conftest.$ac_ext <<_ACEOF
9408 /* end confdefs.h.  */
9409 $ac_includes_default
9410 int
9411 main ()
9412 {
9413 static int test_array [1 - 2 * !(((long) (sizeof (char))) < 0)];
9414 test_array [0] = 0
9415
9416   ;
9417   return 0;
9418 }
9419 _ACEOF
9420 rm -f conftest.$ac_objext
9421 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9422   (eval $ac_compile) 2>conftest.er1
9423   ac_status=$?
9424   grep -v '^ *+' conftest.er1 >conftest.err
9425   rm -f conftest.er1
9426   cat conftest.err >&5
9427   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9428   (exit $ac_status); } &&
9429          { ac_try='test -z "$ac_c_werror_flag"
9430                          || test ! -s conftest.err'
9431   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9432   (eval $ac_try) 2>&5
9433   ac_status=$?
9434   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9435   (exit $ac_status); }; } &&
9436          { ac_try='test -s conftest.$ac_objext'
9437   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9438   (eval $ac_try) 2>&5
9439   ac_status=$?
9440   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9441   (exit $ac_status); }; }; then
9442   ac_hi=-1 ac_mid=-1
9443   while :; do
9444     cat >conftest.$ac_ext <<_ACEOF
9445 /* confdefs.h.  */
9446 _ACEOF
9447 cat confdefs.h >>conftest.$ac_ext
9448 cat >>conftest.$ac_ext <<_ACEOF
9449 /* end confdefs.h.  */
9450 $ac_includes_default
9451 int
9452 main ()
9453 {
9454 static int test_array [1 - 2 * !(((long) (sizeof (char))) >= $ac_mid)];
9455 test_array [0] = 0
9456
9457   ;
9458   return 0;
9459 }
9460 _ACEOF
9461 rm -f conftest.$ac_objext
9462 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9463   (eval $ac_compile) 2>conftest.er1
9464   ac_status=$?
9465   grep -v '^ *+' conftest.er1 >conftest.err
9466   rm -f conftest.er1
9467   cat conftest.err >&5
9468   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9469   (exit $ac_status); } &&
9470          { ac_try='test -z "$ac_c_werror_flag"
9471                          || test ! -s conftest.err'
9472   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9473   (eval $ac_try) 2>&5
9474   ac_status=$?
9475   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9476   (exit $ac_status); }; } &&
9477          { ac_try='test -s conftest.$ac_objext'
9478   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9479   (eval $ac_try) 2>&5
9480   ac_status=$?
9481   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9482   (exit $ac_status); }; }; then
9483   ac_lo=$ac_mid; break
9484 else
9485   echo "$as_me: failed program was:" >&5
9486 sed 's/^/| /' conftest.$ac_ext >&5
9487
9488 ac_hi=`expr '(' $ac_mid ')' - 1`
9489                        if test $ac_mid -le $ac_hi; then
9490                          ac_lo= ac_hi=
9491                          break
9492                        fi
9493                        ac_mid=`expr 2 '*' $ac_mid`
9494 fi
9495 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9496   done
9497 else
9498   echo "$as_me: failed program was:" >&5
9499 sed 's/^/| /' conftest.$ac_ext >&5
9500
9501 ac_lo= ac_hi=
9502 fi
9503 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9504 fi
9505 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9506 # Binary search between lo and hi bounds.
9507 while test "x$ac_lo" != "x$ac_hi"; do
9508   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
9509   cat >conftest.$ac_ext <<_ACEOF
9510 /* confdefs.h.  */
9511 _ACEOF
9512 cat confdefs.h >>conftest.$ac_ext
9513 cat >>conftest.$ac_ext <<_ACEOF
9514 /* end confdefs.h.  */
9515 $ac_includes_default
9516 int
9517 main ()
9518 {
9519 static int test_array [1 - 2 * !(((long) (sizeof (char))) <= $ac_mid)];
9520 test_array [0] = 0
9521
9522   ;
9523   return 0;
9524 }
9525 _ACEOF
9526 rm -f conftest.$ac_objext
9527 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9528   (eval $ac_compile) 2>conftest.er1
9529   ac_status=$?
9530   grep -v '^ *+' conftest.er1 >conftest.err
9531   rm -f conftest.er1
9532   cat conftest.err >&5
9533   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9534   (exit $ac_status); } &&
9535          { ac_try='test -z "$ac_c_werror_flag"
9536                          || test ! -s conftest.err'
9537   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9538   (eval $ac_try) 2>&5
9539   ac_status=$?
9540   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9541   (exit $ac_status); }; } &&
9542          { ac_try='test -s conftest.$ac_objext'
9543   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9544   (eval $ac_try) 2>&5
9545   ac_status=$?
9546   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9547   (exit $ac_status); }; }; then
9548   ac_hi=$ac_mid
9549 else
9550   echo "$as_me: failed program was:" >&5
9551 sed 's/^/| /' conftest.$ac_ext >&5
9552
9553 ac_lo=`expr '(' $ac_mid ')' + 1`
9554 fi
9555 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9556 done
9557 case $ac_lo in
9558 ?*) ac_cv_sizeof_char=$ac_lo;;
9559 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (char), 77
9560 See \`config.log' for more details." >&5
9561 echo "$as_me: error: cannot compute sizeof (char), 77
9562 See \`config.log' for more details." >&2;}
9563    { (exit 1); exit 1; }; } ;;
9564 esac
9565 else
9566   if test "$cross_compiling" = yes; then
9567   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
9568 See \`config.log' for more details." >&5
9569 echo "$as_me: error: cannot run test program while cross compiling
9570 See \`config.log' for more details." >&2;}
9571    { (exit 1); exit 1; }; }
9572 else
9573   cat >conftest.$ac_ext <<_ACEOF
9574 /* confdefs.h.  */
9575 _ACEOF
9576 cat confdefs.h >>conftest.$ac_ext
9577 cat >>conftest.$ac_ext <<_ACEOF
9578 /* end confdefs.h.  */
9579 $ac_includes_default
9580 long longval () { return (long) (sizeof (char)); }
9581 unsigned long ulongval () { return (long) (sizeof (char)); }
9582 #include <stdio.h>
9583 #include <stdlib.h>
9584 int
9585 main ()
9586 {
9587
9588   FILE *f = fopen ("conftest.val", "w");
9589   if (! f)
9590     exit (1);
9591   if (((long) (sizeof (char))) < 0)
9592     {
9593       long i = longval ();
9594       if (i != ((long) (sizeof (char))))
9595         exit (1);
9596       fprintf (f, "%ld\n", i);
9597     }
9598   else
9599     {
9600       unsigned long i = ulongval ();
9601       if (i != ((long) (sizeof (char))))
9602         exit (1);
9603       fprintf (f, "%lu\n", i);
9604     }
9605   exit (ferror (f) || fclose (f) != 0);
9606
9607   ;
9608   return 0;
9609 }
9610 _ACEOF
9611 rm -f conftest$ac_exeext
9612 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9613   (eval $ac_link) 2>&5
9614   ac_status=$?
9615   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9616   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9617   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9618   (eval $ac_try) 2>&5
9619   ac_status=$?
9620   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9621   (exit $ac_status); }; }; then
9622   ac_cv_sizeof_char=`cat conftest.val`
9623 else
9624   echo "$as_me: program exited with status $ac_status" >&5
9625 echo "$as_me: failed program was:" >&5
9626 sed 's/^/| /' conftest.$ac_ext >&5
9627
9628 ( exit $ac_status )
9629 { { echo "$as_me:$LINENO: error: cannot compute sizeof (char), 77
9630 See \`config.log' for more details." >&5
9631 echo "$as_me: error: cannot compute sizeof (char), 77
9632 See \`config.log' for more details." >&2;}
9633    { (exit 1); exit 1; }; }
9634 fi
9635 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9636 fi
9637 fi
9638 rm -f conftest.val
9639 else
9640   ac_cv_sizeof_char=0
9641 fi
9642 fi
9643 echo "$as_me:$LINENO: result: $ac_cv_sizeof_char" >&5
9644 echo "${ECHO_T}$ac_cv_sizeof_char" >&6
9645 cat >>confdefs.h <<_ACEOF
9646 #define SIZEOF_CHAR $ac_cv_sizeof_char
9647 _ACEOF
9648
9649
9650
9651   echo "$as_me:$LINENO: checking for type equivalent to int8_t" >&5
9652 echo $ECHO_N "checking for type equivalent to int8_t... $ECHO_C" >&6
9653   case "$ac_cv_sizeof_char" in
9654     1) acx_cv_type_int8_t=char ;;
9655     *) { { echo "$as_me:$LINENO: error: no 8-bit type" >&5
9656 echo "$as_me: error: no 8-bit type" >&2;}
9657    { (exit please report a bug); exit please report a bug; }; }
9658   esac
9659   echo "$as_me:$LINENO: result: $acx_cv_type_int8_t" >&5
9660 echo "${ECHO_T}$acx_cv_type_int8_t" >&6
9661
9662   echo "$as_me:$LINENO: checking for type equivalent to int16_t" >&5
9663 echo $ECHO_N "checking for type equivalent to int16_t... $ECHO_C" >&6
9664   case "$ac_cv_sizeof_int:$ac_cv_sizeof_short" in
9665     2:*) acx_cv_type_int16_t=int ;;
9666     *:2) acx_cv_type_int16_t=short ;;
9667     *) { { echo "$as_me:$LINENO: error: no 16-bit type" >&5
9668 echo "$as_me: error: no 16-bit type" >&2;}
9669    { (exit please report a bug); exit please report a bug; }; }
9670   esac
9671   echo "$as_me:$LINENO: result: $acx_cv_type_int16_t" >&5
9672 echo "${ECHO_T}$acx_cv_type_int16_t" >&6
9673
9674   echo "$as_me:$LINENO: checking for type equivalent to int32_t" >&5
9675 echo $ECHO_N "checking for type equivalent to int32_t... $ECHO_C" >&6
9676   case "$ac_cv_sizeof_int:$ac_cv_sizeof_long" in
9677     4:*) acx_cv_type_int32_t=int ;;
9678     *:4) acx_cv_type_int32_t=long ;;
9679     *) { { echo "$as_me:$LINENO: error: no 32-bit type" >&5
9680 echo "$as_me: error: no 32-bit type" >&2;}
9681    { (exit please report a bug); exit please report a bug; }; }
9682   esac
9683   echo "$as_me:$LINENO: result: $acx_cv_type_int32_t" >&5
9684 echo "${ECHO_T}$acx_cv_type_int32_t" >&6
9685 fi
9686
9687 # These tests are here to make the output prettier
9688
9689 if test "$ac_cv_type_uint64_t" != yes && test "$ac_cv_type_u_int64_t" != yes; then
9690   case "$ac_cv_sizeof_long" in
9691     8) acx_cv_type_int64_t=long ;;
9692   esac
9693   echo "$as_me:$LINENO: checking for type equivalent to int64_t" >&5
9694 echo $ECHO_N "checking for type equivalent to int64_t... $ECHO_C" >&6
9695   echo "$as_me:$LINENO: result: ${acx_cv_type_int64_t-'using preprocessor symbols'}" >&5
9696 echo "${ECHO_T}${acx_cv_type_int64_t-'using preprocessor symbols'}" >&6
9697 fi
9698
9699 # Now we can use the above types
9700
9701 if test "$ac_cv_type_uintptr_t" != yes; then
9702   echo "$as_me:$LINENO: checking for type equivalent to intptr_t" >&5
9703 echo $ECHO_N "checking for type equivalent to intptr_t... $ECHO_C" >&6
9704   case $ac_cv_sizeof_void_p in
9705     2) acx_cv_type_intptr_t=int16_t ;;
9706     4) acx_cv_type_intptr_t=int32_t ;;
9707     8) acx_cv_type_intptr_t=int64_t ;;
9708     *) { { echo "$as_me:$LINENO: error: no equivalent for intptr_t" >&5
9709 echo "$as_me: error: no equivalent for intptr_t" >&2;}
9710    { (exit please report a bug); exit please report a bug; }; }
9711   esac
9712   echo "$as_me:$LINENO: result: $acx_cv_type_intptr_t" >&5
9713 echo "${ECHO_T}$acx_cv_type_intptr_t" >&6
9714 fi
9715
9716 # ----------------- done all checks, emit header -------------
9717           ac_config_commands="$ac_config_commands gstdint.h"
9718
9719
9720
9721
9722 echo "$as_me:$LINENO: checking for struct stat.st_blksize" >&5
9723 echo $ECHO_N "checking for struct stat.st_blksize... $ECHO_C" >&6
9724 if test "${ac_cv_member_struct_stat_st_blksize+set}" = set; then
9725   echo $ECHO_N "(cached) $ECHO_C" >&6
9726 else
9727   cat >conftest.$ac_ext <<_ACEOF
9728 /* confdefs.h.  */
9729 _ACEOF
9730 cat confdefs.h >>conftest.$ac_ext
9731 cat >>conftest.$ac_ext <<_ACEOF
9732 /* end confdefs.h.  */
9733 $ac_includes_default
9734 int
9735 main ()
9736 {
9737 static struct stat ac_aggr;
9738 if (ac_aggr.st_blksize)
9739 return 0;
9740   ;
9741   return 0;
9742 }
9743 _ACEOF
9744 rm -f conftest.$ac_objext
9745 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9746   (eval $ac_compile) 2>conftest.er1
9747   ac_status=$?
9748   grep -v '^ *+' conftest.er1 >conftest.err
9749   rm -f conftest.er1
9750   cat conftest.err >&5
9751   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9752   (exit $ac_status); } &&
9753          { ac_try='test -z "$ac_c_werror_flag"
9754                          || test ! -s conftest.err'
9755   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9756   (eval $ac_try) 2>&5
9757   ac_status=$?
9758   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9759   (exit $ac_status); }; } &&
9760          { ac_try='test -s conftest.$ac_objext'
9761   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9762   (eval $ac_try) 2>&5
9763   ac_status=$?
9764   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9765   (exit $ac_status); }; }; then
9766   ac_cv_member_struct_stat_st_blksize=yes
9767 else
9768   echo "$as_me: failed program was:" >&5
9769 sed 's/^/| /' conftest.$ac_ext >&5
9770
9771 cat >conftest.$ac_ext <<_ACEOF
9772 /* confdefs.h.  */
9773 _ACEOF
9774 cat confdefs.h >>conftest.$ac_ext
9775 cat >>conftest.$ac_ext <<_ACEOF
9776 /* end confdefs.h.  */
9777 $ac_includes_default
9778 int
9779 main ()
9780 {
9781 static struct stat ac_aggr;
9782 if (sizeof ac_aggr.st_blksize)
9783 return 0;
9784   ;
9785   return 0;
9786 }
9787 _ACEOF
9788 rm -f conftest.$ac_objext
9789 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9790   (eval $ac_compile) 2>conftest.er1
9791   ac_status=$?
9792   grep -v '^ *+' conftest.er1 >conftest.err
9793   rm -f conftest.er1
9794   cat conftest.err >&5
9795   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9796   (exit $ac_status); } &&
9797          { ac_try='test -z "$ac_c_werror_flag"
9798                          || test ! -s conftest.err'
9799   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9800   (eval $ac_try) 2>&5
9801   ac_status=$?
9802   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9803   (exit $ac_status); }; } &&
9804          { ac_try='test -s conftest.$ac_objext'
9805   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9806   (eval $ac_try) 2>&5
9807   ac_status=$?
9808   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9809   (exit $ac_status); }; }; then
9810   ac_cv_member_struct_stat_st_blksize=yes
9811 else
9812   echo "$as_me: failed program was:" >&5
9813 sed 's/^/| /' conftest.$ac_ext >&5
9814
9815 ac_cv_member_struct_stat_st_blksize=no
9816 fi
9817 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9818 fi
9819 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9820 fi
9821 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blksize" >&5
9822 echo "${ECHO_T}$ac_cv_member_struct_stat_st_blksize" >&6
9823 if test $ac_cv_member_struct_stat_st_blksize = yes; then
9824
9825 cat >>confdefs.h <<_ACEOF
9826 #define HAVE_STRUCT_STAT_ST_BLKSIZE 1
9827 _ACEOF
9828
9829
9830 fi
9831
9832 echo "$as_me:$LINENO: checking for struct stat.st_blocks" >&5
9833 echo $ECHO_N "checking for struct stat.st_blocks... $ECHO_C" >&6
9834 if test "${ac_cv_member_struct_stat_st_blocks+set}" = set; then
9835   echo $ECHO_N "(cached) $ECHO_C" >&6
9836 else
9837   cat >conftest.$ac_ext <<_ACEOF
9838 /* confdefs.h.  */
9839 _ACEOF
9840 cat confdefs.h >>conftest.$ac_ext
9841 cat >>conftest.$ac_ext <<_ACEOF
9842 /* end confdefs.h.  */
9843 $ac_includes_default
9844 int
9845 main ()
9846 {
9847 static struct stat ac_aggr;
9848 if (ac_aggr.st_blocks)
9849 return 0;
9850   ;
9851   return 0;
9852 }
9853 _ACEOF
9854 rm -f conftest.$ac_objext
9855 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9856   (eval $ac_compile) 2>conftest.er1
9857   ac_status=$?
9858   grep -v '^ *+' conftest.er1 >conftest.err
9859   rm -f conftest.er1
9860   cat conftest.err >&5
9861   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9862   (exit $ac_status); } &&
9863          { ac_try='test -z "$ac_c_werror_flag"
9864                          || test ! -s conftest.err'
9865   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9866   (eval $ac_try) 2>&5
9867   ac_status=$?
9868   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9869   (exit $ac_status); }; } &&
9870          { ac_try='test -s conftest.$ac_objext'
9871   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9872   (eval $ac_try) 2>&5
9873   ac_status=$?
9874   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9875   (exit $ac_status); }; }; then
9876   ac_cv_member_struct_stat_st_blocks=yes
9877 else
9878   echo "$as_me: failed program was:" >&5
9879 sed 's/^/| /' conftest.$ac_ext >&5
9880
9881 cat >conftest.$ac_ext <<_ACEOF
9882 /* confdefs.h.  */
9883 _ACEOF
9884 cat confdefs.h >>conftest.$ac_ext
9885 cat >>conftest.$ac_ext <<_ACEOF
9886 /* end confdefs.h.  */
9887 $ac_includes_default
9888 int
9889 main ()
9890 {
9891 static struct stat ac_aggr;
9892 if (sizeof ac_aggr.st_blocks)
9893 return 0;
9894   ;
9895   return 0;
9896 }
9897 _ACEOF
9898 rm -f conftest.$ac_objext
9899 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9900   (eval $ac_compile) 2>conftest.er1
9901   ac_status=$?
9902   grep -v '^ *+' conftest.er1 >conftest.err
9903   rm -f conftest.er1
9904   cat conftest.err >&5
9905   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9906   (exit $ac_status); } &&
9907          { ac_try='test -z "$ac_c_werror_flag"
9908                          || test ! -s conftest.err'
9909   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9910   (eval $ac_try) 2>&5
9911   ac_status=$?
9912   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9913   (exit $ac_status); }; } &&
9914          { ac_try='test -s conftest.$ac_objext'
9915   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9916   (eval $ac_try) 2>&5
9917   ac_status=$?
9918   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9919   (exit $ac_status); }; }; then
9920   ac_cv_member_struct_stat_st_blocks=yes
9921 else
9922   echo "$as_me: failed program was:" >&5
9923 sed 's/^/| /' conftest.$ac_ext >&5
9924
9925 ac_cv_member_struct_stat_st_blocks=no
9926 fi
9927 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9928 fi
9929 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9930 fi
9931 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blocks" >&5
9932 echo "${ECHO_T}$ac_cv_member_struct_stat_st_blocks" >&6
9933 if test $ac_cv_member_struct_stat_st_blocks = yes; then
9934
9935 cat >>confdefs.h <<_ACEOF
9936 #define HAVE_STRUCT_STAT_ST_BLOCKS 1
9937 _ACEOF
9938
9939
9940 fi
9941
9942 echo "$as_me:$LINENO: checking for struct stat.st_rdev" >&5
9943 echo $ECHO_N "checking for struct stat.st_rdev... $ECHO_C" >&6
9944 if test "${ac_cv_member_struct_stat_st_rdev+set}" = set; then
9945   echo $ECHO_N "(cached) $ECHO_C" >&6
9946 else
9947   cat >conftest.$ac_ext <<_ACEOF
9948 /* confdefs.h.  */
9949 _ACEOF
9950 cat confdefs.h >>conftest.$ac_ext
9951 cat >>conftest.$ac_ext <<_ACEOF
9952 /* end confdefs.h.  */
9953 $ac_includes_default
9954 int
9955 main ()
9956 {
9957 static struct stat ac_aggr;
9958 if (ac_aggr.st_rdev)
9959 return 0;
9960   ;
9961   return 0;
9962 }
9963 _ACEOF
9964 rm -f conftest.$ac_objext
9965 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9966   (eval $ac_compile) 2>conftest.er1
9967   ac_status=$?
9968   grep -v '^ *+' conftest.er1 >conftest.err
9969   rm -f conftest.er1
9970   cat conftest.err >&5
9971   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9972   (exit $ac_status); } &&
9973          { ac_try='test -z "$ac_c_werror_flag"
9974                          || test ! -s conftest.err'
9975   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9976   (eval $ac_try) 2>&5
9977   ac_status=$?
9978   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9979   (exit $ac_status); }; } &&
9980          { ac_try='test -s conftest.$ac_objext'
9981   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9982   (eval $ac_try) 2>&5
9983   ac_status=$?
9984   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9985   (exit $ac_status); }; }; then
9986   ac_cv_member_struct_stat_st_rdev=yes
9987 else
9988   echo "$as_me: failed program was:" >&5
9989 sed 's/^/| /' conftest.$ac_ext >&5
9990
9991 cat >conftest.$ac_ext <<_ACEOF
9992 /* confdefs.h.  */
9993 _ACEOF
9994 cat confdefs.h >>conftest.$ac_ext
9995 cat >>conftest.$ac_ext <<_ACEOF
9996 /* end confdefs.h.  */
9997 $ac_includes_default
9998 int
9999 main ()
10000 {
10001 static struct stat ac_aggr;
10002 if (sizeof ac_aggr.st_rdev)
10003 return 0;
10004   ;
10005   return 0;
10006 }
10007 _ACEOF
10008 rm -f conftest.$ac_objext
10009 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10010   (eval $ac_compile) 2>conftest.er1
10011   ac_status=$?
10012   grep -v '^ *+' conftest.er1 >conftest.err
10013   rm -f conftest.er1
10014   cat conftest.err >&5
10015   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10016   (exit $ac_status); } &&
10017          { ac_try='test -z "$ac_c_werror_flag"
10018                          || test ! -s conftest.err'
10019   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10020   (eval $ac_try) 2>&5
10021   ac_status=$?
10022   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10023   (exit $ac_status); }; } &&
10024          { ac_try='test -s conftest.$ac_objext'
10025   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10026   (eval $ac_try) 2>&5
10027   ac_status=$?
10028   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10029   (exit $ac_status); }; }; then
10030   ac_cv_member_struct_stat_st_rdev=yes
10031 else
10032   echo "$as_me: failed program was:" >&5
10033 sed 's/^/| /' conftest.$ac_ext >&5
10034
10035 ac_cv_member_struct_stat_st_rdev=no
10036 fi
10037 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10038 fi
10039 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10040 fi
10041 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_rdev" >&5
10042 echo "${ECHO_T}$ac_cv_member_struct_stat_st_rdev" >&6
10043 if test $ac_cv_member_struct_stat_st_rdev = yes; then
10044
10045 cat >>confdefs.h <<_ACEOF
10046 #define HAVE_STRUCT_STAT_ST_RDEV 1
10047 _ACEOF
10048
10049
10050 fi
10051
10052
10053 # Check for library functions.
10054
10055
10056
10057
10058
10059
10060
10061
10062 for ac_func in getrusage times mkstemp strtof strtold snprintf ftruncate chsize
10063 do
10064 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10065 echo "$as_me:$LINENO: checking for $ac_func" >&5
10066 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10067 if eval "test \"\${$as_ac_var+set}\" = set"; then
10068   echo $ECHO_N "(cached) $ECHO_C" >&6
10069 else
10070   if test x$gcc_no_link = xyes; then
10071   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10072 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10073    { (exit 1); exit 1; }; }
10074 fi
10075 cat >conftest.$ac_ext <<_ACEOF
10076 /* confdefs.h.  */
10077 _ACEOF
10078 cat confdefs.h >>conftest.$ac_ext
10079 cat >>conftest.$ac_ext <<_ACEOF
10080 /* end confdefs.h.  */
10081 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10082    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10083 #define $ac_func innocuous_$ac_func
10084
10085 /* System header to define __stub macros and hopefully few prototypes,
10086     which can conflict with char $ac_func (); below.
10087     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10088     <limits.h> exists even on freestanding compilers.  */
10089
10090 #ifdef __STDC__
10091 # include <limits.h>
10092 #else
10093 # include <assert.h>
10094 #endif
10095
10096 #undef $ac_func
10097
10098 /* Override any gcc2 internal prototype to avoid an error.  */
10099 #ifdef __cplusplus
10100 extern "C"
10101 {
10102 #endif
10103 /* We use char because int might match the return type of a gcc2
10104    builtin and then its argument prototype would still apply.  */
10105 char $ac_func ();
10106 /* The GNU C library defines this for functions which it implements
10107     to always fail with ENOSYS.  Some functions are actually named
10108     something starting with __ and the normal name is an alias.  */
10109 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10110 choke me
10111 #else
10112 char (*f) () = $ac_func;
10113 #endif
10114 #ifdef __cplusplus
10115 }
10116 #endif
10117
10118 int
10119 main ()
10120 {
10121 return f != $ac_func;
10122   ;
10123   return 0;
10124 }
10125 _ACEOF
10126 rm -f conftest.$ac_objext conftest$ac_exeext
10127 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10128   (eval $ac_link) 2>conftest.er1
10129   ac_status=$?
10130   grep -v '^ *+' conftest.er1 >conftest.err
10131   rm -f conftest.er1
10132   cat conftest.err >&5
10133   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10134   (exit $ac_status); } &&
10135          { ac_try='test -z "$ac_c_werror_flag"
10136                          || test ! -s conftest.err'
10137   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10138   (eval $ac_try) 2>&5
10139   ac_status=$?
10140   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10141   (exit $ac_status); }; } &&
10142          { ac_try='test -s conftest$ac_exeext'
10143   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10144   (eval $ac_try) 2>&5
10145   ac_status=$?
10146   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10147   (exit $ac_status); }; }; then
10148   eval "$as_ac_var=yes"
10149 else
10150   echo "$as_me: failed program was:" >&5
10151 sed 's/^/| /' conftest.$ac_ext >&5
10152
10153 eval "$as_ac_var=no"
10154 fi
10155 rm -f conftest.err conftest.$ac_objext \
10156       conftest$ac_exeext conftest.$ac_ext
10157 fi
10158 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10159 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10160 if test `eval echo '${'$as_ac_var'}'` = yes; then
10161   cat >>confdefs.h <<_ACEOF
10162 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10163 _ACEOF
10164
10165 fi
10166 done
10167
10168
10169
10170
10171
10172
10173
10174
10175
10176 for ac_func in chdir strerror getlogin gethostname kill link symlink perror
10177 do
10178 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10179 echo "$as_me:$LINENO: checking for $ac_func" >&5
10180 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10181 if eval "test \"\${$as_ac_var+set}\" = set"; then
10182   echo $ECHO_N "(cached) $ECHO_C" >&6
10183 else
10184   if test x$gcc_no_link = xyes; then
10185   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10186 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10187    { (exit 1); exit 1; }; }
10188 fi
10189 cat >conftest.$ac_ext <<_ACEOF
10190 /* confdefs.h.  */
10191 _ACEOF
10192 cat confdefs.h >>conftest.$ac_ext
10193 cat >>conftest.$ac_ext <<_ACEOF
10194 /* end confdefs.h.  */
10195 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10196    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10197 #define $ac_func innocuous_$ac_func
10198
10199 /* System header to define __stub macros and hopefully few prototypes,
10200     which can conflict with char $ac_func (); below.
10201     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10202     <limits.h> exists even on freestanding compilers.  */
10203
10204 #ifdef __STDC__
10205 # include <limits.h>
10206 #else
10207 # include <assert.h>
10208 #endif
10209
10210 #undef $ac_func
10211
10212 /* Override any gcc2 internal prototype to avoid an error.  */
10213 #ifdef __cplusplus
10214 extern "C"
10215 {
10216 #endif
10217 /* We use char because int might match the return type of a gcc2
10218    builtin and then its argument prototype would still apply.  */
10219 char $ac_func ();
10220 /* The GNU C library defines this for functions which it implements
10221     to always fail with ENOSYS.  Some functions are actually named
10222     something starting with __ and the normal name is an alias.  */
10223 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10224 choke me
10225 #else
10226 char (*f) () = $ac_func;
10227 #endif
10228 #ifdef __cplusplus
10229 }
10230 #endif
10231
10232 int
10233 main ()
10234 {
10235 return f != $ac_func;
10236   ;
10237   return 0;
10238 }
10239 _ACEOF
10240 rm -f conftest.$ac_objext conftest$ac_exeext
10241 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10242   (eval $ac_link) 2>conftest.er1
10243   ac_status=$?
10244   grep -v '^ *+' conftest.er1 >conftest.err
10245   rm -f conftest.er1
10246   cat conftest.err >&5
10247   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10248   (exit $ac_status); } &&
10249          { ac_try='test -z "$ac_c_werror_flag"
10250                          || test ! -s conftest.err'
10251   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10252   (eval $ac_try) 2>&5
10253   ac_status=$?
10254   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10255   (exit $ac_status); }; } &&
10256          { ac_try='test -s conftest$ac_exeext'
10257   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10258   (eval $ac_try) 2>&5
10259   ac_status=$?
10260   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10261   (exit $ac_status); }; }; then
10262   eval "$as_ac_var=yes"
10263 else
10264   echo "$as_me: failed program was:" >&5
10265 sed 's/^/| /' conftest.$ac_ext >&5
10266
10267 eval "$as_ac_var=no"
10268 fi
10269 rm -f conftest.err conftest.$ac_objext \
10270       conftest$ac_exeext conftest.$ac_ext
10271 fi
10272 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10273 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10274 if test `eval echo '${'$as_ac_var'}'` = yes; then
10275   cat >>confdefs.h <<_ACEOF
10276 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10277 _ACEOF
10278
10279 fi
10280 done
10281
10282
10283
10284
10285
10286
10287
10288
10289
10290
10291
10292 for ac_func in sleep time ttyname signal alarm ctime clock access fork execl
10293 do
10294 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10295 echo "$as_me:$LINENO: checking for $ac_func" >&5
10296 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10297 if eval "test \"\${$as_ac_var+set}\" = set"; then
10298   echo $ECHO_N "(cached) $ECHO_C" >&6
10299 else
10300   if test x$gcc_no_link = xyes; then
10301   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10302 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10303    { (exit 1); exit 1; }; }
10304 fi
10305 cat >conftest.$ac_ext <<_ACEOF
10306 /* confdefs.h.  */
10307 _ACEOF
10308 cat confdefs.h >>conftest.$ac_ext
10309 cat >>conftest.$ac_ext <<_ACEOF
10310 /* end confdefs.h.  */
10311 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10312    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10313 #define $ac_func innocuous_$ac_func
10314
10315 /* System header to define __stub macros and hopefully few prototypes,
10316     which can conflict with char $ac_func (); below.
10317     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10318     <limits.h> exists even on freestanding compilers.  */
10319
10320 #ifdef __STDC__
10321 # include <limits.h>
10322 #else
10323 # include <assert.h>
10324 #endif
10325
10326 #undef $ac_func
10327
10328 /* Override any gcc2 internal prototype to avoid an error.  */
10329 #ifdef __cplusplus
10330 extern "C"
10331 {
10332 #endif
10333 /* We use char because int might match the return type of a gcc2
10334    builtin and then its argument prototype would still apply.  */
10335 char $ac_func ();
10336 /* The GNU C library defines this for functions which it implements
10337     to always fail with ENOSYS.  Some functions are actually named
10338     something starting with __ and the normal name is an alias.  */
10339 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10340 choke me
10341 #else
10342 char (*f) () = $ac_func;
10343 #endif
10344 #ifdef __cplusplus
10345 }
10346 #endif
10347
10348 int
10349 main ()
10350 {
10351 return f != $ac_func;
10352   ;
10353   return 0;
10354 }
10355 _ACEOF
10356 rm -f conftest.$ac_objext conftest$ac_exeext
10357 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10358   (eval $ac_link) 2>conftest.er1
10359   ac_status=$?
10360   grep -v '^ *+' conftest.er1 >conftest.err
10361   rm -f conftest.er1
10362   cat conftest.err >&5
10363   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10364   (exit $ac_status); } &&
10365          { ac_try='test -z "$ac_c_werror_flag"
10366                          || test ! -s conftest.err'
10367   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10368   (eval $ac_try) 2>&5
10369   ac_status=$?
10370   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10371   (exit $ac_status); }; } &&
10372          { ac_try='test -s conftest$ac_exeext'
10373   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10374   (eval $ac_try) 2>&5
10375   ac_status=$?
10376   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10377   (exit $ac_status); }; }; then
10378   eval "$as_ac_var=yes"
10379 else
10380   echo "$as_me: failed program was:" >&5
10381 sed 's/^/| /' conftest.$ac_ext >&5
10382
10383 eval "$as_ac_var=no"
10384 fi
10385 rm -f conftest.err conftest.$ac_objext \
10386       conftest$ac_exeext conftest.$ac_ext
10387 fi
10388 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10389 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10390 if test `eval echo '${'$as_ac_var'}'` = yes; then
10391   cat >>confdefs.h <<_ACEOF
10392 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10393 _ACEOF
10394
10395 fi
10396 done
10397
10398
10399
10400
10401
10402
10403
10404
10405
10406
10407 for ac_func in wait setmode execvp pipe dup2 close fdopen strcasestr getrlimit
10408 do
10409 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10410 echo "$as_me:$LINENO: checking for $ac_func" >&5
10411 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10412 if eval "test \"\${$as_ac_var+set}\" = set"; then
10413   echo $ECHO_N "(cached) $ECHO_C" >&6
10414 else
10415   if test x$gcc_no_link = xyes; then
10416   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10417 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10418    { (exit 1); exit 1; }; }
10419 fi
10420 cat >conftest.$ac_ext <<_ACEOF
10421 /* confdefs.h.  */
10422 _ACEOF
10423 cat confdefs.h >>conftest.$ac_ext
10424 cat >>conftest.$ac_ext <<_ACEOF
10425 /* end confdefs.h.  */
10426 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10427    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10428 #define $ac_func innocuous_$ac_func
10429
10430 /* System header to define __stub macros and hopefully few prototypes,
10431     which can conflict with char $ac_func (); below.
10432     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10433     <limits.h> exists even on freestanding compilers.  */
10434
10435 #ifdef __STDC__
10436 # include <limits.h>
10437 #else
10438 # include <assert.h>
10439 #endif
10440
10441 #undef $ac_func
10442
10443 /* Override any gcc2 internal prototype to avoid an error.  */
10444 #ifdef __cplusplus
10445 extern "C"
10446 {
10447 #endif
10448 /* We use char because int might match the return type of a gcc2
10449    builtin and then its argument prototype would still apply.  */
10450 char $ac_func ();
10451 /* The GNU C library defines this for functions which it implements
10452     to always fail with ENOSYS.  Some functions are actually named
10453     something starting with __ and the normal name is an alias.  */
10454 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10455 choke me
10456 #else
10457 char (*f) () = $ac_func;
10458 #endif
10459 #ifdef __cplusplus
10460 }
10461 #endif
10462
10463 int
10464 main ()
10465 {
10466 return f != $ac_func;
10467   ;
10468   return 0;
10469 }
10470 _ACEOF
10471 rm -f conftest.$ac_objext conftest$ac_exeext
10472 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10473   (eval $ac_link) 2>conftest.er1
10474   ac_status=$?
10475   grep -v '^ *+' conftest.er1 >conftest.err
10476   rm -f conftest.er1
10477   cat conftest.err >&5
10478   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10479   (exit $ac_status); } &&
10480          { ac_try='test -z "$ac_c_werror_flag"
10481                          || test ! -s conftest.err'
10482   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10483   (eval $ac_try) 2>&5
10484   ac_status=$?
10485   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10486   (exit $ac_status); }; } &&
10487          { ac_try='test -s conftest$ac_exeext'
10488   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10489   (eval $ac_try) 2>&5
10490   ac_status=$?
10491   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10492   (exit $ac_status); }; }; then
10493   eval "$as_ac_var=yes"
10494 else
10495   echo "$as_me: failed program was:" >&5
10496 sed 's/^/| /' conftest.$ac_ext >&5
10497
10498 eval "$as_ac_var=no"
10499 fi
10500 rm -f conftest.err conftest.$ac_objext \
10501       conftest$ac_exeext conftest.$ac_ext
10502 fi
10503 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10504 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10505 if test `eval echo '${'$as_ac_var'}'` = yes; then
10506   cat >>confdefs.h <<_ACEOF
10507 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10508 _ACEOF
10509
10510 fi
10511 done
10512
10513
10514
10515
10516
10517 for ac_func in gettimeofday stat fstat lstat
10518 do
10519 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10520 echo "$as_me:$LINENO: checking for $ac_func" >&5
10521 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10522 if eval "test \"\${$as_ac_var+set}\" = set"; then
10523   echo $ECHO_N "(cached) $ECHO_C" >&6
10524 else
10525   if test x$gcc_no_link = xyes; then
10526   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10527 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10528    { (exit 1); exit 1; }; }
10529 fi
10530 cat >conftest.$ac_ext <<_ACEOF
10531 /* confdefs.h.  */
10532 _ACEOF
10533 cat confdefs.h >>conftest.$ac_ext
10534 cat >>conftest.$ac_ext <<_ACEOF
10535 /* end confdefs.h.  */
10536 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10537    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10538 #define $ac_func innocuous_$ac_func
10539
10540 /* System header to define __stub macros and hopefully few prototypes,
10541     which can conflict with char $ac_func (); below.
10542     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10543     <limits.h> exists even on freestanding compilers.  */
10544
10545 #ifdef __STDC__
10546 # include <limits.h>
10547 #else
10548 # include <assert.h>
10549 #endif
10550
10551 #undef $ac_func
10552
10553 /* Override any gcc2 internal prototype to avoid an error.  */
10554 #ifdef __cplusplus
10555 extern "C"
10556 {
10557 #endif
10558 /* We use char because int might match the return type of a gcc2
10559    builtin and then its argument prototype would still apply.  */
10560 char $ac_func ();
10561 /* The GNU C library defines this for functions which it implements
10562     to always fail with ENOSYS.  Some functions are actually named
10563     something starting with __ and the normal name is an alias.  */
10564 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10565 choke me
10566 #else
10567 char (*f) () = $ac_func;
10568 #endif
10569 #ifdef __cplusplus
10570 }
10571 #endif
10572
10573 int
10574 main ()
10575 {
10576 return f != $ac_func;
10577   ;
10578   return 0;
10579 }
10580 _ACEOF
10581 rm -f conftest.$ac_objext conftest$ac_exeext
10582 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10583   (eval $ac_link) 2>conftest.er1
10584   ac_status=$?
10585   grep -v '^ *+' conftest.er1 >conftest.err
10586   rm -f conftest.er1
10587   cat conftest.err >&5
10588   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10589   (exit $ac_status); } &&
10590          { ac_try='test -z "$ac_c_werror_flag"
10591                          || test ! -s conftest.err'
10592   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10593   (eval $ac_try) 2>&5
10594   ac_status=$?
10595   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10596   (exit $ac_status); }; } &&
10597          { ac_try='test -s conftest$ac_exeext'
10598   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10599   (eval $ac_try) 2>&5
10600   ac_status=$?
10601   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10602   (exit $ac_status); }; }; then
10603   eval "$as_ac_var=yes"
10604 else
10605   echo "$as_me: failed program was:" >&5
10606 sed 's/^/| /' conftest.$ac_ext >&5
10607
10608 eval "$as_ac_var=no"
10609 fi
10610 rm -f conftest.err conftest.$ac_objext \
10611       conftest$ac_exeext conftest.$ac_ext
10612 fi
10613 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10614 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10615 if test `eval echo '${'$as_ac_var'}'` = yes; then
10616   cat >>confdefs.h <<_ACEOF
10617 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10618 _ACEOF
10619
10620 fi
10621 done
10622
10623
10624 # Check for glibc backtrace functions
10625
10626
10627 for ac_func in backtrace backtrace_symbols
10628 do
10629 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10630 echo "$as_me:$LINENO: checking for $ac_func" >&5
10631 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10632 if eval "test \"\${$as_ac_var+set}\" = set"; then
10633   echo $ECHO_N "(cached) $ECHO_C" >&6
10634 else
10635   if test x$gcc_no_link = xyes; then
10636   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10637 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10638    { (exit 1); exit 1; }; }
10639 fi
10640 cat >conftest.$ac_ext <<_ACEOF
10641 /* confdefs.h.  */
10642 _ACEOF
10643 cat confdefs.h >>conftest.$ac_ext
10644 cat >>conftest.$ac_ext <<_ACEOF
10645 /* end confdefs.h.  */
10646 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10647    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10648 #define $ac_func innocuous_$ac_func
10649
10650 /* System header to define __stub macros and hopefully few prototypes,
10651     which can conflict with char $ac_func (); below.
10652     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10653     <limits.h> exists even on freestanding compilers.  */
10654
10655 #ifdef __STDC__
10656 # include <limits.h>
10657 #else
10658 # include <assert.h>
10659 #endif
10660
10661 #undef $ac_func
10662
10663 /* Override any gcc2 internal prototype to avoid an error.  */
10664 #ifdef __cplusplus
10665 extern "C"
10666 {
10667 #endif
10668 /* We use char because int might match the return type of a gcc2
10669    builtin and then its argument prototype would still apply.  */
10670 char $ac_func ();
10671 /* The GNU C library defines this for functions which it implements
10672     to always fail with ENOSYS.  Some functions are actually named
10673     something starting with __ and the normal name is an alias.  */
10674 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10675 choke me
10676 #else
10677 char (*f) () = $ac_func;
10678 #endif
10679 #ifdef __cplusplus
10680 }
10681 #endif
10682
10683 int
10684 main ()
10685 {
10686 return f != $ac_func;
10687   ;
10688   return 0;
10689 }
10690 _ACEOF
10691 rm -f conftest.$ac_objext conftest$ac_exeext
10692 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10693   (eval $ac_link) 2>conftest.er1
10694   ac_status=$?
10695   grep -v '^ *+' conftest.er1 >conftest.err
10696   rm -f conftest.er1
10697   cat conftest.err >&5
10698   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10699   (exit $ac_status); } &&
10700          { ac_try='test -z "$ac_c_werror_flag"
10701                          || test ! -s conftest.err'
10702   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10703   (eval $ac_try) 2>&5
10704   ac_status=$?
10705   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10706   (exit $ac_status); }; } &&
10707          { ac_try='test -s conftest$ac_exeext'
10708   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10709   (eval $ac_try) 2>&5
10710   ac_status=$?
10711   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10712   (exit $ac_status); }; }; then
10713   eval "$as_ac_var=yes"
10714 else
10715   echo "$as_me: failed program was:" >&5
10716 sed 's/^/| /' conftest.$ac_ext >&5
10717
10718 eval "$as_ac_var=no"
10719 fi
10720 rm -f conftest.err conftest.$ac_objext \
10721       conftest$ac_exeext conftest.$ac_ext
10722 fi
10723 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10724 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10725 if test `eval echo '${'$as_ac_var'}'` = yes; then
10726   cat >>confdefs.h <<_ACEOF
10727 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10728 _ACEOF
10729
10730 fi
10731 done
10732
10733
10734 # Check for types
10735 echo "$as_me:$LINENO: checking for intptr_t" >&5
10736 echo $ECHO_N "checking for intptr_t... $ECHO_C" >&6
10737 if test "${ac_cv_type_intptr_t+set}" = set; then
10738   echo $ECHO_N "(cached) $ECHO_C" >&6
10739 else
10740   cat >conftest.$ac_ext <<_ACEOF
10741 /* confdefs.h.  */
10742 _ACEOF
10743 cat confdefs.h >>conftest.$ac_ext
10744 cat >>conftest.$ac_ext <<_ACEOF
10745 /* end confdefs.h.  */
10746 $ac_includes_default
10747 int
10748 main ()
10749 {
10750 if ((intptr_t *) 0)
10751   return 0;
10752 if (sizeof (intptr_t))
10753   return 0;
10754   ;
10755   return 0;
10756 }
10757 _ACEOF
10758 rm -f conftest.$ac_objext
10759 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10760   (eval $ac_compile) 2>conftest.er1
10761   ac_status=$?
10762   grep -v '^ *+' conftest.er1 >conftest.err
10763   rm -f conftest.er1
10764   cat conftest.err >&5
10765   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10766   (exit $ac_status); } &&
10767          { ac_try='test -z "$ac_c_werror_flag"
10768                          || test ! -s conftest.err'
10769   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10770   (eval $ac_try) 2>&5
10771   ac_status=$?
10772   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10773   (exit $ac_status); }; } &&
10774          { ac_try='test -s conftest.$ac_objext'
10775   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10776   (eval $ac_try) 2>&5
10777   ac_status=$?
10778   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10779   (exit $ac_status); }; }; then
10780   ac_cv_type_intptr_t=yes
10781 else
10782   echo "$as_me: failed program was:" >&5
10783 sed 's/^/| /' conftest.$ac_ext >&5
10784
10785 ac_cv_type_intptr_t=no
10786 fi
10787 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10788 fi
10789 echo "$as_me:$LINENO: result: $ac_cv_type_intptr_t" >&5
10790 echo "${ECHO_T}$ac_cv_type_intptr_t" >&6
10791 if test $ac_cv_type_intptr_t = yes; then
10792
10793 cat >>confdefs.h <<_ACEOF
10794 #define HAVE_INTPTR_T 1
10795 _ACEOF
10796
10797
10798 fi
10799
10800
10801 # Check libc for getgid, getpid, getuid
10802 echo "$as_me:$LINENO: checking for getgid in -lc" >&5
10803 echo $ECHO_N "checking for getgid in -lc... $ECHO_C" >&6
10804 if test "${ac_cv_lib_c_getgid+set}" = set; then
10805   echo $ECHO_N "(cached) $ECHO_C" >&6
10806 else
10807   ac_check_lib_save_LIBS=$LIBS
10808 LIBS="-lc  $LIBS"
10809 if test x$gcc_no_link = xyes; then
10810   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10811 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10812    { (exit 1); exit 1; }; }
10813 fi
10814 cat >conftest.$ac_ext <<_ACEOF
10815 /* confdefs.h.  */
10816 _ACEOF
10817 cat confdefs.h >>conftest.$ac_ext
10818 cat >>conftest.$ac_ext <<_ACEOF
10819 /* end confdefs.h.  */
10820
10821 /* Override any gcc2 internal prototype to avoid an error.  */
10822 #ifdef __cplusplus
10823 extern "C"
10824 #endif
10825 /* We use char because int might match the return type of a gcc2
10826    builtin and then its argument prototype would still apply.  */
10827 char getgid ();
10828 int
10829 main ()
10830 {
10831 getgid ();
10832   ;
10833   return 0;
10834 }
10835 _ACEOF
10836 rm -f conftest.$ac_objext conftest$ac_exeext
10837 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10838   (eval $ac_link) 2>conftest.er1
10839   ac_status=$?
10840   grep -v '^ *+' conftest.er1 >conftest.err
10841   rm -f conftest.er1
10842   cat conftest.err >&5
10843   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10844   (exit $ac_status); } &&
10845          { ac_try='test -z "$ac_c_werror_flag"
10846                          || test ! -s conftest.err'
10847   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10848   (eval $ac_try) 2>&5
10849   ac_status=$?
10850   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10851   (exit $ac_status); }; } &&
10852          { ac_try='test -s conftest$ac_exeext'
10853   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10854   (eval $ac_try) 2>&5
10855   ac_status=$?
10856   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10857   (exit $ac_status); }; }; then
10858   ac_cv_lib_c_getgid=yes
10859 else
10860   echo "$as_me: failed program was:" >&5
10861 sed 's/^/| /' conftest.$ac_ext >&5
10862
10863 ac_cv_lib_c_getgid=no
10864 fi
10865 rm -f conftest.err conftest.$ac_objext \
10866       conftest$ac_exeext conftest.$ac_ext
10867 LIBS=$ac_check_lib_save_LIBS
10868 fi
10869 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getgid" >&5
10870 echo "${ECHO_T}$ac_cv_lib_c_getgid" >&6
10871 if test $ac_cv_lib_c_getgid = yes; then
10872
10873 cat >>confdefs.h <<\_ACEOF
10874 #define HAVE_GETGID 1
10875 _ACEOF
10876
10877 fi
10878
10879 echo "$as_me:$LINENO: checking for getpid in -lc" >&5
10880 echo $ECHO_N "checking for getpid in -lc... $ECHO_C" >&6
10881 if test "${ac_cv_lib_c_getpid+set}" = set; then
10882   echo $ECHO_N "(cached) $ECHO_C" >&6
10883 else
10884   ac_check_lib_save_LIBS=$LIBS
10885 LIBS="-lc  $LIBS"
10886 if test x$gcc_no_link = xyes; then
10887   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10888 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10889    { (exit 1); exit 1; }; }
10890 fi
10891 cat >conftest.$ac_ext <<_ACEOF
10892 /* confdefs.h.  */
10893 _ACEOF
10894 cat confdefs.h >>conftest.$ac_ext
10895 cat >>conftest.$ac_ext <<_ACEOF
10896 /* end confdefs.h.  */
10897
10898 /* Override any gcc2 internal prototype to avoid an error.  */
10899 #ifdef __cplusplus
10900 extern "C"
10901 #endif
10902 /* We use char because int might match the return type of a gcc2
10903    builtin and then its argument prototype would still apply.  */
10904 char getpid ();
10905 int
10906 main ()
10907 {
10908 getpid ();
10909   ;
10910   return 0;
10911 }
10912 _ACEOF
10913 rm -f conftest.$ac_objext conftest$ac_exeext
10914 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10915   (eval $ac_link) 2>conftest.er1
10916   ac_status=$?
10917   grep -v '^ *+' conftest.er1 >conftest.err
10918   rm -f conftest.er1
10919   cat conftest.err >&5
10920   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10921   (exit $ac_status); } &&
10922          { ac_try='test -z "$ac_c_werror_flag"
10923                          || test ! -s conftest.err'
10924   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10925   (eval $ac_try) 2>&5
10926   ac_status=$?
10927   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10928   (exit $ac_status); }; } &&
10929          { ac_try='test -s conftest$ac_exeext'
10930   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10931   (eval $ac_try) 2>&5
10932   ac_status=$?
10933   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10934   (exit $ac_status); }; }; then
10935   ac_cv_lib_c_getpid=yes
10936 else
10937   echo "$as_me: failed program was:" >&5
10938 sed 's/^/| /' conftest.$ac_ext >&5
10939
10940 ac_cv_lib_c_getpid=no
10941 fi
10942 rm -f conftest.err conftest.$ac_objext \
10943       conftest$ac_exeext conftest.$ac_ext
10944 LIBS=$ac_check_lib_save_LIBS
10945 fi
10946 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getpid" >&5
10947 echo "${ECHO_T}$ac_cv_lib_c_getpid" >&6
10948 if test $ac_cv_lib_c_getpid = yes; then
10949
10950 cat >>confdefs.h <<\_ACEOF
10951 #define HAVE_GETPID 1
10952 _ACEOF
10953
10954 fi
10955
10956 echo "$as_me:$LINENO: checking for getppid in -lc" >&5
10957 echo $ECHO_N "checking for getppid in -lc... $ECHO_C" >&6
10958 if test "${ac_cv_lib_c_getppid+set}" = set; then
10959   echo $ECHO_N "(cached) $ECHO_C" >&6
10960 else
10961   ac_check_lib_save_LIBS=$LIBS
10962 LIBS="-lc  $LIBS"
10963 if test x$gcc_no_link = xyes; then
10964   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10965 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10966    { (exit 1); exit 1; }; }
10967 fi
10968 cat >conftest.$ac_ext <<_ACEOF
10969 /* confdefs.h.  */
10970 _ACEOF
10971 cat confdefs.h >>conftest.$ac_ext
10972 cat >>conftest.$ac_ext <<_ACEOF
10973 /* end confdefs.h.  */
10974
10975 /* Override any gcc2 internal prototype to avoid an error.  */
10976 #ifdef __cplusplus
10977 extern "C"
10978 #endif
10979 /* We use char because int might match the return type of a gcc2
10980    builtin and then its argument prototype would still apply.  */
10981 char getppid ();
10982 int
10983 main ()
10984 {
10985 getppid ();
10986   ;
10987   return 0;
10988 }
10989 _ACEOF
10990 rm -f conftest.$ac_objext conftest$ac_exeext
10991 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10992   (eval $ac_link) 2>conftest.er1
10993   ac_status=$?
10994   grep -v '^ *+' conftest.er1 >conftest.err
10995   rm -f conftest.er1
10996   cat conftest.err >&5
10997   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10998   (exit $ac_status); } &&
10999          { ac_try='test -z "$ac_c_werror_flag"
11000                          || test ! -s conftest.err'
11001   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11002   (eval $ac_try) 2>&5
11003   ac_status=$?
11004   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11005   (exit $ac_status); }; } &&
11006          { ac_try='test -s conftest$ac_exeext'
11007   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11008   (eval $ac_try) 2>&5
11009   ac_status=$?
11010   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11011   (exit $ac_status); }; }; then
11012   ac_cv_lib_c_getppid=yes
11013 else
11014   echo "$as_me: failed program was:" >&5
11015 sed 's/^/| /' conftest.$ac_ext >&5
11016
11017 ac_cv_lib_c_getppid=no
11018 fi
11019 rm -f conftest.err conftest.$ac_objext \
11020       conftest$ac_exeext conftest.$ac_ext
11021 LIBS=$ac_check_lib_save_LIBS
11022 fi
11023 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getppid" >&5
11024 echo "${ECHO_T}$ac_cv_lib_c_getppid" >&6
11025 if test $ac_cv_lib_c_getppid = yes; then
11026
11027 cat >>confdefs.h <<\_ACEOF
11028 #define HAVE_GETPPID 1
11029 _ACEOF
11030
11031 fi
11032
11033 echo "$as_me:$LINENO: checking for getuid in -lc" >&5
11034 echo $ECHO_N "checking for getuid in -lc... $ECHO_C" >&6
11035 if test "${ac_cv_lib_c_getuid+set}" = set; then
11036   echo $ECHO_N "(cached) $ECHO_C" >&6
11037 else
11038   ac_check_lib_save_LIBS=$LIBS
11039 LIBS="-lc  $LIBS"
11040 if test x$gcc_no_link = xyes; then
11041   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11042 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11043    { (exit 1); exit 1; }; }
11044 fi
11045 cat >conftest.$ac_ext <<_ACEOF
11046 /* confdefs.h.  */
11047 _ACEOF
11048 cat confdefs.h >>conftest.$ac_ext
11049 cat >>conftest.$ac_ext <<_ACEOF
11050 /* end confdefs.h.  */
11051
11052 /* Override any gcc2 internal prototype to avoid an error.  */
11053 #ifdef __cplusplus
11054 extern "C"
11055 #endif
11056 /* We use char because int might match the return type of a gcc2
11057    builtin and then its argument prototype would still apply.  */
11058 char getuid ();
11059 int
11060 main ()
11061 {
11062 getuid ();
11063   ;
11064   return 0;
11065 }
11066 _ACEOF
11067 rm -f conftest.$ac_objext conftest$ac_exeext
11068 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11069   (eval $ac_link) 2>conftest.er1
11070   ac_status=$?
11071   grep -v '^ *+' conftest.er1 >conftest.err
11072   rm -f conftest.er1
11073   cat conftest.err >&5
11074   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11075   (exit $ac_status); } &&
11076          { ac_try='test -z "$ac_c_werror_flag"
11077                          || test ! -s conftest.err'
11078   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11079   (eval $ac_try) 2>&5
11080   ac_status=$?
11081   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11082   (exit $ac_status); }; } &&
11083          { ac_try='test -s conftest$ac_exeext'
11084   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11085   (eval $ac_try) 2>&5
11086   ac_status=$?
11087   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11088   (exit $ac_status); }; }; then
11089   ac_cv_lib_c_getuid=yes
11090 else
11091   echo "$as_me: failed program was:" >&5
11092 sed 's/^/| /' conftest.$ac_ext >&5
11093
11094 ac_cv_lib_c_getuid=no
11095 fi
11096 rm -f conftest.err conftest.$ac_objext \
11097       conftest$ac_exeext conftest.$ac_ext
11098 LIBS=$ac_check_lib_save_LIBS
11099 fi
11100 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getuid" >&5
11101 echo "${ECHO_T}$ac_cv_lib_c_getuid" >&6
11102 if test $ac_cv_lib_c_getuid = yes; then
11103
11104 cat >>confdefs.h <<\_ACEOF
11105 #define HAVE_GETUID 1
11106 _ACEOF
11107
11108 fi
11109
11110
11111 # Check for C99 (and other IEEE) math functions
11112 # ??? This list seems awful long. Is there a better way to test for these?
11113 echo "$as_me:$LINENO: checking for acosf in -lm" >&5
11114 echo $ECHO_N "checking for acosf in -lm... $ECHO_C" >&6
11115 if test "${ac_cv_lib_m_acosf+set}" = set; then
11116   echo $ECHO_N "(cached) $ECHO_C" >&6
11117 else
11118   ac_check_lib_save_LIBS=$LIBS
11119 LIBS="-lm  $LIBS"
11120 if test x$gcc_no_link = xyes; then
11121   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11122 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11123    { (exit 1); exit 1; }; }
11124 fi
11125 cat >conftest.$ac_ext <<_ACEOF
11126 /* confdefs.h.  */
11127 _ACEOF
11128 cat confdefs.h >>conftest.$ac_ext
11129 cat >>conftest.$ac_ext <<_ACEOF
11130 /* end confdefs.h.  */
11131
11132 /* Override any gcc2 internal prototype to avoid an error.  */
11133 #ifdef __cplusplus
11134 extern "C"
11135 #endif
11136 /* We use char because int might match the return type of a gcc2
11137    builtin and then its argument prototype would still apply.  */
11138 char acosf ();
11139 int
11140 main ()
11141 {
11142 acosf ();
11143   ;
11144   return 0;
11145 }
11146 _ACEOF
11147 rm -f conftest.$ac_objext conftest$ac_exeext
11148 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11149   (eval $ac_link) 2>conftest.er1
11150   ac_status=$?
11151   grep -v '^ *+' conftest.er1 >conftest.err
11152   rm -f conftest.er1
11153   cat conftest.err >&5
11154   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11155   (exit $ac_status); } &&
11156          { ac_try='test -z "$ac_c_werror_flag"
11157                          || test ! -s conftest.err'
11158   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11159   (eval $ac_try) 2>&5
11160   ac_status=$?
11161   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11162   (exit $ac_status); }; } &&
11163          { ac_try='test -s conftest$ac_exeext'
11164   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11165   (eval $ac_try) 2>&5
11166   ac_status=$?
11167   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11168   (exit $ac_status); }; }; then
11169   ac_cv_lib_m_acosf=yes
11170 else
11171   echo "$as_me: failed program was:" >&5
11172 sed 's/^/| /' conftest.$ac_ext >&5
11173
11174 ac_cv_lib_m_acosf=no
11175 fi
11176 rm -f conftest.err conftest.$ac_objext \
11177       conftest$ac_exeext conftest.$ac_ext
11178 LIBS=$ac_check_lib_save_LIBS
11179 fi
11180 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosf" >&5
11181 echo "${ECHO_T}$ac_cv_lib_m_acosf" >&6
11182 if test $ac_cv_lib_m_acosf = yes; then
11183
11184 cat >>confdefs.h <<\_ACEOF
11185 #define HAVE_ACOSF 1
11186 _ACEOF
11187
11188 fi
11189
11190 echo "$as_me:$LINENO: checking for acos in -lm" >&5
11191 echo $ECHO_N "checking for acos in -lm... $ECHO_C" >&6
11192 if test "${ac_cv_lib_m_acos+set}" = set; then
11193   echo $ECHO_N "(cached) $ECHO_C" >&6
11194 else
11195   ac_check_lib_save_LIBS=$LIBS
11196 LIBS="-lm  $LIBS"
11197 if test x$gcc_no_link = xyes; then
11198   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11199 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11200    { (exit 1); exit 1; }; }
11201 fi
11202 cat >conftest.$ac_ext <<_ACEOF
11203 /* confdefs.h.  */
11204 _ACEOF
11205 cat confdefs.h >>conftest.$ac_ext
11206 cat >>conftest.$ac_ext <<_ACEOF
11207 /* end confdefs.h.  */
11208
11209 /* Override any gcc2 internal prototype to avoid an error.  */
11210 #ifdef __cplusplus
11211 extern "C"
11212 #endif
11213 /* We use char because int might match the return type of a gcc2
11214    builtin and then its argument prototype would still apply.  */
11215 char acos ();
11216 int
11217 main ()
11218 {
11219 acos ();
11220   ;
11221   return 0;
11222 }
11223 _ACEOF
11224 rm -f conftest.$ac_objext conftest$ac_exeext
11225 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11226   (eval $ac_link) 2>conftest.er1
11227   ac_status=$?
11228   grep -v '^ *+' conftest.er1 >conftest.err
11229   rm -f conftest.er1
11230   cat conftest.err >&5
11231   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11232   (exit $ac_status); } &&
11233          { ac_try='test -z "$ac_c_werror_flag"
11234                          || test ! -s conftest.err'
11235   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11236   (eval $ac_try) 2>&5
11237   ac_status=$?
11238   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11239   (exit $ac_status); }; } &&
11240          { ac_try='test -s conftest$ac_exeext'
11241   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11242   (eval $ac_try) 2>&5
11243   ac_status=$?
11244   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11245   (exit $ac_status); }; }; then
11246   ac_cv_lib_m_acos=yes
11247 else
11248   echo "$as_me: failed program was:" >&5
11249 sed 's/^/| /' conftest.$ac_ext >&5
11250
11251 ac_cv_lib_m_acos=no
11252 fi
11253 rm -f conftest.err conftest.$ac_objext \
11254       conftest$ac_exeext conftest.$ac_ext
11255 LIBS=$ac_check_lib_save_LIBS
11256 fi
11257 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acos" >&5
11258 echo "${ECHO_T}$ac_cv_lib_m_acos" >&6
11259 if test $ac_cv_lib_m_acos = yes; then
11260
11261 cat >>confdefs.h <<\_ACEOF
11262 #define HAVE_ACOS 1
11263 _ACEOF
11264
11265 fi
11266
11267 echo "$as_me:$LINENO: checking for acosl in -lm" >&5
11268 echo $ECHO_N "checking for acosl in -lm... $ECHO_C" >&6
11269 if test "${ac_cv_lib_m_acosl+set}" = set; then
11270   echo $ECHO_N "(cached) $ECHO_C" >&6
11271 else
11272   ac_check_lib_save_LIBS=$LIBS
11273 LIBS="-lm  $LIBS"
11274 if test x$gcc_no_link = xyes; then
11275   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11276 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11277    { (exit 1); exit 1; }; }
11278 fi
11279 cat >conftest.$ac_ext <<_ACEOF
11280 /* confdefs.h.  */
11281 _ACEOF
11282 cat confdefs.h >>conftest.$ac_ext
11283 cat >>conftest.$ac_ext <<_ACEOF
11284 /* end confdefs.h.  */
11285
11286 /* Override any gcc2 internal prototype to avoid an error.  */
11287 #ifdef __cplusplus
11288 extern "C"
11289 #endif
11290 /* We use char because int might match the return type of a gcc2
11291    builtin and then its argument prototype would still apply.  */
11292 char acosl ();
11293 int
11294 main ()
11295 {
11296 acosl ();
11297   ;
11298   return 0;
11299 }
11300 _ACEOF
11301 rm -f conftest.$ac_objext conftest$ac_exeext
11302 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11303   (eval $ac_link) 2>conftest.er1
11304   ac_status=$?
11305   grep -v '^ *+' conftest.er1 >conftest.err
11306   rm -f conftest.er1
11307   cat conftest.err >&5
11308   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11309   (exit $ac_status); } &&
11310          { ac_try='test -z "$ac_c_werror_flag"
11311                          || test ! -s conftest.err'
11312   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11313   (eval $ac_try) 2>&5
11314   ac_status=$?
11315   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11316   (exit $ac_status); }; } &&
11317          { ac_try='test -s conftest$ac_exeext'
11318   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11319   (eval $ac_try) 2>&5
11320   ac_status=$?
11321   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11322   (exit $ac_status); }; }; then
11323   ac_cv_lib_m_acosl=yes
11324 else
11325   echo "$as_me: failed program was:" >&5
11326 sed 's/^/| /' conftest.$ac_ext >&5
11327
11328 ac_cv_lib_m_acosl=no
11329 fi
11330 rm -f conftest.err conftest.$ac_objext \
11331       conftest$ac_exeext conftest.$ac_ext
11332 LIBS=$ac_check_lib_save_LIBS
11333 fi
11334 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosl" >&5
11335 echo "${ECHO_T}$ac_cv_lib_m_acosl" >&6
11336 if test $ac_cv_lib_m_acosl = yes; then
11337
11338 cat >>confdefs.h <<\_ACEOF
11339 #define HAVE_ACOSL 1
11340 _ACEOF
11341
11342 fi
11343
11344 echo "$as_me:$LINENO: checking for acoshf in -lm" >&5
11345 echo $ECHO_N "checking for acoshf in -lm... $ECHO_C" >&6
11346 if test "${ac_cv_lib_m_acoshf+set}" = set; then
11347   echo $ECHO_N "(cached) $ECHO_C" >&6
11348 else
11349   ac_check_lib_save_LIBS=$LIBS
11350 LIBS="-lm  $LIBS"
11351 if test x$gcc_no_link = xyes; then
11352   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11353 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11354    { (exit 1); exit 1; }; }
11355 fi
11356 cat >conftest.$ac_ext <<_ACEOF
11357 /* confdefs.h.  */
11358 _ACEOF
11359 cat confdefs.h >>conftest.$ac_ext
11360 cat >>conftest.$ac_ext <<_ACEOF
11361 /* end confdefs.h.  */
11362
11363 /* Override any gcc2 internal prototype to avoid an error.  */
11364 #ifdef __cplusplus
11365 extern "C"
11366 #endif
11367 /* We use char because int might match the return type of a gcc2
11368    builtin and then its argument prototype would still apply.  */
11369 char acoshf ();
11370 int
11371 main ()
11372 {
11373 acoshf ();
11374   ;
11375   return 0;
11376 }
11377 _ACEOF
11378 rm -f conftest.$ac_objext conftest$ac_exeext
11379 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11380   (eval $ac_link) 2>conftest.er1
11381   ac_status=$?
11382   grep -v '^ *+' conftest.er1 >conftest.err
11383   rm -f conftest.er1
11384   cat conftest.err >&5
11385   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11386   (exit $ac_status); } &&
11387          { ac_try='test -z "$ac_c_werror_flag"
11388                          || test ! -s conftest.err'
11389   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11390   (eval $ac_try) 2>&5
11391   ac_status=$?
11392   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11393   (exit $ac_status); }; } &&
11394          { ac_try='test -s conftest$ac_exeext'
11395   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11396   (eval $ac_try) 2>&5
11397   ac_status=$?
11398   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11399   (exit $ac_status); }; }; then
11400   ac_cv_lib_m_acoshf=yes
11401 else
11402   echo "$as_me: failed program was:" >&5
11403 sed 's/^/| /' conftest.$ac_ext >&5
11404
11405 ac_cv_lib_m_acoshf=no
11406 fi
11407 rm -f conftest.err conftest.$ac_objext \
11408       conftest$ac_exeext conftest.$ac_ext
11409 LIBS=$ac_check_lib_save_LIBS
11410 fi
11411 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acoshf" >&5
11412 echo "${ECHO_T}$ac_cv_lib_m_acoshf" >&6
11413 if test $ac_cv_lib_m_acoshf = yes; then
11414
11415 cat >>confdefs.h <<\_ACEOF
11416 #define HAVE_ACOSHF 1
11417 _ACEOF
11418
11419 fi
11420
11421 echo "$as_me:$LINENO: checking for acosh in -lm" >&5
11422 echo $ECHO_N "checking for acosh in -lm... $ECHO_C" >&6
11423 if test "${ac_cv_lib_m_acosh+set}" = set; then
11424   echo $ECHO_N "(cached) $ECHO_C" >&6
11425 else
11426   ac_check_lib_save_LIBS=$LIBS
11427 LIBS="-lm  $LIBS"
11428 if test x$gcc_no_link = xyes; then
11429   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11430 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11431    { (exit 1); exit 1; }; }
11432 fi
11433 cat >conftest.$ac_ext <<_ACEOF
11434 /* confdefs.h.  */
11435 _ACEOF
11436 cat confdefs.h >>conftest.$ac_ext
11437 cat >>conftest.$ac_ext <<_ACEOF
11438 /* end confdefs.h.  */
11439
11440 /* Override any gcc2 internal prototype to avoid an error.  */
11441 #ifdef __cplusplus
11442 extern "C"
11443 #endif
11444 /* We use char because int might match the return type of a gcc2
11445    builtin and then its argument prototype would still apply.  */
11446 char acosh ();
11447 int
11448 main ()
11449 {
11450 acosh ();
11451   ;
11452   return 0;
11453 }
11454 _ACEOF
11455 rm -f conftest.$ac_objext conftest$ac_exeext
11456 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11457   (eval $ac_link) 2>conftest.er1
11458   ac_status=$?
11459   grep -v '^ *+' conftest.er1 >conftest.err
11460   rm -f conftest.er1
11461   cat conftest.err >&5
11462   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11463   (exit $ac_status); } &&
11464          { ac_try='test -z "$ac_c_werror_flag"
11465                          || test ! -s conftest.err'
11466   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11467   (eval $ac_try) 2>&5
11468   ac_status=$?
11469   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11470   (exit $ac_status); }; } &&
11471          { ac_try='test -s conftest$ac_exeext'
11472   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11473   (eval $ac_try) 2>&5
11474   ac_status=$?
11475   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11476   (exit $ac_status); }; }; then
11477   ac_cv_lib_m_acosh=yes
11478 else
11479   echo "$as_me: failed program was:" >&5
11480 sed 's/^/| /' conftest.$ac_ext >&5
11481
11482 ac_cv_lib_m_acosh=no
11483 fi
11484 rm -f conftest.err conftest.$ac_objext \
11485       conftest$ac_exeext conftest.$ac_ext
11486 LIBS=$ac_check_lib_save_LIBS
11487 fi
11488 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosh" >&5
11489 echo "${ECHO_T}$ac_cv_lib_m_acosh" >&6
11490 if test $ac_cv_lib_m_acosh = yes; then
11491
11492 cat >>confdefs.h <<\_ACEOF
11493 #define HAVE_ACOSH 1
11494 _ACEOF
11495
11496 fi
11497
11498 echo "$as_me:$LINENO: checking for acoshl in -lm" >&5
11499 echo $ECHO_N "checking for acoshl in -lm... $ECHO_C" >&6
11500 if test "${ac_cv_lib_m_acoshl+set}" = set; then
11501   echo $ECHO_N "(cached) $ECHO_C" >&6
11502 else
11503   ac_check_lib_save_LIBS=$LIBS
11504 LIBS="-lm  $LIBS"
11505 if test x$gcc_no_link = xyes; then
11506   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11507 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11508    { (exit 1); exit 1; }; }
11509 fi
11510 cat >conftest.$ac_ext <<_ACEOF
11511 /* confdefs.h.  */
11512 _ACEOF
11513 cat confdefs.h >>conftest.$ac_ext
11514 cat >>conftest.$ac_ext <<_ACEOF
11515 /* end confdefs.h.  */
11516
11517 /* Override any gcc2 internal prototype to avoid an error.  */
11518 #ifdef __cplusplus
11519 extern "C"
11520 #endif
11521 /* We use char because int might match the return type of a gcc2
11522    builtin and then its argument prototype would still apply.  */
11523 char acoshl ();
11524 int
11525 main ()
11526 {
11527 acoshl ();
11528   ;
11529   return 0;
11530 }
11531 _ACEOF
11532 rm -f conftest.$ac_objext conftest$ac_exeext
11533 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11534   (eval $ac_link) 2>conftest.er1
11535   ac_status=$?
11536   grep -v '^ *+' conftest.er1 >conftest.err
11537   rm -f conftest.er1
11538   cat conftest.err >&5
11539   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11540   (exit $ac_status); } &&
11541          { ac_try='test -z "$ac_c_werror_flag"
11542                          || test ! -s conftest.err'
11543   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11544   (eval $ac_try) 2>&5
11545   ac_status=$?
11546   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11547   (exit $ac_status); }; } &&
11548          { ac_try='test -s conftest$ac_exeext'
11549   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11550   (eval $ac_try) 2>&5
11551   ac_status=$?
11552   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11553   (exit $ac_status); }; }; then
11554   ac_cv_lib_m_acoshl=yes
11555 else
11556   echo "$as_me: failed program was:" >&5
11557 sed 's/^/| /' conftest.$ac_ext >&5
11558
11559 ac_cv_lib_m_acoshl=no
11560 fi
11561 rm -f conftest.err conftest.$ac_objext \
11562       conftest$ac_exeext conftest.$ac_ext
11563 LIBS=$ac_check_lib_save_LIBS
11564 fi
11565 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acoshl" >&5
11566 echo "${ECHO_T}$ac_cv_lib_m_acoshl" >&6
11567 if test $ac_cv_lib_m_acoshl = yes; then
11568
11569 cat >>confdefs.h <<\_ACEOF
11570 #define HAVE_ACOSHL 1
11571 _ACEOF
11572
11573 fi
11574
11575 echo "$as_me:$LINENO: checking for asinf in -lm" >&5
11576 echo $ECHO_N "checking for asinf in -lm... $ECHO_C" >&6
11577 if test "${ac_cv_lib_m_asinf+set}" = set; then
11578   echo $ECHO_N "(cached) $ECHO_C" >&6
11579 else
11580   ac_check_lib_save_LIBS=$LIBS
11581 LIBS="-lm  $LIBS"
11582 if test x$gcc_no_link = xyes; then
11583   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11584 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11585    { (exit 1); exit 1; }; }
11586 fi
11587 cat >conftest.$ac_ext <<_ACEOF
11588 /* confdefs.h.  */
11589 _ACEOF
11590 cat confdefs.h >>conftest.$ac_ext
11591 cat >>conftest.$ac_ext <<_ACEOF
11592 /* end confdefs.h.  */
11593
11594 /* Override any gcc2 internal prototype to avoid an error.  */
11595 #ifdef __cplusplus
11596 extern "C"
11597 #endif
11598 /* We use char because int might match the return type of a gcc2
11599    builtin and then its argument prototype would still apply.  */
11600 char asinf ();
11601 int
11602 main ()
11603 {
11604 asinf ();
11605   ;
11606   return 0;
11607 }
11608 _ACEOF
11609 rm -f conftest.$ac_objext conftest$ac_exeext
11610 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11611   (eval $ac_link) 2>conftest.er1
11612   ac_status=$?
11613   grep -v '^ *+' conftest.er1 >conftest.err
11614   rm -f conftest.er1
11615   cat conftest.err >&5
11616   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11617   (exit $ac_status); } &&
11618          { ac_try='test -z "$ac_c_werror_flag"
11619                          || test ! -s conftest.err'
11620   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11621   (eval $ac_try) 2>&5
11622   ac_status=$?
11623   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11624   (exit $ac_status); }; } &&
11625          { ac_try='test -s conftest$ac_exeext'
11626   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11627   (eval $ac_try) 2>&5
11628   ac_status=$?
11629   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11630   (exit $ac_status); }; }; then
11631   ac_cv_lib_m_asinf=yes
11632 else
11633   echo "$as_me: failed program was:" >&5
11634 sed 's/^/| /' conftest.$ac_ext >&5
11635
11636 ac_cv_lib_m_asinf=no
11637 fi
11638 rm -f conftest.err conftest.$ac_objext \
11639       conftest$ac_exeext conftest.$ac_ext
11640 LIBS=$ac_check_lib_save_LIBS
11641 fi
11642 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinf" >&5
11643 echo "${ECHO_T}$ac_cv_lib_m_asinf" >&6
11644 if test $ac_cv_lib_m_asinf = yes; then
11645
11646 cat >>confdefs.h <<\_ACEOF
11647 #define HAVE_ASINF 1
11648 _ACEOF
11649
11650 fi
11651
11652 echo "$as_me:$LINENO: checking for asin in -lm" >&5
11653 echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
11654 if test "${ac_cv_lib_m_asin+set}" = set; then
11655   echo $ECHO_N "(cached) $ECHO_C" >&6
11656 else
11657   ac_check_lib_save_LIBS=$LIBS
11658 LIBS="-lm  $LIBS"
11659 if test x$gcc_no_link = xyes; then
11660   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11661 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11662    { (exit 1); exit 1; }; }
11663 fi
11664 cat >conftest.$ac_ext <<_ACEOF
11665 /* confdefs.h.  */
11666 _ACEOF
11667 cat confdefs.h >>conftest.$ac_ext
11668 cat >>conftest.$ac_ext <<_ACEOF
11669 /* end confdefs.h.  */
11670
11671 /* Override any gcc2 internal prototype to avoid an error.  */
11672 #ifdef __cplusplus
11673 extern "C"
11674 #endif
11675 /* We use char because int might match the return type of a gcc2
11676    builtin and then its argument prototype would still apply.  */
11677 char asin ();
11678 int
11679 main ()
11680 {
11681 asin ();
11682   ;
11683   return 0;
11684 }
11685 _ACEOF
11686 rm -f conftest.$ac_objext conftest$ac_exeext
11687 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11688   (eval $ac_link) 2>conftest.er1
11689   ac_status=$?
11690   grep -v '^ *+' conftest.er1 >conftest.err
11691   rm -f conftest.er1
11692   cat conftest.err >&5
11693   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11694   (exit $ac_status); } &&
11695          { ac_try='test -z "$ac_c_werror_flag"
11696                          || test ! -s conftest.err'
11697   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11698   (eval $ac_try) 2>&5
11699   ac_status=$?
11700   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11701   (exit $ac_status); }; } &&
11702          { ac_try='test -s conftest$ac_exeext'
11703   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11704   (eval $ac_try) 2>&5
11705   ac_status=$?
11706   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11707   (exit $ac_status); }; }; then
11708   ac_cv_lib_m_asin=yes
11709 else
11710   echo "$as_me: failed program was:" >&5
11711 sed 's/^/| /' conftest.$ac_ext >&5
11712
11713 ac_cv_lib_m_asin=no
11714 fi
11715 rm -f conftest.err conftest.$ac_objext \
11716       conftest$ac_exeext conftest.$ac_ext
11717 LIBS=$ac_check_lib_save_LIBS
11718 fi
11719 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
11720 echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
11721 if test $ac_cv_lib_m_asin = yes; then
11722
11723 cat >>confdefs.h <<\_ACEOF
11724 #define HAVE_ASIN 1
11725 _ACEOF
11726
11727 fi
11728
11729 echo "$as_me:$LINENO: checking for asinl in -lm" >&5
11730 echo $ECHO_N "checking for asinl in -lm... $ECHO_C" >&6
11731 if test "${ac_cv_lib_m_asinl+set}" = set; then
11732   echo $ECHO_N "(cached) $ECHO_C" >&6
11733 else
11734   ac_check_lib_save_LIBS=$LIBS
11735 LIBS="-lm  $LIBS"
11736 if test x$gcc_no_link = xyes; then
11737   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11738 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11739    { (exit 1); exit 1; }; }
11740 fi
11741 cat >conftest.$ac_ext <<_ACEOF
11742 /* confdefs.h.  */
11743 _ACEOF
11744 cat confdefs.h >>conftest.$ac_ext
11745 cat >>conftest.$ac_ext <<_ACEOF
11746 /* end confdefs.h.  */
11747
11748 /* Override any gcc2 internal prototype to avoid an error.  */
11749 #ifdef __cplusplus
11750 extern "C"
11751 #endif
11752 /* We use char because int might match the return type of a gcc2
11753    builtin and then its argument prototype would still apply.  */
11754 char asinl ();
11755 int
11756 main ()
11757 {
11758 asinl ();
11759   ;
11760   return 0;
11761 }
11762 _ACEOF
11763 rm -f conftest.$ac_objext conftest$ac_exeext
11764 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11765   (eval $ac_link) 2>conftest.er1
11766   ac_status=$?
11767   grep -v '^ *+' conftest.er1 >conftest.err
11768   rm -f conftest.er1
11769   cat conftest.err >&5
11770   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11771   (exit $ac_status); } &&
11772          { ac_try='test -z "$ac_c_werror_flag"
11773                          || test ! -s conftest.err'
11774   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11775   (eval $ac_try) 2>&5
11776   ac_status=$?
11777   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11778   (exit $ac_status); }; } &&
11779          { ac_try='test -s conftest$ac_exeext'
11780   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11781   (eval $ac_try) 2>&5
11782   ac_status=$?
11783   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11784   (exit $ac_status); }; }; then
11785   ac_cv_lib_m_asinl=yes
11786 else
11787   echo "$as_me: failed program was:" >&5
11788 sed 's/^/| /' conftest.$ac_ext >&5
11789
11790 ac_cv_lib_m_asinl=no
11791 fi
11792 rm -f conftest.err conftest.$ac_objext \
11793       conftest$ac_exeext conftest.$ac_ext
11794 LIBS=$ac_check_lib_save_LIBS
11795 fi
11796 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinl" >&5
11797 echo "${ECHO_T}$ac_cv_lib_m_asinl" >&6
11798 if test $ac_cv_lib_m_asinl = yes; then
11799
11800 cat >>confdefs.h <<\_ACEOF
11801 #define HAVE_ASINL 1
11802 _ACEOF
11803
11804 fi
11805
11806 echo "$as_me:$LINENO: checking for asinhf in -lm" >&5
11807 echo $ECHO_N "checking for asinhf in -lm... $ECHO_C" >&6
11808 if test "${ac_cv_lib_m_asinhf+set}" = set; then
11809   echo $ECHO_N "(cached) $ECHO_C" >&6
11810 else
11811   ac_check_lib_save_LIBS=$LIBS
11812 LIBS="-lm  $LIBS"
11813 if test x$gcc_no_link = xyes; then
11814   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11815 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11816    { (exit 1); exit 1; }; }
11817 fi
11818 cat >conftest.$ac_ext <<_ACEOF
11819 /* confdefs.h.  */
11820 _ACEOF
11821 cat confdefs.h >>conftest.$ac_ext
11822 cat >>conftest.$ac_ext <<_ACEOF
11823 /* end confdefs.h.  */
11824
11825 /* Override any gcc2 internal prototype to avoid an error.  */
11826 #ifdef __cplusplus
11827 extern "C"
11828 #endif
11829 /* We use char because int might match the return type of a gcc2
11830    builtin and then its argument prototype would still apply.  */
11831 char asinhf ();
11832 int
11833 main ()
11834 {
11835 asinhf ();
11836   ;
11837   return 0;
11838 }
11839 _ACEOF
11840 rm -f conftest.$ac_objext conftest$ac_exeext
11841 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11842   (eval $ac_link) 2>conftest.er1
11843   ac_status=$?
11844   grep -v '^ *+' conftest.er1 >conftest.err
11845   rm -f conftest.er1
11846   cat conftest.err >&5
11847   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11848   (exit $ac_status); } &&
11849          { ac_try='test -z "$ac_c_werror_flag"
11850                          || test ! -s conftest.err'
11851   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11852   (eval $ac_try) 2>&5
11853   ac_status=$?
11854   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11855   (exit $ac_status); }; } &&
11856          { ac_try='test -s conftest$ac_exeext'
11857   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11858   (eval $ac_try) 2>&5
11859   ac_status=$?
11860   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11861   (exit $ac_status); }; }; then
11862   ac_cv_lib_m_asinhf=yes
11863 else
11864   echo "$as_me: failed program was:" >&5
11865 sed 's/^/| /' conftest.$ac_ext >&5
11866
11867 ac_cv_lib_m_asinhf=no
11868 fi
11869 rm -f conftest.err conftest.$ac_objext \
11870       conftest$ac_exeext conftest.$ac_ext
11871 LIBS=$ac_check_lib_save_LIBS
11872 fi
11873 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinhf" >&5
11874 echo "${ECHO_T}$ac_cv_lib_m_asinhf" >&6
11875 if test $ac_cv_lib_m_asinhf = yes; then
11876
11877 cat >>confdefs.h <<\_ACEOF
11878 #define HAVE_ASINHF 1
11879 _ACEOF
11880
11881 fi
11882
11883 echo "$as_me:$LINENO: checking for asinh in -lm" >&5
11884 echo $ECHO_N "checking for asinh in -lm... $ECHO_C" >&6
11885 if test "${ac_cv_lib_m_asinh+set}" = set; then
11886   echo $ECHO_N "(cached) $ECHO_C" >&6
11887 else
11888   ac_check_lib_save_LIBS=$LIBS
11889 LIBS="-lm  $LIBS"
11890 if test x$gcc_no_link = xyes; then
11891   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11892 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11893    { (exit 1); exit 1; }; }
11894 fi
11895 cat >conftest.$ac_ext <<_ACEOF
11896 /* confdefs.h.  */
11897 _ACEOF
11898 cat confdefs.h >>conftest.$ac_ext
11899 cat >>conftest.$ac_ext <<_ACEOF
11900 /* end confdefs.h.  */
11901
11902 /* Override any gcc2 internal prototype to avoid an error.  */
11903 #ifdef __cplusplus
11904 extern "C"
11905 #endif
11906 /* We use char because int might match the return type of a gcc2
11907    builtin and then its argument prototype would still apply.  */
11908 char asinh ();
11909 int
11910 main ()
11911 {
11912 asinh ();
11913   ;
11914   return 0;
11915 }
11916 _ACEOF
11917 rm -f conftest.$ac_objext conftest$ac_exeext
11918 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11919   (eval $ac_link) 2>conftest.er1
11920   ac_status=$?
11921   grep -v '^ *+' conftest.er1 >conftest.err
11922   rm -f conftest.er1
11923   cat conftest.err >&5
11924   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11925   (exit $ac_status); } &&
11926          { ac_try='test -z "$ac_c_werror_flag"
11927                          || test ! -s conftest.err'
11928   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11929   (eval $ac_try) 2>&5
11930   ac_status=$?
11931   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11932   (exit $ac_status); }; } &&
11933          { ac_try='test -s conftest$ac_exeext'
11934   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11935   (eval $ac_try) 2>&5
11936   ac_status=$?
11937   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11938   (exit $ac_status); }; }; then
11939   ac_cv_lib_m_asinh=yes
11940 else
11941   echo "$as_me: failed program was:" >&5
11942 sed 's/^/| /' conftest.$ac_ext >&5
11943
11944 ac_cv_lib_m_asinh=no
11945 fi
11946 rm -f conftest.err conftest.$ac_objext \
11947       conftest$ac_exeext conftest.$ac_ext
11948 LIBS=$ac_check_lib_save_LIBS
11949 fi
11950 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinh" >&5
11951 echo "${ECHO_T}$ac_cv_lib_m_asinh" >&6
11952 if test $ac_cv_lib_m_asinh = yes; then
11953
11954 cat >>confdefs.h <<\_ACEOF
11955 #define HAVE_ASINH 1
11956 _ACEOF
11957
11958 fi
11959
11960 echo "$as_me:$LINENO: checking for asinhl in -lm" >&5
11961 echo $ECHO_N "checking for asinhl in -lm... $ECHO_C" >&6
11962 if test "${ac_cv_lib_m_asinhl+set}" = set; then
11963   echo $ECHO_N "(cached) $ECHO_C" >&6
11964 else
11965   ac_check_lib_save_LIBS=$LIBS
11966 LIBS="-lm  $LIBS"
11967 if test x$gcc_no_link = xyes; then
11968   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11969 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11970    { (exit 1); exit 1; }; }
11971 fi
11972 cat >conftest.$ac_ext <<_ACEOF
11973 /* confdefs.h.  */
11974 _ACEOF
11975 cat confdefs.h >>conftest.$ac_ext
11976 cat >>conftest.$ac_ext <<_ACEOF
11977 /* end confdefs.h.  */
11978
11979 /* Override any gcc2 internal prototype to avoid an error.  */
11980 #ifdef __cplusplus
11981 extern "C"
11982 #endif
11983 /* We use char because int might match the return type of a gcc2
11984    builtin and then its argument prototype would still apply.  */
11985 char asinhl ();
11986 int
11987 main ()
11988 {
11989 asinhl ();
11990   ;
11991   return 0;
11992 }
11993 _ACEOF
11994 rm -f conftest.$ac_objext conftest$ac_exeext
11995 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11996   (eval $ac_link) 2>conftest.er1
11997   ac_status=$?
11998   grep -v '^ *+' conftest.er1 >conftest.err
11999   rm -f conftest.er1
12000   cat conftest.err >&5
12001   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12002   (exit $ac_status); } &&
12003          { ac_try='test -z "$ac_c_werror_flag"
12004                          || test ! -s conftest.err'
12005   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12006   (eval $ac_try) 2>&5
12007   ac_status=$?
12008   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12009   (exit $ac_status); }; } &&
12010          { ac_try='test -s conftest$ac_exeext'
12011   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12012   (eval $ac_try) 2>&5
12013   ac_status=$?
12014   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12015   (exit $ac_status); }; }; then
12016   ac_cv_lib_m_asinhl=yes
12017 else
12018   echo "$as_me: failed program was:" >&5
12019 sed 's/^/| /' conftest.$ac_ext >&5
12020
12021 ac_cv_lib_m_asinhl=no
12022 fi
12023 rm -f conftest.err conftest.$ac_objext \
12024       conftest$ac_exeext conftest.$ac_ext
12025 LIBS=$ac_check_lib_save_LIBS
12026 fi
12027 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinhl" >&5
12028 echo "${ECHO_T}$ac_cv_lib_m_asinhl" >&6
12029 if test $ac_cv_lib_m_asinhl = yes; then
12030
12031 cat >>confdefs.h <<\_ACEOF
12032 #define HAVE_ASINHL 1
12033 _ACEOF
12034
12035 fi
12036
12037 echo "$as_me:$LINENO: checking for atan2f in -lm" >&5
12038 echo $ECHO_N "checking for atan2f in -lm... $ECHO_C" >&6
12039 if test "${ac_cv_lib_m_atan2f+set}" = set; then
12040   echo $ECHO_N "(cached) $ECHO_C" >&6
12041 else
12042   ac_check_lib_save_LIBS=$LIBS
12043 LIBS="-lm  $LIBS"
12044 if test x$gcc_no_link = xyes; then
12045   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12046 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12047    { (exit 1); exit 1; }; }
12048 fi
12049 cat >conftest.$ac_ext <<_ACEOF
12050 /* confdefs.h.  */
12051 _ACEOF
12052 cat confdefs.h >>conftest.$ac_ext
12053 cat >>conftest.$ac_ext <<_ACEOF
12054 /* end confdefs.h.  */
12055
12056 /* Override any gcc2 internal prototype to avoid an error.  */
12057 #ifdef __cplusplus
12058 extern "C"
12059 #endif
12060 /* We use char because int might match the return type of a gcc2
12061    builtin and then its argument prototype would still apply.  */
12062 char atan2f ();
12063 int
12064 main ()
12065 {
12066 atan2f ();
12067   ;
12068   return 0;
12069 }
12070 _ACEOF
12071 rm -f conftest.$ac_objext conftest$ac_exeext
12072 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12073   (eval $ac_link) 2>conftest.er1
12074   ac_status=$?
12075   grep -v '^ *+' conftest.er1 >conftest.err
12076   rm -f conftest.er1
12077   cat conftest.err >&5
12078   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12079   (exit $ac_status); } &&
12080          { ac_try='test -z "$ac_c_werror_flag"
12081                          || test ! -s conftest.err'
12082   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12083   (eval $ac_try) 2>&5
12084   ac_status=$?
12085   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12086   (exit $ac_status); }; } &&
12087          { ac_try='test -s conftest$ac_exeext'
12088   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12089   (eval $ac_try) 2>&5
12090   ac_status=$?
12091   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12092   (exit $ac_status); }; }; then
12093   ac_cv_lib_m_atan2f=yes
12094 else
12095   echo "$as_me: failed program was:" >&5
12096 sed 's/^/| /' conftest.$ac_ext >&5
12097
12098 ac_cv_lib_m_atan2f=no
12099 fi
12100 rm -f conftest.err conftest.$ac_objext \
12101       conftest$ac_exeext conftest.$ac_ext
12102 LIBS=$ac_check_lib_save_LIBS
12103 fi
12104 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2f" >&5
12105 echo "${ECHO_T}$ac_cv_lib_m_atan2f" >&6
12106 if test $ac_cv_lib_m_atan2f = yes; then
12107
12108 cat >>confdefs.h <<\_ACEOF
12109 #define HAVE_ATAN2F 1
12110 _ACEOF
12111
12112 fi
12113
12114 echo "$as_me:$LINENO: checking for atan2 in -lm" >&5
12115 echo $ECHO_N "checking for atan2 in -lm... $ECHO_C" >&6
12116 if test "${ac_cv_lib_m_atan2+set}" = set; then
12117   echo $ECHO_N "(cached) $ECHO_C" >&6
12118 else
12119   ac_check_lib_save_LIBS=$LIBS
12120 LIBS="-lm  $LIBS"
12121 if test x$gcc_no_link = xyes; then
12122   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12123 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12124    { (exit 1); exit 1; }; }
12125 fi
12126 cat >conftest.$ac_ext <<_ACEOF
12127 /* confdefs.h.  */
12128 _ACEOF
12129 cat confdefs.h >>conftest.$ac_ext
12130 cat >>conftest.$ac_ext <<_ACEOF
12131 /* end confdefs.h.  */
12132
12133 /* Override any gcc2 internal prototype to avoid an error.  */
12134 #ifdef __cplusplus
12135 extern "C"
12136 #endif
12137 /* We use char because int might match the return type of a gcc2
12138    builtin and then its argument prototype would still apply.  */
12139 char atan2 ();
12140 int
12141 main ()
12142 {
12143 atan2 ();
12144   ;
12145   return 0;
12146 }
12147 _ACEOF
12148 rm -f conftest.$ac_objext conftest$ac_exeext
12149 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12150   (eval $ac_link) 2>conftest.er1
12151   ac_status=$?
12152   grep -v '^ *+' conftest.er1 >conftest.err
12153   rm -f conftest.er1
12154   cat conftest.err >&5
12155   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12156   (exit $ac_status); } &&
12157          { ac_try='test -z "$ac_c_werror_flag"
12158                          || test ! -s conftest.err'
12159   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12160   (eval $ac_try) 2>&5
12161   ac_status=$?
12162   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12163   (exit $ac_status); }; } &&
12164          { ac_try='test -s conftest$ac_exeext'
12165   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12166   (eval $ac_try) 2>&5
12167   ac_status=$?
12168   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12169   (exit $ac_status); }; }; then
12170   ac_cv_lib_m_atan2=yes
12171 else
12172   echo "$as_me: failed program was:" >&5
12173 sed 's/^/| /' conftest.$ac_ext >&5
12174
12175 ac_cv_lib_m_atan2=no
12176 fi
12177 rm -f conftest.err conftest.$ac_objext \
12178       conftest$ac_exeext conftest.$ac_ext
12179 LIBS=$ac_check_lib_save_LIBS
12180 fi
12181 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2" >&5
12182 echo "${ECHO_T}$ac_cv_lib_m_atan2" >&6
12183 if test $ac_cv_lib_m_atan2 = yes; then
12184
12185 cat >>confdefs.h <<\_ACEOF
12186 #define HAVE_ATAN2 1
12187 _ACEOF
12188
12189 fi
12190
12191 echo "$as_me:$LINENO: checking for atan2l in -lm" >&5
12192 echo $ECHO_N "checking for atan2l in -lm... $ECHO_C" >&6
12193 if test "${ac_cv_lib_m_atan2l+set}" = set; then
12194   echo $ECHO_N "(cached) $ECHO_C" >&6
12195 else
12196   ac_check_lib_save_LIBS=$LIBS
12197 LIBS="-lm  $LIBS"
12198 if test x$gcc_no_link = xyes; then
12199   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12200 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12201    { (exit 1); exit 1; }; }
12202 fi
12203 cat >conftest.$ac_ext <<_ACEOF
12204 /* confdefs.h.  */
12205 _ACEOF
12206 cat confdefs.h >>conftest.$ac_ext
12207 cat >>conftest.$ac_ext <<_ACEOF
12208 /* end confdefs.h.  */
12209
12210 /* Override any gcc2 internal prototype to avoid an error.  */
12211 #ifdef __cplusplus
12212 extern "C"
12213 #endif
12214 /* We use char because int might match the return type of a gcc2
12215    builtin and then its argument prototype would still apply.  */
12216 char atan2l ();
12217 int
12218 main ()
12219 {
12220 atan2l ();
12221   ;
12222   return 0;
12223 }
12224 _ACEOF
12225 rm -f conftest.$ac_objext conftest$ac_exeext
12226 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12227   (eval $ac_link) 2>conftest.er1
12228   ac_status=$?
12229   grep -v '^ *+' conftest.er1 >conftest.err
12230   rm -f conftest.er1
12231   cat conftest.err >&5
12232   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12233   (exit $ac_status); } &&
12234          { ac_try='test -z "$ac_c_werror_flag"
12235                          || test ! -s conftest.err'
12236   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12237   (eval $ac_try) 2>&5
12238   ac_status=$?
12239   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12240   (exit $ac_status); }; } &&
12241          { ac_try='test -s conftest$ac_exeext'
12242   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12243   (eval $ac_try) 2>&5
12244   ac_status=$?
12245   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12246   (exit $ac_status); }; }; then
12247   ac_cv_lib_m_atan2l=yes
12248 else
12249   echo "$as_me: failed program was:" >&5
12250 sed 's/^/| /' conftest.$ac_ext >&5
12251
12252 ac_cv_lib_m_atan2l=no
12253 fi
12254 rm -f conftest.err conftest.$ac_objext \
12255       conftest$ac_exeext conftest.$ac_ext
12256 LIBS=$ac_check_lib_save_LIBS
12257 fi
12258 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2l" >&5
12259 echo "${ECHO_T}$ac_cv_lib_m_atan2l" >&6
12260 if test $ac_cv_lib_m_atan2l = yes; then
12261
12262 cat >>confdefs.h <<\_ACEOF
12263 #define HAVE_ATAN2L 1
12264 _ACEOF
12265
12266 fi
12267
12268 echo "$as_me:$LINENO: checking for atanf in -lm" >&5
12269 echo $ECHO_N "checking for atanf in -lm... $ECHO_C" >&6
12270 if test "${ac_cv_lib_m_atanf+set}" = set; then
12271   echo $ECHO_N "(cached) $ECHO_C" >&6
12272 else
12273   ac_check_lib_save_LIBS=$LIBS
12274 LIBS="-lm  $LIBS"
12275 if test x$gcc_no_link = xyes; then
12276   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12277 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12278    { (exit 1); exit 1; }; }
12279 fi
12280 cat >conftest.$ac_ext <<_ACEOF
12281 /* confdefs.h.  */
12282 _ACEOF
12283 cat confdefs.h >>conftest.$ac_ext
12284 cat >>conftest.$ac_ext <<_ACEOF
12285 /* end confdefs.h.  */
12286
12287 /* Override any gcc2 internal prototype to avoid an error.  */
12288 #ifdef __cplusplus
12289 extern "C"
12290 #endif
12291 /* We use char because int might match the return type of a gcc2
12292    builtin and then its argument prototype would still apply.  */
12293 char atanf ();
12294 int
12295 main ()
12296 {
12297 atanf ();
12298   ;
12299   return 0;
12300 }
12301 _ACEOF
12302 rm -f conftest.$ac_objext conftest$ac_exeext
12303 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12304   (eval $ac_link) 2>conftest.er1
12305   ac_status=$?
12306   grep -v '^ *+' conftest.er1 >conftest.err
12307   rm -f conftest.er1
12308   cat conftest.err >&5
12309   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12310   (exit $ac_status); } &&
12311          { ac_try='test -z "$ac_c_werror_flag"
12312                          || test ! -s conftest.err'
12313   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12314   (eval $ac_try) 2>&5
12315   ac_status=$?
12316   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12317   (exit $ac_status); }; } &&
12318          { ac_try='test -s conftest$ac_exeext'
12319   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12320   (eval $ac_try) 2>&5
12321   ac_status=$?
12322   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12323   (exit $ac_status); }; }; then
12324   ac_cv_lib_m_atanf=yes
12325 else
12326   echo "$as_me: failed program was:" >&5
12327 sed 's/^/| /' conftest.$ac_ext >&5
12328
12329 ac_cv_lib_m_atanf=no
12330 fi
12331 rm -f conftest.err conftest.$ac_objext \
12332       conftest$ac_exeext conftest.$ac_ext
12333 LIBS=$ac_check_lib_save_LIBS
12334 fi
12335 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanf" >&5
12336 echo "${ECHO_T}$ac_cv_lib_m_atanf" >&6
12337 if test $ac_cv_lib_m_atanf = yes; then
12338
12339 cat >>confdefs.h <<\_ACEOF
12340 #define HAVE_ATANF 1
12341 _ACEOF
12342
12343 fi
12344
12345 echo "$as_me:$LINENO: checking for atan in -lm" >&5
12346 echo $ECHO_N "checking for atan in -lm... $ECHO_C" >&6
12347 if test "${ac_cv_lib_m_atan+set}" = set; then
12348   echo $ECHO_N "(cached) $ECHO_C" >&6
12349 else
12350   ac_check_lib_save_LIBS=$LIBS
12351 LIBS="-lm  $LIBS"
12352 if test x$gcc_no_link = xyes; then
12353   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12354 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12355    { (exit 1); exit 1; }; }
12356 fi
12357 cat >conftest.$ac_ext <<_ACEOF
12358 /* confdefs.h.  */
12359 _ACEOF
12360 cat confdefs.h >>conftest.$ac_ext
12361 cat >>conftest.$ac_ext <<_ACEOF
12362 /* end confdefs.h.  */
12363
12364 /* Override any gcc2 internal prototype to avoid an error.  */
12365 #ifdef __cplusplus
12366 extern "C"
12367 #endif
12368 /* We use char because int might match the return type of a gcc2
12369    builtin and then its argument prototype would still apply.  */
12370 char atan ();
12371 int
12372 main ()
12373 {
12374 atan ();
12375   ;
12376   return 0;
12377 }
12378 _ACEOF
12379 rm -f conftest.$ac_objext conftest$ac_exeext
12380 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12381   (eval $ac_link) 2>conftest.er1
12382   ac_status=$?
12383   grep -v '^ *+' conftest.er1 >conftest.err
12384   rm -f conftest.er1
12385   cat conftest.err >&5
12386   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12387   (exit $ac_status); } &&
12388          { ac_try='test -z "$ac_c_werror_flag"
12389                          || test ! -s conftest.err'
12390   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12391   (eval $ac_try) 2>&5
12392   ac_status=$?
12393   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12394   (exit $ac_status); }; } &&
12395          { ac_try='test -s conftest$ac_exeext'
12396   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12397   (eval $ac_try) 2>&5
12398   ac_status=$?
12399   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12400   (exit $ac_status); }; }; then
12401   ac_cv_lib_m_atan=yes
12402 else
12403   echo "$as_me: failed program was:" >&5
12404 sed 's/^/| /' conftest.$ac_ext >&5
12405
12406 ac_cv_lib_m_atan=no
12407 fi
12408 rm -f conftest.err conftest.$ac_objext \
12409       conftest$ac_exeext conftest.$ac_ext
12410 LIBS=$ac_check_lib_save_LIBS
12411 fi
12412 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan" >&5
12413 echo "${ECHO_T}$ac_cv_lib_m_atan" >&6
12414 if test $ac_cv_lib_m_atan = yes; then
12415
12416 cat >>confdefs.h <<\_ACEOF
12417 #define HAVE_ATAN 1
12418 _ACEOF
12419
12420 fi
12421
12422 echo "$as_me:$LINENO: checking for atanl in -lm" >&5
12423 echo $ECHO_N "checking for atanl in -lm... $ECHO_C" >&6
12424 if test "${ac_cv_lib_m_atanl+set}" = set; then
12425   echo $ECHO_N "(cached) $ECHO_C" >&6
12426 else
12427   ac_check_lib_save_LIBS=$LIBS
12428 LIBS="-lm  $LIBS"
12429 if test x$gcc_no_link = xyes; then
12430   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12431 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12432    { (exit 1); exit 1; }; }
12433 fi
12434 cat >conftest.$ac_ext <<_ACEOF
12435 /* confdefs.h.  */
12436 _ACEOF
12437 cat confdefs.h >>conftest.$ac_ext
12438 cat >>conftest.$ac_ext <<_ACEOF
12439 /* end confdefs.h.  */
12440
12441 /* Override any gcc2 internal prototype to avoid an error.  */
12442 #ifdef __cplusplus
12443 extern "C"
12444 #endif
12445 /* We use char because int might match the return type of a gcc2
12446    builtin and then its argument prototype would still apply.  */
12447 char atanl ();
12448 int
12449 main ()
12450 {
12451 atanl ();
12452   ;
12453   return 0;
12454 }
12455 _ACEOF
12456 rm -f conftest.$ac_objext conftest$ac_exeext
12457 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12458   (eval $ac_link) 2>conftest.er1
12459   ac_status=$?
12460   grep -v '^ *+' conftest.er1 >conftest.err
12461   rm -f conftest.er1
12462   cat conftest.err >&5
12463   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12464   (exit $ac_status); } &&
12465          { ac_try='test -z "$ac_c_werror_flag"
12466                          || test ! -s conftest.err'
12467   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12468   (eval $ac_try) 2>&5
12469   ac_status=$?
12470   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12471   (exit $ac_status); }; } &&
12472          { ac_try='test -s conftest$ac_exeext'
12473   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12474   (eval $ac_try) 2>&5
12475   ac_status=$?
12476   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12477   (exit $ac_status); }; }; then
12478   ac_cv_lib_m_atanl=yes
12479 else
12480   echo "$as_me: failed program was:" >&5
12481 sed 's/^/| /' conftest.$ac_ext >&5
12482
12483 ac_cv_lib_m_atanl=no
12484 fi
12485 rm -f conftest.err conftest.$ac_objext \
12486       conftest$ac_exeext conftest.$ac_ext
12487 LIBS=$ac_check_lib_save_LIBS
12488 fi
12489 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanl" >&5
12490 echo "${ECHO_T}$ac_cv_lib_m_atanl" >&6
12491 if test $ac_cv_lib_m_atanl = yes; then
12492
12493 cat >>confdefs.h <<\_ACEOF
12494 #define HAVE_ATANL 1
12495 _ACEOF
12496
12497 fi
12498
12499 echo "$as_me:$LINENO: checking for atanhf in -lm" >&5
12500 echo $ECHO_N "checking for atanhf in -lm... $ECHO_C" >&6
12501 if test "${ac_cv_lib_m_atanhf+set}" = set; then
12502   echo $ECHO_N "(cached) $ECHO_C" >&6
12503 else
12504   ac_check_lib_save_LIBS=$LIBS
12505 LIBS="-lm  $LIBS"
12506 if test x$gcc_no_link = xyes; then
12507   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12508 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12509    { (exit 1); exit 1; }; }
12510 fi
12511 cat >conftest.$ac_ext <<_ACEOF
12512 /* confdefs.h.  */
12513 _ACEOF
12514 cat confdefs.h >>conftest.$ac_ext
12515 cat >>conftest.$ac_ext <<_ACEOF
12516 /* end confdefs.h.  */
12517
12518 /* Override any gcc2 internal prototype to avoid an error.  */
12519 #ifdef __cplusplus
12520 extern "C"
12521 #endif
12522 /* We use char because int might match the return type of a gcc2
12523    builtin and then its argument prototype would still apply.  */
12524 char atanhf ();
12525 int
12526 main ()
12527 {
12528 atanhf ();
12529   ;
12530   return 0;
12531 }
12532 _ACEOF
12533 rm -f conftest.$ac_objext conftest$ac_exeext
12534 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12535   (eval $ac_link) 2>conftest.er1
12536   ac_status=$?
12537   grep -v '^ *+' conftest.er1 >conftest.err
12538   rm -f conftest.er1
12539   cat conftest.err >&5
12540   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12541   (exit $ac_status); } &&
12542          { ac_try='test -z "$ac_c_werror_flag"
12543                          || test ! -s conftest.err'
12544   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12545   (eval $ac_try) 2>&5
12546   ac_status=$?
12547   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12548   (exit $ac_status); }; } &&
12549          { ac_try='test -s conftest$ac_exeext'
12550   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12551   (eval $ac_try) 2>&5
12552   ac_status=$?
12553   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12554   (exit $ac_status); }; }; then
12555   ac_cv_lib_m_atanhf=yes
12556 else
12557   echo "$as_me: failed program was:" >&5
12558 sed 's/^/| /' conftest.$ac_ext >&5
12559
12560 ac_cv_lib_m_atanhf=no
12561 fi
12562 rm -f conftest.err conftest.$ac_objext \
12563       conftest$ac_exeext conftest.$ac_ext
12564 LIBS=$ac_check_lib_save_LIBS
12565 fi
12566 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanhf" >&5
12567 echo "${ECHO_T}$ac_cv_lib_m_atanhf" >&6
12568 if test $ac_cv_lib_m_atanhf = yes; then
12569
12570 cat >>confdefs.h <<\_ACEOF
12571 #define HAVE_ATANHF 1
12572 _ACEOF
12573
12574 fi
12575
12576 echo "$as_me:$LINENO: checking for atanh in -lm" >&5
12577 echo $ECHO_N "checking for atanh in -lm... $ECHO_C" >&6
12578 if test "${ac_cv_lib_m_atanh+set}" = set; then
12579   echo $ECHO_N "(cached) $ECHO_C" >&6
12580 else
12581   ac_check_lib_save_LIBS=$LIBS
12582 LIBS="-lm  $LIBS"
12583 if test x$gcc_no_link = xyes; then
12584   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12585 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12586    { (exit 1); exit 1; }; }
12587 fi
12588 cat >conftest.$ac_ext <<_ACEOF
12589 /* confdefs.h.  */
12590 _ACEOF
12591 cat confdefs.h >>conftest.$ac_ext
12592 cat >>conftest.$ac_ext <<_ACEOF
12593 /* end confdefs.h.  */
12594
12595 /* Override any gcc2 internal prototype to avoid an error.  */
12596 #ifdef __cplusplus
12597 extern "C"
12598 #endif
12599 /* We use char because int might match the return type of a gcc2
12600    builtin and then its argument prototype would still apply.  */
12601 char atanh ();
12602 int
12603 main ()
12604 {
12605 atanh ();
12606   ;
12607   return 0;
12608 }
12609 _ACEOF
12610 rm -f conftest.$ac_objext conftest$ac_exeext
12611 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12612   (eval $ac_link) 2>conftest.er1
12613   ac_status=$?
12614   grep -v '^ *+' conftest.er1 >conftest.err
12615   rm -f conftest.er1
12616   cat conftest.err >&5
12617   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12618   (exit $ac_status); } &&
12619          { ac_try='test -z "$ac_c_werror_flag"
12620                          || test ! -s conftest.err'
12621   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12622   (eval $ac_try) 2>&5
12623   ac_status=$?
12624   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12625   (exit $ac_status); }; } &&
12626          { ac_try='test -s conftest$ac_exeext'
12627   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12628   (eval $ac_try) 2>&5
12629   ac_status=$?
12630   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12631   (exit $ac_status); }; }; then
12632   ac_cv_lib_m_atanh=yes
12633 else
12634   echo "$as_me: failed program was:" >&5
12635 sed 's/^/| /' conftest.$ac_ext >&5
12636
12637 ac_cv_lib_m_atanh=no
12638 fi
12639 rm -f conftest.err conftest.$ac_objext \
12640       conftest$ac_exeext conftest.$ac_ext
12641 LIBS=$ac_check_lib_save_LIBS
12642 fi
12643 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanh" >&5
12644 echo "${ECHO_T}$ac_cv_lib_m_atanh" >&6
12645 if test $ac_cv_lib_m_atanh = yes; then
12646
12647 cat >>confdefs.h <<\_ACEOF
12648 #define HAVE_ATANH 1
12649 _ACEOF
12650
12651 fi
12652
12653 echo "$as_me:$LINENO: checking for atanhl in -lm" >&5
12654 echo $ECHO_N "checking for atanhl in -lm... $ECHO_C" >&6
12655 if test "${ac_cv_lib_m_atanhl+set}" = set; then
12656   echo $ECHO_N "(cached) $ECHO_C" >&6
12657 else
12658   ac_check_lib_save_LIBS=$LIBS
12659 LIBS="-lm  $LIBS"
12660 if test x$gcc_no_link = xyes; then
12661   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12662 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12663    { (exit 1); exit 1; }; }
12664 fi
12665 cat >conftest.$ac_ext <<_ACEOF
12666 /* confdefs.h.  */
12667 _ACEOF
12668 cat confdefs.h >>conftest.$ac_ext
12669 cat >>conftest.$ac_ext <<_ACEOF
12670 /* end confdefs.h.  */
12671
12672 /* Override any gcc2 internal prototype to avoid an error.  */
12673 #ifdef __cplusplus
12674 extern "C"
12675 #endif
12676 /* We use char because int might match the return type of a gcc2
12677    builtin and then its argument prototype would still apply.  */
12678 char atanhl ();
12679 int
12680 main ()
12681 {
12682 atanhl ();
12683   ;
12684   return 0;
12685 }
12686 _ACEOF
12687 rm -f conftest.$ac_objext conftest$ac_exeext
12688 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12689   (eval $ac_link) 2>conftest.er1
12690   ac_status=$?
12691   grep -v '^ *+' conftest.er1 >conftest.err
12692   rm -f conftest.er1
12693   cat conftest.err >&5
12694   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12695   (exit $ac_status); } &&
12696          { ac_try='test -z "$ac_c_werror_flag"
12697                          || test ! -s conftest.err'
12698   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12699   (eval $ac_try) 2>&5
12700   ac_status=$?
12701   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12702   (exit $ac_status); }; } &&
12703          { ac_try='test -s conftest$ac_exeext'
12704   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12705   (eval $ac_try) 2>&5
12706   ac_status=$?
12707   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12708   (exit $ac_status); }; }; then
12709   ac_cv_lib_m_atanhl=yes
12710 else
12711   echo "$as_me: failed program was:" >&5
12712 sed 's/^/| /' conftest.$ac_ext >&5
12713
12714 ac_cv_lib_m_atanhl=no
12715 fi
12716 rm -f conftest.err conftest.$ac_objext \
12717       conftest$ac_exeext conftest.$ac_ext
12718 LIBS=$ac_check_lib_save_LIBS
12719 fi
12720 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanhl" >&5
12721 echo "${ECHO_T}$ac_cv_lib_m_atanhl" >&6
12722 if test $ac_cv_lib_m_atanhl = yes; then
12723
12724 cat >>confdefs.h <<\_ACEOF
12725 #define HAVE_ATANHL 1
12726 _ACEOF
12727
12728 fi
12729
12730 echo "$as_me:$LINENO: checking for cargf in -lm" >&5
12731 echo $ECHO_N "checking for cargf in -lm... $ECHO_C" >&6
12732 if test "${ac_cv_lib_m_cargf+set}" = set; then
12733   echo $ECHO_N "(cached) $ECHO_C" >&6
12734 else
12735   ac_check_lib_save_LIBS=$LIBS
12736 LIBS="-lm  $LIBS"
12737 if test x$gcc_no_link = xyes; then
12738   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12739 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12740    { (exit 1); exit 1; }; }
12741 fi
12742 cat >conftest.$ac_ext <<_ACEOF
12743 /* confdefs.h.  */
12744 _ACEOF
12745 cat confdefs.h >>conftest.$ac_ext
12746 cat >>conftest.$ac_ext <<_ACEOF
12747 /* end confdefs.h.  */
12748
12749 /* Override any gcc2 internal prototype to avoid an error.  */
12750 #ifdef __cplusplus
12751 extern "C"
12752 #endif
12753 /* We use char because int might match the return type of a gcc2
12754    builtin and then its argument prototype would still apply.  */
12755 char cargf ();
12756 int
12757 main ()
12758 {
12759 cargf ();
12760   ;
12761   return 0;
12762 }
12763 _ACEOF
12764 rm -f conftest.$ac_objext conftest$ac_exeext
12765 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12766   (eval $ac_link) 2>conftest.er1
12767   ac_status=$?
12768   grep -v '^ *+' conftest.er1 >conftest.err
12769   rm -f conftest.er1
12770   cat conftest.err >&5
12771   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12772   (exit $ac_status); } &&
12773          { ac_try='test -z "$ac_c_werror_flag"
12774                          || test ! -s conftest.err'
12775   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12776   (eval $ac_try) 2>&5
12777   ac_status=$?
12778   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12779   (exit $ac_status); }; } &&
12780          { ac_try='test -s conftest$ac_exeext'
12781   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12782   (eval $ac_try) 2>&5
12783   ac_status=$?
12784   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12785   (exit $ac_status); }; }; then
12786   ac_cv_lib_m_cargf=yes
12787 else
12788   echo "$as_me: failed program was:" >&5
12789 sed 's/^/| /' conftest.$ac_ext >&5
12790
12791 ac_cv_lib_m_cargf=no
12792 fi
12793 rm -f conftest.err conftest.$ac_objext \
12794       conftest$ac_exeext conftest.$ac_ext
12795 LIBS=$ac_check_lib_save_LIBS
12796 fi
12797 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cargf" >&5
12798 echo "${ECHO_T}$ac_cv_lib_m_cargf" >&6
12799 if test $ac_cv_lib_m_cargf = yes; then
12800
12801 cat >>confdefs.h <<\_ACEOF
12802 #define HAVE_CARGF 1
12803 _ACEOF
12804
12805 fi
12806
12807 echo "$as_me:$LINENO: checking for carg in -lm" >&5
12808 echo $ECHO_N "checking for carg in -lm... $ECHO_C" >&6
12809 if test "${ac_cv_lib_m_carg+set}" = set; then
12810   echo $ECHO_N "(cached) $ECHO_C" >&6
12811 else
12812   ac_check_lib_save_LIBS=$LIBS
12813 LIBS="-lm  $LIBS"
12814 if test x$gcc_no_link = xyes; then
12815   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12816 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12817    { (exit 1); exit 1; }; }
12818 fi
12819 cat >conftest.$ac_ext <<_ACEOF
12820 /* confdefs.h.  */
12821 _ACEOF
12822 cat confdefs.h >>conftest.$ac_ext
12823 cat >>conftest.$ac_ext <<_ACEOF
12824 /* end confdefs.h.  */
12825
12826 /* Override any gcc2 internal prototype to avoid an error.  */
12827 #ifdef __cplusplus
12828 extern "C"
12829 #endif
12830 /* We use char because int might match the return type of a gcc2
12831    builtin and then its argument prototype would still apply.  */
12832 char carg ();
12833 int
12834 main ()
12835 {
12836 carg ();
12837   ;
12838   return 0;
12839 }
12840 _ACEOF
12841 rm -f conftest.$ac_objext conftest$ac_exeext
12842 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12843   (eval $ac_link) 2>conftest.er1
12844   ac_status=$?
12845   grep -v '^ *+' conftest.er1 >conftest.err
12846   rm -f conftest.er1
12847   cat conftest.err >&5
12848   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12849   (exit $ac_status); } &&
12850          { ac_try='test -z "$ac_c_werror_flag"
12851                          || test ! -s conftest.err'
12852   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12853   (eval $ac_try) 2>&5
12854   ac_status=$?
12855   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12856   (exit $ac_status); }; } &&
12857          { ac_try='test -s conftest$ac_exeext'
12858   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12859   (eval $ac_try) 2>&5
12860   ac_status=$?
12861   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12862   (exit $ac_status); }; }; then
12863   ac_cv_lib_m_carg=yes
12864 else
12865   echo "$as_me: failed program was:" >&5
12866 sed 's/^/| /' conftest.$ac_ext >&5
12867
12868 ac_cv_lib_m_carg=no
12869 fi
12870 rm -f conftest.err conftest.$ac_objext \
12871       conftest$ac_exeext conftest.$ac_ext
12872 LIBS=$ac_check_lib_save_LIBS
12873 fi
12874 echo "$as_me:$LINENO: result: $ac_cv_lib_m_carg" >&5
12875 echo "${ECHO_T}$ac_cv_lib_m_carg" >&6
12876 if test $ac_cv_lib_m_carg = yes; then
12877
12878 cat >>confdefs.h <<\_ACEOF
12879 #define HAVE_CARG 1
12880 _ACEOF
12881
12882 fi
12883
12884 echo "$as_me:$LINENO: checking for cargl in -lm" >&5
12885 echo $ECHO_N "checking for cargl in -lm... $ECHO_C" >&6
12886 if test "${ac_cv_lib_m_cargl+set}" = set; then
12887   echo $ECHO_N "(cached) $ECHO_C" >&6
12888 else
12889   ac_check_lib_save_LIBS=$LIBS
12890 LIBS="-lm  $LIBS"
12891 if test x$gcc_no_link = xyes; then
12892   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12893 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12894    { (exit 1); exit 1; }; }
12895 fi
12896 cat >conftest.$ac_ext <<_ACEOF
12897 /* confdefs.h.  */
12898 _ACEOF
12899 cat confdefs.h >>conftest.$ac_ext
12900 cat >>conftest.$ac_ext <<_ACEOF
12901 /* end confdefs.h.  */
12902
12903 /* Override any gcc2 internal prototype to avoid an error.  */
12904 #ifdef __cplusplus
12905 extern "C"
12906 #endif
12907 /* We use char because int might match the return type of a gcc2
12908    builtin and then its argument prototype would still apply.  */
12909 char cargl ();
12910 int
12911 main ()
12912 {
12913 cargl ();
12914   ;
12915   return 0;
12916 }
12917 _ACEOF
12918 rm -f conftest.$ac_objext conftest$ac_exeext
12919 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12920   (eval $ac_link) 2>conftest.er1
12921   ac_status=$?
12922   grep -v '^ *+' conftest.er1 >conftest.err
12923   rm -f conftest.er1
12924   cat conftest.err >&5
12925   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12926   (exit $ac_status); } &&
12927          { ac_try='test -z "$ac_c_werror_flag"
12928                          || test ! -s conftest.err'
12929   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12930   (eval $ac_try) 2>&5
12931   ac_status=$?
12932   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12933   (exit $ac_status); }; } &&
12934          { ac_try='test -s conftest$ac_exeext'
12935   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12936   (eval $ac_try) 2>&5
12937   ac_status=$?
12938   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12939   (exit $ac_status); }; }; then
12940   ac_cv_lib_m_cargl=yes
12941 else
12942   echo "$as_me: failed program was:" >&5
12943 sed 's/^/| /' conftest.$ac_ext >&5
12944
12945 ac_cv_lib_m_cargl=no
12946 fi
12947 rm -f conftest.err conftest.$ac_objext \
12948       conftest$ac_exeext conftest.$ac_ext
12949 LIBS=$ac_check_lib_save_LIBS
12950 fi
12951 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cargl" >&5
12952 echo "${ECHO_T}$ac_cv_lib_m_cargl" >&6
12953 if test $ac_cv_lib_m_cargl = yes; then
12954
12955 cat >>confdefs.h <<\_ACEOF
12956 #define HAVE_CARGL 1
12957 _ACEOF
12958
12959 fi
12960
12961 echo "$as_me:$LINENO: checking for ceilf in -lm" >&5
12962 echo $ECHO_N "checking for ceilf in -lm... $ECHO_C" >&6
12963 if test "${ac_cv_lib_m_ceilf+set}" = set; then
12964   echo $ECHO_N "(cached) $ECHO_C" >&6
12965 else
12966   ac_check_lib_save_LIBS=$LIBS
12967 LIBS="-lm  $LIBS"
12968 if test x$gcc_no_link = xyes; then
12969   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12970 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12971    { (exit 1); exit 1; }; }
12972 fi
12973 cat >conftest.$ac_ext <<_ACEOF
12974 /* confdefs.h.  */
12975 _ACEOF
12976 cat confdefs.h >>conftest.$ac_ext
12977 cat >>conftest.$ac_ext <<_ACEOF
12978 /* end confdefs.h.  */
12979
12980 /* Override any gcc2 internal prototype to avoid an error.  */
12981 #ifdef __cplusplus
12982 extern "C"
12983 #endif
12984 /* We use char because int might match the return type of a gcc2
12985    builtin and then its argument prototype would still apply.  */
12986 char ceilf ();
12987 int
12988 main ()
12989 {
12990 ceilf ();
12991   ;
12992   return 0;
12993 }
12994 _ACEOF
12995 rm -f conftest.$ac_objext conftest$ac_exeext
12996 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12997   (eval $ac_link) 2>conftest.er1
12998   ac_status=$?
12999   grep -v '^ *+' conftest.er1 >conftest.err
13000   rm -f conftest.er1
13001   cat conftest.err >&5
13002   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13003   (exit $ac_status); } &&
13004          { ac_try='test -z "$ac_c_werror_flag"
13005                          || test ! -s conftest.err'
13006   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13007   (eval $ac_try) 2>&5
13008   ac_status=$?
13009   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13010   (exit $ac_status); }; } &&
13011          { ac_try='test -s conftest$ac_exeext'
13012   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13013   (eval $ac_try) 2>&5
13014   ac_status=$?
13015   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13016   (exit $ac_status); }; }; then
13017   ac_cv_lib_m_ceilf=yes
13018 else
13019   echo "$as_me: failed program was:" >&5
13020 sed 's/^/| /' conftest.$ac_ext >&5
13021
13022 ac_cv_lib_m_ceilf=no
13023 fi
13024 rm -f conftest.err conftest.$ac_objext \
13025       conftest$ac_exeext conftest.$ac_ext
13026 LIBS=$ac_check_lib_save_LIBS
13027 fi
13028 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceilf" >&5
13029 echo "${ECHO_T}$ac_cv_lib_m_ceilf" >&6
13030 if test $ac_cv_lib_m_ceilf = yes; then
13031
13032 cat >>confdefs.h <<\_ACEOF
13033 #define HAVE_CEILF 1
13034 _ACEOF
13035
13036 fi
13037
13038 echo "$as_me:$LINENO: checking for ceil in -lm" >&5
13039 echo $ECHO_N "checking for ceil in -lm... $ECHO_C" >&6
13040 if test "${ac_cv_lib_m_ceil+set}" = set; then
13041   echo $ECHO_N "(cached) $ECHO_C" >&6
13042 else
13043   ac_check_lib_save_LIBS=$LIBS
13044 LIBS="-lm  $LIBS"
13045 if test x$gcc_no_link = xyes; then
13046   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13047 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13048    { (exit 1); exit 1; }; }
13049 fi
13050 cat >conftest.$ac_ext <<_ACEOF
13051 /* confdefs.h.  */
13052 _ACEOF
13053 cat confdefs.h >>conftest.$ac_ext
13054 cat >>conftest.$ac_ext <<_ACEOF
13055 /* end confdefs.h.  */
13056
13057 /* Override any gcc2 internal prototype to avoid an error.  */
13058 #ifdef __cplusplus
13059 extern "C"
13060 #endif
13061 /* We use char because int might match the return type of a gcc2
13062    builtin and then its argument prototype would still apply.  */
13063 char ceil ();
13064 int
13065 main ()
13066 {
13067 ceil ();
13068   ;
13069   return 0;
13070 }
13071 _ACEOF
13072 rm -f conftest.$ac_objext conftest$ac_exeext
13073 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13074   (eval $ac_link) 2>conftest.er1
13075   ac_status=$?
13076   grep -v '^ *+' conftest.er1 >conftest.err
13077   rm -f conftest.er1
13078   cat conftest.err >&5
13079   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13080   (exit $ac_status); } &&
13081          { ac_try='test -z "$ac_c_werror_flag"
13082                          || test ! -s conftest.err'
13083   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13084   (eval $ac_try) 2>&5
13085   ac_status=$?
13086   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13087   (exit $ac_status); }; } &&
13088          { ac_try='test -s conftest$ac_exeext'
13089   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13090   (eval $ac_try) 2>&5
13091   ac_status=$?
13092   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13093   (exit $ac_status); }; }; then
13094   ac_cv_lib_m_ceil=yes
13095 else
13096   echo "$as_me: failed program was:" >&5
13097 sed 's/^/| /' conftest.$ac_ext >&5
13098
13099 ac_cv_lib_m_ceil=no
13100 fi
13101 rm -f conftest.err conftest.$ac_objext \
13102       conftest$ac_exeext conftest.$ac_ext
13103 LIBS=$ac_check_lib_save_LIBS
13104 fi
13105 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceil" >&5
13106 echo "${ECHO_T}$ac_cv_lib_m_ceil" >&6
13107 if test $ac_cv_lib_m_ceil = yes; then
13108
13109 cat >>confdefs.h <<\_ACEOF
13110 #define HAVE_CEIL 1
13111 _ACEOF
13112
13113 fi
13114
13115 echo "$as_me:$LINENO: checking for ceill in -lm" >&5
13116 echo $ECHO_N "checking for ceill in -lm... $ECHO_C" >&6
13117 if test "${ac_cv_lib_m_ceill+set}" = set; then
13118   echo $ECHO_N "(cached) $ECHO_C" >&6
13119 else
13120   ac_check_lib_save_LIBS=$LIBS
13121 LIBS="-lm  $LIBS"
13122 if test x$gcc_no_link = xyes; then
13123   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13124 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13125    { (exit 1); exit 1; }; }
13126 fi
13127 cat >conftest.$ac_ext <<_ACEOF
13128 /* confdefs.h.  */
13129 _ACEOF
13130 cat confdefs.h >>conftest.$ac_ext
13131 cat >>conftest.$ac_ext <<_ACEOF
13132 /* end confdefs.h.  */
13133
13134 /* Override any gcc2 internal prototype to avoid an error.  */
13135 #ifdef __cplusplus
13136 extern "C"
13137 #endif
13138 /* We use char because int might match the return type of a gcc2
13139    builtin and then its argument prototype would still apply.  */
13140 char ceill ();
13141 int
13142 main ()
13143 {
13144 ceill ();
13145   ;
13146   return 0;
13147 }
13148 _ACEOF
13149 rm -f conftest.$ac_objext conftest$ac_exeext
13150 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13151   (eval $ac_link) 2>conftest.er1
13152   ac_status=$?
13153   grep -v '^ *+' conftest.er1 >conftest.err
13154   rm -f conftest.er1
13155   cat conftest.err >&5
13156   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13157   (exit $ac_status); } &&
13158          { ac_try='test -z "$ac_c_werror_flag"
13159                          || test ! -s conftest.err'
13160   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13161   (eval $ac_try) 2>&5
13162   ac_status=$?
13163   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13164   (exit $ac_status); }; } &&
13165          { ac_try='test -s conftest$ac_exeext'
13166   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13167   (eval $ac_try) 2>&5
13168   ac_status=$?
13169   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13170   (exit $ac_status); }; }; then
13171   ac_cv_lib_m_ceill=yes
13172 else
13173   echo "$as_me: failed program was:" >&5
13174 sed 's/^/| /' conftest.$ac_ext >&5
13175
13176 ac_cv_lib_m_ceill=no
13177 fi
13178 rm -f conftest.err conftest.$ac_objext \
13179       conftest$ac_exeext conftest.$ac_ext
13180 LIBS=$ac_check_lib_save_LIBS
13181 fi
13182 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceill" >&5
13183 echo "${ECHO_T}$ac_cv_lib_m_ceill" >&6
13184 if test $ac_cv_lib_m_ceill = yes; then
13185
13186 cat >>confdefs.h <<\_ACEOF
13187 #define HAVE_CEILL 1
13188 _ACEOF
13189
13190 fi
13191
13192 echo "$as_me:$LINENO: checking for copysignf in -lm" >&5
13193 echo $ECHO_N "checking for copysignf in -lm... $ECHO_C" >&6
13194 if test "${ac_cv_lib_m_copysignf+set}" = set; then
13195   echo $ECHO_N "(cached) $ECHO_C" >&6
13196 else
13197   ac_check_lib_save_LIBS=$LIBS
13198 LIBS="-lm  $LIBS"
13199 if test x$gcc_no_link = xyes; then
13200   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13201 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13202    { (exit 1); exit 1; }; }
13203 fi
13204 cat >conftest.$ac_ext <<_ACEOF
13205 /* confdefs.h.  */
13206 _ACEOF
13207 cat confdefs.h >>conftest.$ac_ext
13208 cat >>conftest.$ac_ext <<_ACEOF
13209 /* end confdefs.h.  */
13210
13211 /* Override any gcc2 internal prototype to avoid an error.  */
13212 #ifdef __cplusplus
13213 extern "C"
13214 #endif
13215 /* We use char because int might match the return type of a gcc2
13216    builtin and then its argument prototype would still apply.  */
13217 char copysignf ();
13218 int
13219 main ()
13220 {
13221 copysignf ();
13222   ;
13223   return 0;
13224 }
13225 _ACEOF
13226 rm -f conftest.$ac_objext conftest$ac_exeext
13227 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13228   (eval $ac_link) 2>conftest.er1
13229   ac_status=$?
13230   grep -v '^ *+' conftest.er1 >conftest.err
13231   rm -f conftest.er1
13232   cat conftest.err >&5
13233   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13234   (exit $ac_status); } &&
13235          { ac_try='test -z "$ac_c_werror_flag"
13236                          || test ! -s conftest.err'
13237   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13238   (eval $ac_try) 2>&5
13239   ac_status=$?
13240   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13241   (exit $ac_status); }; } &&
13242          { ac_try='test -s conftest$ac_exeext'
13243   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13244   (eval $ac_try) 2>&5
13245   ac_status=$?
13246   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13247   (exit $ac_status); }; }; then
13248   ac_cv_lib_m_copysignf=yes
13249 else
13250   echo "$as_me: failed program was:" >&5
13251 sed 's/^/| /' conftest.$ac_ext >&5
13252
13253 ac_cv_lib_m_copysignf=no
13254 fi
13255 rm -f conftest.err conftest.$ac_objext \
13256       conftest$ac_exeext conftest.$ac_ext
13257 LIBS=$ac_check_lib_save_LIBS
13258 fi
13259 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysignf" >&5
13260 echo "${ECHO_T}$ac_cv_lib_m_copysignf" >&6
13261 if test $ac_cv_lib_m_copysignf = yes; then
13262
13263 cat >>confdefs.h <<\_ACEOF
13264 #define HAVE_COPYSIGNF 1
13265 _ACEOF
13266
13267 fi
13268
13269 echo "$as_me:$LINENO: checking for copysign in -lm" >&5
13270 echo $ECHO_N "checking for copysign in -lm... $ECHO_C" >&6
13271 if test "${ac_cv_lib_m_copysign+set}" = set; then
13272   echo $ECHO_N "(cached) $ECHO_C" >&6
13273 else
13274   ac_check_lib_save_LIBS=$LIBS
13275 LIBS="-lm  $LIBS"
13276 if test x$gcc_no_link = xyes; then
13277   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13278 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13279    { (exit 1); exit 1; }; }
13280 fi
13281 cat >conftest.$ac_ext <<_ACEOF
13282 /* confdefs.h.  */
13283 _ACEOF
13284 cat confdefs.h >>conftest.$ac_ext
13285 cat >>conftest.$ac_ext <<_ACEOF
13286 /* end confdefs.h.  */
13287
13288 /* Override any gcc2 internal prototype to avoid an error.  */
13289 #ifdef __cplusplus
13290 extern "C"
13291 #endif
13292 /* We use char because int might match the return type of a gcc2
13293    builtin and then its argument prototype would still apply.  */
13294 char copysign ();
13295 int
13296 main ()
13297 {
13298 copysign ();
13299   ;
13300   return 0;
13301 }
13302 _ACEOF
13303 rm -f conftest.$ac_objext conftest$ac_exeext
13304 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13305   (eval $ac_link) 2>conftest.er1
13306   ac_status=$?
13307   grep -v '^ *+' conftest.er1 >conftest.err
13308   rm -f conftest.er1
13309   cat conftest.err >&5
13310   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13311   (exit $ac_status); } &&
13312          { ac_try='test -z "$ac_c_werror_flag"
13313                          || test ! -s conftest.err'
13314   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13315   (eval $ac_try) 2>&5
13316   ac_status=$?
13317   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13318   (exit $ac_status); }; } &&
13319          { ac_try='test -s conftest$ac_exeext'
13320   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13321   (eval $ac_try) 2>&5
13322   ac_status=$?
13323   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13324   (exit $ac_status); }; }; then
13325   ac_cv_lib_m_copysign=yes
13326 else
13327   echo "$as_me: failed program was:" >&5
13328 sed 's/^/| /' conftest.$ac_ext >&5
13329
13330 ac_cv_lib_m_copysign=no
13331 fi
13332 rm -f conftest.err conftest.$ac_objext \
13333       conftest$ac_exeext conftest.$ac_ext
13334 LIBS=$ac_check_lib_save_LIBS
13335 fi
13336 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysign" >&5
13337 echo "${ECHO_T}$ac_cv_lib_m_copysign" >&6
13338 if test $ac_cv_lib_m_copysign = yes; then
13339
13340 cat >>confdefs.h <<\_ACEOF
13341 #define HAVE_COPYSIGN 1
13342 _ACEOF
13343
13344 fi
13345
13346 echo "$as_me:$LINENO: checking for copysignl in -lm" >&5
13347 echo $ECHO_N "checking for copysignl in -lm... $ECHO_C" >&6
13348 if test "${ac_cv_lib_m_copysignl+set}" = set; then
13349   echo $ECHO_N "(cached) $ECHO_C" >&6
13350 else
13351   ac_check_lib_save_LIBS=$LIBS
13352 LIBS="-lm  $LIBS"
13353 if test x$gcc_no_link = xyes; then
13354   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13355 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13356    { (exit 1); exit 1; }; }
13357 fi
13358 cat >conftest.$ac_ext <<_ACEOF
13359 /* confdefs.h.  */
13360 _ACEOF
13361 cat confdefs.h >>conftest.$ac_ext
13362 cat >>conftest.$ac_ext <<_ACEOF
13363 /* end confdefs.h.  */
13364
13365 /* Override any gcc2 internal prototype to avoid an error.  */
13366 #ifdef __cplusplus
13367 extern "C"
13368 #endif
13369 /* We use char because int might match the return type of a gcc2
13370    builtin and then its argument prototype would still apply.  */
13371 char copysignl ();
13372 int
13373 main ()
13374 {
13375 copysignl ();
13376   ;
13377   return 0;
13378 }
13379 _ACEOF
13380 rm -f conftest.$ac_objext conftest$ac_exeext
13381 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13382   (eval $ac_link) 2>conftest.er1
13383   ac_status=$?
13384   grep -v '^ *+' conftest.er1 >conftest.err
13385   rm -f conftest.er1
13386   cat conftest.err >&5
13387   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13388   (exit $ac_status); } &&
13389          { ac_try='test -z "$ac_c_werror_flag"
13390                          || test ! -s conftest.err'
13391   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13392   (eval $ac_try) 2>&5
13393   ac_status=$?
13394   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13395   (exit $ac_status); }; } &&
13396          { ac_try='test -s conftest$ac_exeext'
13397   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13398   (eval $ac_try) 2>&5
13399   ac_status=$?
13400   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13401   (exit $ac_status); }; }; then
13402   ac_cv_lib_m_copysignl=yes
13403 else
13404   echo "$as_me: failed program was:" >&5
13405 sed 's/^/| /' conftest.$ac_ext >&5
13406
13407 ac_cv_lib_m_copysignl=no
13408 fi
13409 rm -f conftest.err conftest.$ac_objext \
13410       conftest$ac_exeext conftest.$ac_ext
13411 LIBS=$ac_check_lib_save_LIBS
13412 fi
13413 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysignl" >&5
13414 echo "${ECHO_T}$ac_cv_lib_m_copysignl" >&6
13415 if test $ac_cv_lib_m_copysignl = yes; then
13416
13417 cat >>confdefs.h <<\_ACEOF
13418 #define HAVE_COPYSIGNL 1
13419 _ACEOF
13420
13421 fi
13422
13423 echo "$as_me:$LINENO: checking for cosf in -lm" >&5
13424 echo $ECHO_N "checking for cosf in -lm... $ECHO_C" >&6
13425 if test "${ac_cv_lib_m_cosf+set}" = set; then
13426   echo $ECHO_N "(cached) $ECHO_C" >&6
13427 else
13428   ac_check_lib_save_LIBS=$LIBS
13429 LIBS="-lm  $LIBS"
13430 if test x$gcc_no_link = xyes; then
13431   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13432 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13433    { (exit 1); exit 1; }; }
13434 fi
13435 cat >conftest.$ac_ext <<_ACEOF
13436 /* confdefs.h.  */
13437 _ACEOF
13438 cat confdefs.h >>conftest.$ac_ext
13439 cat >>conftest.$ac_ext <<_ACEOF
13440 /* end confdefs.h.  */
13441
13442 /* Override any gcc2 internal prototype to avoid an error.  */
13443 #ifdef __cplusplus
13444 extern "C"
13445 #endif
13446 /* We use char because int might match the return type of a gcc2
13447    builtin and then its argument prototype would still apply.  */
13448 char cosf ();
13449 int
13450 main ()
13451 {
13452 cosf ();
13453   ;
13454   return 0;
13455 }
13456 _ACEOF
13457 rm -f conftest.$ac_objext conftest$ac_exeext
13458 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13459   (eval $ac_link) 2>conftest.er1
13460   ac_status=$?
13461   grep -v '^ *+' conftest.er1 >conftest.err
13462   rm -f conftest.er1
13463   cat conftest.err >&5
13464   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13465   (exit $ac_status); } &&
13466          { ac_try='test -z "$ac_c_werror_flag"
13467                          || test ! -s conftest.err'
13468   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13469   (eval $ac_try) 2>&5
13470   ac_status=$?
13471   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13472   (exit $ac_status); }; } &&
13473          { ac_try='test -s conftest$ac_exeext'
13474   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13475   (eval $ac_try) 2>&5
13476   ac_status=$?
13477   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13478   (exit $ac_status); }; }; then
13479   ac_cv_lib_m_cosf=yes
13480 else
13481   echo "$as_me: failed program was:" >&5
13482 sed 's/^/| /' conftest.$ac_ext >&5
13483
13484 ac_cv_lib_m_cosf=no
13485 fi
13486 rm -f conftest.err conftest.$ac_objext \
13487       conftest$ac_exeext conftest.$ac_ext
13488 LIBS=$ac_check_lib_save_LIBS
13489 fi
13490 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosf" >&5
13491 echo "${ECHO_T}$ac_cv_lib_m_cosf" >&6
13492 if test $ac_cv_lib_m_cosf = yes; then
13493
13494 cat >>confdefs.h <<\_ACEOF
13495 #define HAVE_COSF 1
13496 _ACEOF
13497
13498 fi
13499
13500 echo "$as_me:$LINENO: checking for cos in -lm" >&5
13501 echo $ECHO_N "checking for cos in -lm... $ECHO_C" >&6
13502 if test "${ac_cv_lib_m_cos+set}" = set; then
13503   echo $ECHO_N "(cached) $ECHO_C" >&6
13504 else
13505   ac_check_lib_save_LIBS=$LIBS
13506 LIBS="-lm  $LIBS"
13507 if test x$gcc_no_link = xyes; then
13508   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13509 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13510    { (exit 1); exit 1; }; }
13511 fi
13512 cat >conftest.$ac_ext <<_ACEOF
13513 /* confdefs.h.  */
13514 _ACEOF
13515 cat confdefs.h >>conftest.$ac_ext
13516 cat >>conftest.$ac_ext <<_ACEOF
13517 /* end confdefs.h.  */
13518
13519 /* Override any gcc2 internal prototype to avoid an error.  */
13520 #ifdef __cplusplus
13521 extern "C"
13522 #endif
13523 /* We use char because int might match the return type of a gcc2
13524    builtin and then its argument prototype would still apply.  */
13525 char cos ();
13526 int
13527 main ()
13528 {
13529 cos ();
13530   ;
13531   return 0;
13532 }
13533 _ACEOF
13534 rm -f conftest.$ac_objext conftest$ac_exeext
13535 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13536   (eval $ac_link) 2>conftest.er1
13537   ac_status=$?
13538   grep -v '^ *+' conftest.er1 >conftest.err
13539   rm -f conftest.er1
13540   cat conftest.err >&5
13541   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13542   (exit $ac_status); } &&
13543          { ac_try='test -z "$ac_c_werror_flag"
13544                          || test ! -s conftest.err'
13545   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13546   (eval $ac_try) 2>&5
13547   ac_status=$?
13548   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13549   (exit $ac_status); }; } &&
13550          { ac_try='test -s conftest$ac_exeext'
13551   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13552   (eval $ac_try) 2>&5
13553   ac_status=$?
13554   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13555   (exit $ac_status); }; }; then
13556   ac_cv_lib_m_cos=yes
13557 else
13558   echo "$as_me: failed program was:" >&5
13559 sed 's/^/| /' conftest.$ac_ext >&5
13560
13561 ac_cv_lib_m_cos=no
13562 fi
13563 rm -f conftest.err conftest.$ac_objext \
13564       conftest$ac_exeext conftest.$ac_ext
13565 LIBS=$ac_check_lib_save_LIBS
13566 fi
13567 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cos" >&5
13568 echo "${ECHO_T}$ac_cv_lib_m_cos" >&6
13569 if test $ac_cv_lib_m_cos = yes; then
13570
13571 cat >>confdefs.h <<\_ACEOF
13572 #define HAVE_COS 1
13573 _ACEOF
13574
13575 fi
13576
13577 echo "$as_me:$LINENO: checking for cosl in -lm" >&5
13578 echo $ECHO_N "checking for cosl in -lm... $ECHO_C" >&6
13579 if test "${ac_cv_lib_m_cosl+set}" = set; then
13580   echo $ECHO_N "(cached) $ECHO_C" >&6
13581 else
13582   ac_check_lib_save_LIBS=$LIBS
13583 LIBS="-lm  $LIBS"
13584 if test x$gcc_no_link = xyes; then
13585   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13586 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13587    { (exit 1); exit 1; }; }
13588 fi
13589 cat >conftest.$ac_ext <<_ACEOF
13590 /* confdefs.h.  */
13591 _ACEOF
13592 cat confdefs.h >>conftest.$ac_ext
13593 cat >>conftest.$ac_ext <<_ACEOF
13594 /* end confdefs.h.  */
13595
13596 /* Override any gcc2 internal prototype to avoid an error.  */
13597 #ifdef __cplusplus
13598 extern "C"
13599 #endif
13600 /* We use char because int might match the return type of a gcc2
13601    builtin and then its argument prototype would still apply.  */
13602 char cosl ();
13603 int
13604 main ()
13605 {
13606 cosl ();
13607   ;
13608   return 0;
13609 }
13610 _ACEOF
13611 rm -f conftest.$ac_objext conftest$ac_exeext
13612 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13613   (eval $ac_link) 2>conftest.er1
13614   ac_status=$?
13615   grep -v '^ *+' conftest.er1 >conftest.err
13616   rm -f conftest.er1
13617   cat conftest.err >&5
13618   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13619   (exit $ac_status); } &&
13620          { ac_try='test -z "$ac_c_werror_flag"
13621                          || test ! -s conftest.err'
13622   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13623   (eval $ac_try) 2>&5
13624   ac_status=$?
13625   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13626   (exit $ac_status); }; } &&
13627          { ac_try='test -s conftest$ac_exeext'
13628   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13629   (eval $ac_try) 2>&5
13630   ac_status=$?
13631   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13632   (exit $ac_status); }; }; then
13633   ac_cv_lib_m_cosl=yes
13634 else
13635   echo "$as_me: failed program was:" >&5
13636 sed 's/^/| /' conftest.$ac_ext >&5
13637
13638 ac_cv_lib_m_cosl=no
13639 fi
13640 rm -f conftest.err conftest.$ac_objext \
13641       conftest$ac_exeext conftest.$ac_ext
13642 LIBS=$ac_check_lib_save_LIBS
13643 fi
13644 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosl" >&5
13645 echo "${ECHO_T}$ac_cv_lib_m_cosl" >&6
13646 if test $ac_cv_lib_m_cosl = yes; then
13647
13648 cat >>confdefs.h <<\_ACEOF
13649 #define HAVE_COSL 1
13650 _ACEOF
13651
13652 fi
13653
13654 echo "$as_me:$LINENO: checking for ccosf in -lm" >&5
13655 echo $ECHO_N "checking for ccosf in -lm... $ECHO_C" >&6
13656 if test "${ac_cv_lib_m_ccosf+set}" = set; then
13657   echo $ECHO_N "(cached) $ECHO_C" >&6
13658 else
13659   ac_check_lib_save_LIBS=$LIBS
13660 LIBS="-lm  $LIBS"
13661 if test x$gcc_no_link = xyes; then
13662   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13663 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13664    { (exit 1); exit 1; }; }
13665 fi
13666 cat >conftest.$ac_ext <<_ACEOF
13667 /* confdefs.h.  */
13668 _ACEOF
13669 cat confdefs.h >>conftest.$ac_ext
13670 cat >>conftest.$ac_ext <<_ACEOF
13671 /* end confdefs.h.  */
13672
13673 /* Override any gcc2 internal prototype to avoid an error.  */
13674 #ifdef __cplusplus
13675 extern "C"
13676 #endif
13677 /* We use char because int might match the return type of a gcc2
13678    builtin and then its argument prototype would still apply.  */
13679 char ccosf ();
13680 int
13681 main ()
13682 {
13683 ccosf ();
13684   ;
13685   return 0;
13686 }
13687 _ACEOF
13688 rm -f conftest.$ac_objext conftest$ac_exeext
13689 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13690   (eval $ac_link) 2>conftest.er1
13691   ac_status=$?
13692   grep -v '^ *+' conftest.er1 >conftest.err
13693   rm -f conftest.er1
13694   cat conftest.err >&5
13695   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13696   (exit $ac_status); } &&
13697          { ac_try='test -z "$ac_c_werror_flag"
13698                          || test ! -s conftest.err'
13699   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13700   (eval $ac_try) 2>&5
13701   ac_status=$?
13702   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13703   (exit $ac_status); }; } &&
13704          { ac_try='test -s conftest$ac_exeext'
13705   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13706   (eval $ac_try) 2>&5
13707   ac_status=$?
13708   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13709   (exit $ac_status); }; }; then
13710   ac_cv_lib_m_ccosf=yes
13711 else
13712   echo "$as_me: failed program was:" >&5
13713 sed 's/^/| /' conftest.$ac_ext >&5
13714
13715 ac_cv_lib_m_ccosf=no
13716 fi
13717 rm -f conftest.err conftest.$ac_objext \
13718       conftest$ac_exeext conftest.$ac_ext
13719 LIBS=$ac_check_lib_save_LIBS
13720 fi
13721 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosf" >&5
13722 echo "${ECHO_T}$ac_cv_lib_m_ccosf" >&6
13723 if test $ac_cv_lib_m_ccosf = yes; then
13724
13725 cat >>confdefs.h <<\_ACEOF
13726 #define HAVE_CCOSF 1
13727 _ACEOF
13728
13729 fi
13730
13731 echo "$as_me:$LINENO: checking for ccos in -lm" >&5
13732 echo $ECHO_N "checking for ccos in -lm... $ECHO_C" >&6
13733 if test "${ac_cv_lib_m_ccos+set}" = set; then
13734   echo $ECHO_N "(cached) $ECHO_C" >&6
13735 else
13736   ac_check_lib_save_LIBS=$LIBS
13737 LIBS="-lm  $LIBS"
13738 if test x$gcc_no_link = xyes; then
13739   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13740 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13741    { (exit 1); exit 1; }; }
13742 fi
13743 cat >conftest.$ac_ext <<_ACEOF
13744 /* confdefs.h.  */
13745 _ACEOF
13746 cat confdefs.h >>conftest.$ac_ext
13747 cat >>conftest.$ac_ext <<_ACEOF
13748 /* end confdefs.h.  */
13749
13750 /* Override any gcc2 internal prototype to avoid an error.  */
13751 #ifdef __cplusplus
13752 extern "C"
13753 #endif
13754 /* We use char because int might match the return type of a gcc2
13755    builtin and then its argument prototype would still apply.  */
13756 char ccos ();
13757 int
13758 main ()
13759 {
13760 ccos ();
13761   ;
13762   return 0;
13763 }
13764 _ACEOF
13765 rm -f conftest.$ac_objext conftest$ac_exeext
13766 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13767   (eval $ac_link) 2>conftest.er1
13768   ac_status=$?
13769   grep -v '^ *+' conftest.er1 >conftest.err
13770   rm -f conftest.er1
13771   cat conftest.err >&5
13772   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13773   (exit $ac_status); } &&
13774          { ac_try='test -z "$ac_c_werror_flag"
13775                          || test ! -s conftest.err'
13776   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13777   (eval $ac_try) 2>&5
13778   ac_status=$?
13779   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13780   (exit $ac_status); }; } &&
13781          { ac_try='test -s conftest$ac_exeext'
13782   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13783   (eval $ac_try) 2>&5
13784   ac_status=$?
13785   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13786   (exit $ac_status); }; }; then
13787   ac_cv_lib_m_ccos=yes
13788 else
13789   echo "$as_me: failed program was:" >&5
13790 sed 's/^/| /' conftest.$ac_ext >&5
13791
13792 ac_cv_lib_m_ccos=no
13793 fi
13794 rm -f conftest.err conftest.$ac_objext \
13795       conftest$ac_exeext conftest.$ac_ext
13796 LIBS=$ac_check_lib_save_LIBS
13797 fi
13798 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccos" >&5
13799 echo "${ECHO_T}$ac_cv_lib_m_ccos" >&6
13800 if test $ac_cv_lib_m_ccos = yes; then
13801
13802 cat >>confdefs.h <<\_ACEOF
13803 #define HAVE_CCOS 1
13804 _ACEOF
13805
13806 fi
13807
13808 echo "$as_me:$LINENO: checking for ccosl in -lm" >&5
13809 echo $ECHO_N "checking for ccosl in -lm... $ECHO_C" >&6
13810 if test "${ac_cv_lib_m_ccosl+set}" = set; then
13811   echo $ECHO_N "(cached) $ECHO_C" >&6
13812 else
13813   ac_check_lib_save_LIBS=$LIBS
13814 LIBS="-lm  $LIBS"
13815 if test x$gcc_no_link = xyes; then
13816   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13817 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13818    { (exit 1); exit 1; }; }
13819 fi
13820 cat >conftest.$ac_ext <<_ACEOF
13821 /* confdefs.h.  */
13822 _ACEOF
13823 cat confdefs.h >>conftest.$ac_ext
13824 cat >>conftest.$ac_ext <<_ACEOF
13825 /* end confdefs.h.  */
13826
13827 /* Override any gcc2 internal prototype to avoid an error.  */
13828 #ifdef __cplusplus
13829 extern "C"
13830 #endif
13831 /* We use char because int might match the return type of a gcc2
13832    builtin and then its argument prototype would still apply.  */
13833 char ccosl ();
13834 int
13835 main ()
13836 {
13837 ccosl ();
13838   ;
13839   return 0;
13840 }
13841 _ACEOF
13842 rm -f conftest.$ac_objext conftest$ac_exeext
13843 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13844   (eval $ac_link) 2>conftest.er1
13845   ac_status=$?
13846   grep -v '^ *+' conftest.er1 >conftest.err
13847   rm -f conftest.er1
13848   cat conftest.err >&5
13849   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13850   (exit $ac_status); } &&
13851          { ac_try='test -z "$ac_c_werror_flag"
13852                          || test ! -s conftest.err'
13853   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13854   (eval $ac_try) 2>&5
13855   ac_status=$?
13856   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13857   (exit $ac_status); }; } &&
13858          { ac_try='test -s conftest$ac_exeext'
13859   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13860   (eval $ac_try) 2>&5
13861   ac_status=$?
13862   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13863   (exit $ac_status); }; }; then
13864   ac_cv_lib_m_ccosl=yes
13865 else
13866   echo "$as_me: failed program was:" >&5
13867 sed 's/^/| /' conftest.$ac_ext >&5
13868
13869 ac_cv_lib_m_ccosl=no
13870 fi
13871 rm -f conftest.err conftest.$ac_objext \
13872       conftest$ac_exeext conftest.$ac_ext
13873 LIBS=$ac_check_lib_save_LIBS
13874 fi
13875 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosl" >&5
13876 echo "${ECHO_T}$ac_cv_lib_m_ccosl" >&6
13877 if test $ac_cv_lib_m_ccosl = yes; then
13878
13879 cat >>confdefs.h <<\_ACEOF
13880 #define HAVE_CCOSL 1
13881 _ACEOF
13882
13883 fi
13884
13885 echo "$as_me:$LINENO: checking for coshf in -lm" >&5
13886 echo $ECHO_N "checking for coshf in -lm... $ECHO_C" >&6
13887 if test "${ac_cv_lib_m_coshf+set}" = set; then
13888   echo $ECHO_N "(cached) $ECHO_C" >&6
13889 else
13890   ac_check_lib_save_LIBS=$LIBS
13891 LIBS="-lm  $LIBS"
13892 if test x$gcc_no_link = xyes; then
13893   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13894 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13895    { (exit 1); exit 1; }; }
13896 fi
13897 cat >conftest.$ac_ext <<_ACEOF
13898 /* confdefs.h.  */
13899 _ACEOF
13900 cat confdefs.h >>conftest.$ac_ext
13901 cat >>conftest.$ac_ext <<_ACEOF
13902 /* end confdefs.h.  */
13903
13904 /* Override any gcc2 internal prototype to avoid an error.  */
13905 #ifdef __cplusplus
13906 extern "C"
13907 #endif
13908 /* We use char because int might match the return type of a gcc2
13909    builtin and then its argument prototype would still apply.  */
13910 char coshf ();
13911 int
13912 main ()
13913 {
13914 coshf ();
13915   ;
13916   return 0;
13917 }
13918 _ACEOF
13919 rm -f conftest.$ac_objext conftest$ac_exeext
13920 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13921   (eval $ac_link) 2>conftest.er1
13922   ac_status=$?
13923   grep -v '^ *+' conftest.er1 >conftest.err
13924   rm -f conftest.er1
13925   cat conftest.err >&5
13926   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13927   (exit $ac_status); } &&
13928          { ac_try='test -z "$ac_c_werror_flag"
13929                          || test ! -s conftest.err'
13930   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13931   (eval $ac_try) 2>&5
13932   ac_status=$?
13933   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13934   (exit $ac_status); }; } &&
13935          { ac_try='test -s conftest$ac_exeext'
13936   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13937   (eval $ac_try) 2>&5
13938   ac_status=$?
13939   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13940   (exit $ac_status); }; }; then
13941   ac_cv_lib_m_coshf=yes
13942 else
13943   echo "$as_me: failed program was:" >&5
13944 sed 's/^/| /' conftest.$ac_ext >&5
13945
13946 ac_cv_lib_m_coshf=no
13947 fi
13948 rm -f conftest.err conftest.$ac_objext \
13949       conftest$ac_exeext conftest.$ac_ext
13950 LIBS=$ac_check_lib_save_LIBS
13951 fi
13952 echo "$as_me:$LINENO: result: $ac_cv_lib_m_coshf" >&5
13953 echo "${ECHO_T}$ac_cv_lib_m_coshf" >&6
13954 if test $ac_cv_lib_m_coshf = yes; then
13955
13956 cat >>confdefs.h <<\_ACEOF
13957 #define HAVE_COSHF 1
13958 _ACEOF
13959
13960 fi
13961
13962 echo "$as_me:$LINENO: checking for cosh in -lm" >&5
13963 echo $ECHO_N "checking for cosh in -lm... $ECHO_C" >&6
13964 if test "${ac_cv_lib_m_cosh+set}" = set; then
13965   echo $ECHO_N "(cached) $ECHO_C" >&6
13966 else
13967   ac_check_lib_save_LIBS=$LIBS
13968 LIBS="-lm  $LIBS"
13969 if test x$gcc_no_link = xyes; then
13970   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13971 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13972    { (exit 1); exit 1; }; }
13973 fi
13974 cat >conftest.$ac_ext <<_ACEOF
13975 /* confdefs.h.  */
13976 _ACEOF
13977 cat confdefs.h >>conftest.$ac_ext
13978 cat >>conftest.$ac_ext <<_ACEOF
13979 /* end confdefs.h.  */
13980
13981 /* Override any gcc2 internal prototype to avoid an error.  */
13982 #ifdef __cplusplus
13983 extern "C"
13984 #endif
13985 /* We use char because int might match the return type of a gcc2
13986    builtin and then its argument prototype would still apply.  */
13987 char cosh ();
13988 int
13989 main ()
13990 {
13991 cosh ();
13992   ;
13993   return 0;
13994 }
13995 _ACEOF
13996 rm -f conftest.$ac_objext conftest$ac_exeext
13997 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13998   (eval $ac_link) 2>conftest.er1
13999   ac_status=$?
14000   grep -v '^ *+' conftest.er1 >conftest.err
14001   rm -f conftest.er1
14002   cat conftest.err >&5
14003   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14004   (exit $ac_status); } &&
14005          { ac_try='test -z "$ac_c_werror_flag"
14006                          || test ! -s conftest.err'
14007   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14008   (eval $ac_try) 2>&5
14009   ac_status=$?
14010   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14011   (exit $ac_status); }; } &&
14012          { ac_try='test -s conftest$ac_exeext'
14013   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14014   (eval $ac_try) 2>&5
14015   ac_status=$?
14016   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14017   (exit $ac_status); }; }; then
14018   ac_cv_lib_m_cosh=yes
14019 else
14020   echo "$as_me: failed program was:" >&5
14021 sed 's/^/| /' conftest.$ac_ext >&5
14022
14023 ac_cv_lib_m_cosh=no
14024 fi
14025 rm -f conftest.err conftest.$ac_objext \
14026       conftest$ac_exeext conftest.$ac_ext
14027 LIBS=$ac_check_lib_save_LIBS
14028 fi
14029 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosh" >&5
14030 echo "${ECHO_T}$ac_cv_lib_m_cosh" >&6
14031 if test $ac_cv_lib_m_cosh = yes; then
14032
14033 cat >>confdefs.h <<\_ACEOF
14034 #define HAVE_COSH 1
14035 _ACEOF
14036
14037 fi
14038
14039 echo "$as_me:$LINENO: checking for coshl in -lm" >&5
14040 echo $ECHO_N "checking for coshl in -lm... $ECHO_C" >&6
14041 if test "${ac_cv_lib_m_coshl+set}" = set; then
14042   echo $ECHO_N "(cached) $ECHO_C" >&6
14043 else
14044   ac_check_lib_save_LIBS=$LIBS
14045 LIBS="-lm  $LIBS"
14046 if test x$gcc_no_link = xyes; then
14047   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14048 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14049    { (exit 1); exit 1; }; }
14050 fi
14051 cat >conftest.$ac_ext <<_ACEOF
14052 /* confdefs.h.  */
14053 _ACEOF
14054 cat confdefs.h >>conftest.$ac_ext
14055 cat >>conftest.$ac_ext <<_ACEOF
14056 /* end confdefs.h.  */
14057
14058 /* Override any gcc2 internal prototype to avoid an error.  */
14059 #ifdef __cplusplus
14060 extern "C"
14061 #endif
14062 /* We use char because int might match the return type of a gcc2
14063    builtin and then its argument prototype would still apply.  */
14064 char coshl ();
14065 int
14066 main ()
14067 {
14068 coshl ();
14069   ;
14070   return 0;
14071 }
14072 _ACEOF
14073 rm -f conftest.$ac_objext conftest$ac_exeext
14074 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14075   (eval $ac_link) 2>conftest.er1
14076   ac_status=$?
14077   grep -v '^ *+' conftest.er1 >conftest.err
14078   rm -f conftest.er1
14079   cat conftest.err >&5
14080   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14081   (exit $ac_status); } &&
14082          { ac_try='test -z "$ac_c_werror_flag"
14083                          || test ! -s conftest.err'
14084   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14085   (eval $ac_try) 2>&5
14086   ac_status=$?
14087   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14088   (exit $ac_status); }; } &&
14089          { ac_try='test -s conftest$ac_exeext'
14090   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14091   (eval $ac_try) 2>&5
14092   ac_status=$?
14093   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14094   (exit $ac_status); }; }; then
14095   ac_cv_lib_m_coshl=yes
14096 else
14097   echo "$as_me: failed program was:" >&5
14098 sed 's/^/| /' conftest.$ac_ext >&5
14099
14100 ac_cv_lib_m_coshl=no
14101 fi
14102 rm -f conftest.err conftest.$ac_objext \
14103       conftest$ac_exeext conftest.$ac_ext
14104 LIBS=$ac_check_lib_save_LIBS
14105 fi
14106 echo "$as_me:$LINENO: result: $ac_cv_lib_m_coshl" >&5
14107 echo "${ECHO_T}$ac_cv_lib_m_coshl" >&6
14108 if test $ac_cv_lib_m_coshl = yes; then
14109
14110 cat >>confdefs.h <<\_ACEOF
14111 #define HAVE_COSHL 1
14112 _ACEOF
14113
14114 fi
14115
14116 echo "$as_me:$LINENO: checking for ccoshf in -lm" >&5
14117 echo $ECHO_N "checking for ccoshf in -lm... $ECHO_C" >&6
14118 if test "${ac_cv_lib_m_ccoshf+set}" = set; then
14119   echo $ECHO_N "(cached) $ECHO_C" >&6
14120 else
14121   ac_check_lib_save_LIBS=$LIBS
14122 LIBS="-lm  $LIBS"
14123 if test x$gcc_no_link = xyes; then
14124   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14125 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14126    { (exit 1); exit 1; }; }
14127 fi
14128 cat >conftest.$ac_ext <<_ACEOF
14129 /* confdefs.h.  */
14130 _ACEOF
14131 cat confdefs.h >>conftest.$ac_ext
14132 cat >>conftest.$ac_ext <<_ACEOF
14133 /* end confdefs.h.  */
14134
14135 /* Override any gcc2 internal prototype to avoid an error.  */
14136 #ifdef __cplusplus
14137 extern "C"
14138 #endif
14139 /* We use char because int might match the return type of a gcc2
14140    builtin and then its argument prototype would still apply.  */
14141 char ccoshf ();
14142 int
14143 main ()
14144 {
14145 ccoshf ();
14146   ;
14147   return 0;
14148 }
14149 _ACEOF
14150 rm -f conftest.$ac_objext conftest$ac_exeext
14151 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14152   (eval $ac_link) 2>conftest.er1
14153   ac_status=$?
14154   grep -v '^ *+' conftest.er1 >conftest.err
14155   rm -f conftest.er1
14156   cat conftest.err >&5
14157   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14158   (exit $ac_status); } &&
14159          { ac_try='test -z "$ac_c_werror_flag"
14160                          || test ! -s conftest.err'
14161   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14162   (eval $ac_try) 2>&5
14163   ac_status=$?
14164   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14165   (exit $ac_status); }; } &&
14166          { ac_try='test -s conftest$ac_exeext'
14167   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14168   (eval $ac_try) 2>&5
14169   ac_status=$?
14170   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14171   (exit $ac_status); }; }; then
14172   ac_cv_lib_m_ccoshf=yes
14173 else
14174   echo "$as_me: failed program was:" >&5
14175 sed 's/^/| /' conftest.$ac_ext >&5
14176
14177 ac_cv_lib_m_ccoshf=no
14178 fi
14179 rm -f conftest.err conftest.$ac_objext \
14180       conftest$ac_exeext conftest.$ac_ext
14181 LIBS=$ac_check_lib_save_LIBS
14182 fi
14183 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccoshf" >&5
14184 echo "${ECHO_T}$ac_cv_lib_m_ccoshf" >&6
14185 if test $ac_cv_lib_m_ccoshf = yes; then
14186
14187 cat >>confdefs.h <<\_ACEOF
14188 #define HAVE_CCOSHF 1
14189 _ACEOF
14190
14191 fi
14192
14193 echo "$as_me:$LINENO: checking for ccosh in -lm" >&5
14194 echo $ECHO_N "checking for ccosh in -lm... $ECHO_C" >&6
14195 if test "${ac_cv_lib_m_ccosh+set}" = set; then
14196   echo $ECHO_N "(cached) $ECHO_C" >&6
14197 else
14198   ac_check_lib_save_LIBS=$LIBS
14199 LIBS="-lm  $LIBS"
14200 if test x$gcc_no_link = xyes; then
14201   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14202 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14203    { (exit 1); exit 1; }; }
14204 fi
14205 cat >conftest.$ac_ext <<_ACEOF
14206 /* confdefs.h.  */
14207 _ACEOF
14208 cat confdefs.h >>conftest.$ac_ext
14209 cat >>conftest.$ac_ext <<_ACEOF
14210 /* end confdefs.h.  */
14211
14212 /* Override any gcc2 internal prototype to avoid an error.  */
14213 #ifdef __cplusplus
14214 extern "C"
14215 #endif
14216 /* We use char because int might match the return type of a gcc2
14217    builtin and then its argument prototype would still apply.  */
14218 char ccosh ();
14219 int
14220 main ()
14221 {
14222 ccosh ();
14223   ;
14224   return 0;
14225 }
14226 _ACEOF
14227 rm -f conftest.$ac_objext conftest$ac_exeext
14228 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14229   (eval $ac_link) 2>conftest.er1
14230   ac_status=$?
14231   grep -v '^ *+' conftest.er1 >conftest.err
14232   rm -f conftest.er1
14233   cat conftest.err >&5
14234   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14235   (exit $ac_status); } &&
14236          { ac_try='test -z "$ac_c_werror_flag"
14237                          || test ! -s conftest.err'
14238   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14239   (eval $ac_try) 2>&5
14240   ac_status=$?
14241   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14242   (exit $ac_status); }; } &&
14243          { ac_try='test -s conftest$ac_exeext'
14244   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14245   (eval $ac_try) 2>&5
14246   ac_status=$?
14247   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14248   (exit $ac_status); }; }; then
14249   ac_cv_lib_m_ccosh=yes
14250 else
14251   echo "$as_me: failed program was:" >&5
14252 sed 's/^/| /' conftest.$ac_ext >&5
14253
14254 ac_cv_lib_m_ccosh=no
14255 fi
14256 rm -f conftest.err conftest.$ac_objext \
14257       conftest$ac_exeext conftest.$ac_ext
14258 LIBS=$ac_check_lib_save_LIBS
14259 fi
14260 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosh" >&5
14261 echo "${ECHO_T}$ac_cv_lib_m_ccosh" >&6
14262 if test $ac_cv_lib_m_ccosh = yes; then
14263
14264 cat >>confdefs.h <<\_ACEOF
14265 #define HAVE_CCOSH 1
14266 _ACEOF
14267
14268 fi
14269
14270 echo "$as_me:$LINENO: checking for ccoshl in -lm" >&5
14271 echo $ECHO_N "checking for ccoshl in -lm... $ECHO_C" >&6
14272 if test "${ac_cv_lib_m_ccoshl+set}" = set; then
14273   echo $ECHO_N "(cached) $ECHO_C" >&6
14274 else
14275   ac_check_lib_save_LIBS=$LIBS
14276 LIBS="-lm  $LIBS"
14277 if test x$gcc_no_link = xyes; then
14278   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14279 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14280    { (exit 1); exit 1; }; }
14281 fi
14282 cat >conftest.$ac_ext <<_ACEOF
14283 /* confdefs.h.  */
14284 _ACEOF
14285 cat confdefs.h >>conftest.$ac_ext
14286 cat >>conftest.$ac_ext <<_ACEOF
14287 /* end confdefs.h.  */
14288
14289 /* Override any gcc2 internal prototype to avoid an error.  */
14290 #ifdef __cplusplus
14291 extern "C"
14292 #endif
14293 /* We use char because int might match the return type of a gcc2
14294    builtin and then its argument prototype would still apply.  */
14295 char ccoshl ();
14296 int
14297 main ()
14298 {
14299 ccoshl ();
14300   ;
14301   return 0;
14302 }
14303 _ACEOF
14304 rm -f conftest.$ac_objext conftest$ac_exeext
14305 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14306   (eval $ac_link) 2>conftest.er1
14307   ac_status=$?
14308   grep -v '^ *+' conftest.er1 >conftest.err
14309   rm -f conftest.er1
14310   cat conftest.err >&5
14311   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14312   (exit $ac_status); } &&
14313          { ac_try='test -z "$ac_c_werror_flag"
14314                          || test ! -s conftest.err'
14315   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14316   (eval $ac_try) 2>&5
14317   ac_status=$?
14318   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14319   (exit $ac_status); }; } &&
14320          { ac_try='test -s conftest$ac_exeext'
14321   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14322   (eval $ac_try) 2>&5
14323   ac_status=$?
14324   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14325   (exit $ac_status); }; }; then
14326   ac_cv_lib_m_ccoshl=yes
14327 else
14328   echo "$as_me: failed program was:" >&5
14329 sed 's/^/| /' conftest.$ac_ext >&5
14330
14331 ac_cv_lib_m_ccoshl=no
14332 fi
14333 rm -f conftest.err conftest.$ac_objext \
14334       conftest$ac_exeext conftest.$ac_ext
14335 LIBS=$ac_check_lib_save_LIBS
14336 fi
14337 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccoshl" >&5
14338 echo "${ECHO_T}$ac_cv_lib_m_ccoshl" >&6
14339 if test $ac_cv_lib_m_ccoshl = yes; then
14340
14341 cat >>confdefs.h <<\_ACEOF
14342 #define HAVE_CCOSHL 1
14343 _ACEOF
14344
14345 fi
14346
14347 echo "$as_me:$LINENO: checking for expf in -lm" >&5
14348 echo $ECHO_N "checking for expf in -lm... $ECHO_C" >&6
14349 if test "${ac_cv_lib_m_expf+set}" = set; then
14350   echo $ECHO_N "(cached) $ECHO_C" >&6
14351 else
14352   ac_check_lib_save_LIBS=$LIBS
14353 LIBS="-lm  $LIBS"
14354 if test x$gcc_no_link = xyes; then
14355   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14356 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14357    { (exit 1); exit 1; }; }
14358 fi
14359 cat >conftest.$ac_ext <<_ACEOF
14360 /* confdefs.h.  */
14361 _ACEOF
14362 cat confdefs.h >>conftest.$ac_ext
14363 cat >>conftest.$ac_ext <<_ACEOF
14364 /* end confdefs.h.  */
14365
14366 /* Override any gcc2 internal prototype to avoid an error.  */
14367 #ifdef __cplusplus
14368 extern "C"
14369 #endif
14370 /* We use char because int might match the return type of a gcc2
14371    builtin and then its argument prototype would still apply.  */
14372 char expf ();
14373 int
14374 main ()
14375 {
14376 expf ();
14377   ;
14378   return 0;
14379 }
14380 _ACEOF
14381 rm -f conftest.$ac_objext conftest$ac_exeext
14382 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14383   (eval $ac_link) 2>conftest.er1
14384   ac_status=$?
14385   grep -v '^ *+' conftest.er1 >conftest.err
14386   rm -f conftest.er1
14387   cat conftest.err >&5
14388   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14389   (exit $ac_status); } &&
14390          { ac_try='test -z "$ac_c_werror_flag"
14391                          || test ! -s conftest.err'
14392   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14393   (eval $ac_try) 2>&5
14394   ac_status=$?
14395   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14396   (exit $ac_status); }; } &&
14397          { ac_try='test -s conftest$ac_exeext'
14398   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14399   (eval $ac_try) 2>&5
14400   ac_status=$?
14401   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14402   (exit $ac_status); }; }; then
14403   ac_cv_lib_m_expf=yes
14404 else
14405   echo "$as_me: failed program was:" >&5
14406 sed 's/^/| /' conftest.$ac_ext >&5
14407
14408 ac_cv_lib_m_expf=no
14409 fi
14410 rm -f conftest.err conftest.$ac_objext \
14411       conftest$ac_exeext conftest.$ac_ext
14412 LIBS=$ac_check_lib_save_LIBS
14413 fi
14414 echo "$as_me:$LINENO: result: $ac_cv_lib_m_expf" >&5
14415 echo "${ECHO_T}$ac_cv_lib_m_expf" >&6
14416 if test $ac_cv_lib_m_expf = yes; then
14417
14418 cat >>confdefs.h <<\_ACEOF
14419 #define HAVE_EXPF 1
14420 _ACEOF
14421
14422 fi
14423
14424 echo "$as_me:$LINENO: checking for exp in -lm" >&5
14425 echo $ECHO_N "checking for exp in -lm... $ECHO_C" >&6
14426 if test "${ac_cv_lib_m_exp+set}" = set; then
14427   echo $ECHO_N "(cached) $ECHO_C" >&6
14428 else
14429   ac_check_lib_save_LIBS=$LIBS
14430 LIBS="-lm  $LIBS"
14431 if test x$gcc_no_link = xyes; then
14432   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14433 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14434    { (exit 1); exit 1; }; }
14435 fi
14436 cat >conftest.$ac_ext <<_ACEOF
14437 /* confdefs.h.  */
14438 _ACEOF
14439 cat confdefs.h >>conftest.$ac_ext
14440 cat >>conftest.$ac_ext <<_ACEOF
14441 /* end confdefs.h.  */
14442
14443 /* Override any gcc2 internal prototype to avoid an error.  */
14444 #ifdef __cplusplus
14445 extern "C"
14446 #endif
14447 /* We use char because int might match the return type of a gcc2
14448    builtin and then its argument prototype would still apply.  */
14449 char exp ();
14450 int
14451 main ()
14452 {
14453 exp ();
14454   ;
14455   return 0;
14456 }
14457 _ACEOF
14458 rm -f conftest.$ac_objext conftest$ac_exeext
14459 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14460   (eval $ac_link) 2>conftest.er1
14461   ac_status=$?
14462   grep -v '^ *+' conftest.er1 >conftest.err
14463   rm -f conftest.er1
14464   cat conftest.err >&5
14465   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14466   (exit $ac_status); } &&
14467          { ac_try='test -z "$ac_c_werror_flag"
14468                          || test ! -s conftest.err'
14469   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14470   (eval $ac_try) 2>&5
14471   ac_status=$?
14472   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14473   (exit $ac_status); }; } &&
14474          { ac_try='test -s conftest$ac_exeext'
14475   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14476   (eval $ac_try) 2>&5
14477   ac_status=$?
14478   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14479   (exit $ac_status); }; }; then
14480   ac_cv_lib_m_exp=yes
14481 else
14482   echo "$as_me: failed program was:" >&5
14483 sed 's/^/| /' conftest.$ac_ext >&5
14484
14485 ac_cv_lib_m_exp=no
14486 fi
14487 rm -f conftest.err conftest.$ac_objext \
14488       conftest$ac_exeext conftest.$ac_ext
14489 LIBS=$ac_check_lib_save_LIBS
14490 fi
14491 echo "$as_me:$LINENO: result: $ac_cv_lib_m_exp" >&5
14492 echo "${ECHO_T}$ac_cv_lib_m_exp" >&6
14493 if test $ac_cv_lib_m_exp = yes; then
14494
14495 cat >>confdefs.h <<\_ACEOF
14496 #define HAVE_EXP 1
14497 _ACEOF
14498
14499 fi
14500
14501 echo "$as_me:$LINENO: checking for expl in -lm" >&5
14502 echo $ECHO_N "checking for expl in -lm... $ECHO_C" >&6
14503 if test "${ac_cv_lib_m_expl+set}" = set; then
14504   echo $ECHO_N "(cached) $ECHO_C" >&6
14505 else
14506   ac_check_lib_save_LIBS=$LIBS
14507 LIBS="-lm  $LIBS"
14508 if test x$gcc_no_link = xyes; then
14509   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14510 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14511    { (exit 1); exit 1; }; }
14512 fi
14513 cat >conftest.$ac_ext <<_ACEOF
14514 /* confdefs.h.  */
14515 _ACEOF
14516 cat confdefs.h >>conftest.$ac_ext
14517 cat >>conftest.$ac_ext <<_ACEOF
14518 /* end confdefs.h.  */
14519
14520 /* Override any gcc2 internal prototype to avoid an error.  */
14521 #ifdef __cplusplus
14522 extern "C"
14523 #endif
14524 /* We use char because int might match the return type of a gcc2
14525    builtin and then its argument prototype would still apply.  */
14526 char expl ();
14527 int
14528 main ()
14529 {
14530 expl ();
14531   ;
14532   return 0;
14533 }
14534 _ACEOF
14535 rm -f conftest.$ac_objext conftest$ac_exeext
14536 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14537   (eval $ac_link) 2>conftest.er1
14538   ac_status=$?
14539   grep -v '^ *+' conftest.er1 >conftest.err
14540   rm -f conftest.er1
14541   cat conftest.err >&5
14542   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14543   (exit $ac_status); } &&
14544          { ac_try='test -z "$ac_c_werror_flag"
14545                          || test ! -s conftest.err'
14546   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14547   (eval $ac_try) 2>&5
14548   ac_status=$?
14549   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14550   (exit $ac_status); }; } &&
14551          { ac_try='test -s conftest$ac_exeext'
14552   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14553   (eval $ac_try) 2>&5
14554   ac_status=$?
14555   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14556   (exit $ac_status); }; }; then
14557   ac_cv_lib_m_expl=yes
14558 else
14559   echo "$as_me: failed program was:" >&5
14560 sed 's/^/| /' conftest.$ac_ext >&5
14561
14562 ac_cv_lib_m_expl=no
14563 fi
14564 rm -f conftest.err conftest.$ac_objext \
14565       conftest$ac_exeext conftest.$ac_ext
14566 LIBS=$ac_check_lib_save_LIBS
14567 fi
14568 echo "$as_me:$LINENO: result: $ac_cv_lib_m_expl" >&5
14569 echo "${ECHO_T}$ac_cv_lib_m_expl" >&6
14570 if test $ac_cv_lib_m_expl = yes; then
14571
14572 cat >>confdefs.h <<\_ACEOF
14573 #define HAVE_EXPL 1
14574 _ACEOF
14575
14576 fi
14577
14578 echo "$as_me:$LINENO: checking for cexpf in -lm" >&5
14579 echo $ECHO_N "checking for cexpf in -lm... $ECHO_C" >&6
14580 if test "${ac_cv_lib_m_cexpf+set}" = set; then
14581   echo $ECHO_N "(cached) $ECHO_C" >&6
14582 else
14583   ac_check_lib_save_LIBS=$LIBS
14584 LIBS="-lm  $LIBS"
14585 if test x$gcc_no_link = xyes; then
14586   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14587 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14588    { (exit 1); exit 1; }; }
14589 fi
14590 cat >conftest.$ac_ext <<_ACEOF
14591 /* confdefs.h.  */
14592 _ACEOF
14593 cat confdefs.h >>conftest.$ac_ext
14594 cat >>conftest.$ac_ext <<_ACEOF
14595 /* end confdefs.h.  */
14596
14597 /* Override any gcc2 internal prototype to avoid an error.  */
14598 #ifdef __cplusplus
14599 extern "C"
14600 #endif
14601 /* We use char because int might match the return type of a gcc2
14602    builtin and then its argument prototype would still apply.  */
14603 char cexpf ();
14604 int
14605 main ()
14606 {
14607 cexpf ();
14608   ;
14609   return 0;
14610 }
14611 _ACEOF
14612 rm -f conftest.$ac_objext conftest$ac_exeext
14613 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14614   (eval $ac_link) 2>conftest.er1
14615   ac_status=$?
14616   grep -v '^ *+' conftest.er1 >conftest.err
14617   rm -f conftest.er1
14618   cat conftest.err >&5
14619   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14620   (exit $ac_status); } &&
14621          { ac_try='test -z "$ac_c_werror_flag"
14622                          || test ! -s conftest.err'
14623   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14624   (eval $ac_try) 2>&5
14625   ac_status=$?
14626   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14627   (exit $ac_status); }; } &&
14628          { ac_try='test -s conftest$ac_exeext'
14629   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14630   (eval $ac_try) 2>&5
14631   ac_status=$?
14632   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14633   (exit $ac_status); }; }; then
14634   ac_cv_lib_m_cexpf=yes
14635 else
14636   echo "$as_me: failed program was:" >&5
14637 sed 's/^/| /' conftest.$ac_ext >&5
14638
14639 ac_cv_lib_m_cexpf=no
14640 fi
14641 rm -f conftest.err conftest.$ac_objext \
14642       conftest$ac_exeext conftest.$ac_ext
14643 LIBS=$ac_check_lib_save_LIBS
14644 fi
14645 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexpf" >&5
14646 echo "${ECHO_T}$ac_cv_lib_m_cexpf" >&6
14647 if test $ac_cv_lib_m_cexpf = yes; then
14648
14649 cat >>confdefs.h <<\_ACEOF
14650 #define HAVE_CEXPF 1
14651 _ACEOF
14652
14653 fi
14654
14655 echo "$as_me:$LINENO: checking for cexp in -lm" >&5
14656 echo $ECHO_N "checking for cexp in -lm... $ECHO_C" >&6
14657 if test "${ac_cv_lib_m_cexp+set}" = set; then
14658   echo $ECHO_N "(cached) $ECHO_C" >&6
14659 else
14660   ac_check_lib_save_LIBS=$LIBS
14661 LIBS="-lm  $LIBS"
14662 if test x$gcc_no_link = xyes; then
14663   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14664 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14665    { (exit 1); exit 1; }; }
14666 fi
14667 cat >conftest.$ac_ext <<_ACEOF
14668 /* confdefs.h.  */
14669 _ACEOF
14670 cat confdefs.h >>conftest.$ac_ext
14671 cat >>conftest.$ac_ext <<_ACEOF
14672 /* end confdefs.h.  */
14673
14674 /* Override any gcc2 internal prototype to avoid an error.  */
14675 #ifdef __cplusplus
14676 extern "C"
14677 #endif
14678 /* We use char because int might match the return type of a gcc2
14679    builtin and then its argument prototype would still apply.  */
14680 char cexp ();
14681 int
14682 main ()
14683 {
14684 cexp ();
14685   ;
14686   return 0;
14687 }
14688 _ACEOF
14689 rm -f conftest.$ac_objext conftest$ac_exeext
14690 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14691   (eval $ac_link) 2>conftest.er1
14692   ac_status=$?
14693   grep -v '^ *+' conftest.er1 >conftest.err
14694   rm -f conftest.er1
14695   cat conftest.err >&5
14696   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14697   (exit $ac_status); } &&
14698          { ac_try='test -z "$ac_c_werror_flag"
14699                          || test ! -s conftest.err'
14700   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14701   (eval $ac_try) 2>&5
14702   ac_status=$?
14703   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14704   (exit $ac_status); }; } &&
14705          { ac_try='test -s conftest$ac_exeext'
14706   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14707   (eval $ac_try) 2>&5
14708   ac_status=$?
14709   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14710   (exit $ac_status); }; }; then
14711   ac_cv_lib_m_cexp=yes
14712 else
14713   echo "$as_me: failed program was:" >&5
14714 sed 's/^/| /' conftest.$ac_ext >&5
14715
14716 ac_cv_lib_m_cexp=no
14717 fi
14718 rm -f conftest.err conftest.$ac_objext \
14719       conftest$ac_exeext conftest.$ac_ext
14720 LIBS=$ac_check_lib_save_LIBS
14721 fi
14722 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexp" >&5
14723 echo "${ECHO_T}$ac_cv_lib_m_cexp" >&6
14724 if test $ac_cv_lib_m_cexp = yes; then
14725
14726 cat >>confdefs.h <<\_ACEOF
14727 #define HAVE_CEXP 1
14728 _ACEOF
14729
14730 fi
14731
14732 echo "$as_me:$LINENO: checking for cexpl in -lm" >&5
14733 echo $ECHO_N "checking for cexpl in -lm... $ECHO_C" >&6
14734 if test "${ac_cv_lib_m_cexpl+set}" = set; then
14735   echo $ECHO_N "(cached) $ECHO_C" >&6
14736 else
14737   ac_check_lib_save_LIBS=$LIBS
14738 LIBS="-lm  $LIBS"
14739 if test x$gcc_no_link = xyes; then
14740   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14741 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14742    { (exit 1); exit 1; }; }
14743 fi
14744 cat >conftest.$ac_ext <<_ACEOF
14745 /* confdefs.h.  */
14746 _ACEOF
14747 cat confdefs.h >>conftest.$ac_ext
14748 cat >>conftest.$ac_ext <<_ACEOF
14749 /* end confdefs.h.  */
14750
14751 /* Override any gcc2 internal prototype to avoid an error.  */
14752 #ifdef __cplusplus
14753 extern "C"
14754 #endif
14755 /* We use char because int might match the return type of a gcc2
14756    builtin and then its argument prototype would still apply.  */
14757 char cexpl ();
14758 int
14759 main ()
14760 {
14761 cexpl ();
14762   ;
14763   return 0;
14764 }
14765 _ACEOF
14766 rm -f conftest.$ac_objext conftest$ac_exeext
14767 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14768   (eval $ac_link) 2>conftest.er1
14769   ac_status=$?
14770   grep -v '^ *+' conftest.er1 >conftest.err
14771   rm -f conftest.er1
14772   cat conftest.err >&5
14773   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14774   (exit $ac_status); } &&
14775          { ac_try='test -z "$ac_c_werror_flag"
14776                          || test ! -s conftest.err'
14777   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14778   (eval $ac_try) 2>&5
14779   ac_status=$?
14780   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14781   (exit $ac_status); }; } &&
14782          { ac_try='test -s conftest$ac_exeext'
14783   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14784   (eval $ac_try) 2>&5
14785   ac_status=$?
14786   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14787   (exit $ac_status); }; }; then
14788   ac_cv_lib_m_cexpl=yes
14789 else
14790   echo "$as_me: failed program was:" >&5
14791 sed 's/^/| /' conftest.$ac_ext >&5
14792
14793 ac_cv_lib_m_cexpl=no
14794 fi
14795 rm -f conftest.err conftest.$ac_objext \
14796       conftest$ac_exeext conftest.$ac_ext
14797 LIBS=$ac_check_lib_save_LIBS
14798 fi
14799 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexpl" >&5
14800 echo "${ECHO_T}$ac_cv_lib_m_cexpl" >&6
14801 if test $ac_cv_lib_m_cexpl = yes; then
14802
14803 cat >>confdefs.h <<\_ACEOF
14804 #define HAVE_CEXPL 1
14805 _ACEOF
14806
14807 fi
14808
14809 echo "$as_me:$LINENO: checking for fabsf in -lm" >&5
14810 echo $ECHO_N "checking for fabsf in -lm... $ECHO_C" >&6
14811 if test "${ac_cv_lib_m_fabsf+set}" = set; then
14812   echo $ECHO_N "(cached) $ECHO_C" >&6
14813 else
14814   ac_check_lib_save_LIBS=$LIBS
14815 LIBS="-lm  $LIBS"
14816 if test x$gcc_no_link = xyes; then
14817   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14818 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14819    { (exit 1); exit 1; }; }
14820 fi
14821 cat >conftest.$ac_ext <<_ACEOF
14822 /* confdefs.h.  */
14823 _ACEOF
14824 cat confdefs.h >>conftest.$ac_ext
14825 cat >>conftest.$ac_ext <<_ACEOF
14826 /* end confdefs.h.  */
14827
14828 /* Override any gcc2 internal prototype to avoid an error.  */
14829 #ifdef __cplusplus
14830 extern "C"
14831 #endif
14832 /* We use char because int might match the return type of a gcc2
14833    builtin and then its argument prototype would still apply.  */
14834 char fabsf ();
14835 int
14836 main ()
14837 {
14838 fabsf ();
14839   ;
14840   return 0;
14841 }
14842 _ACEOF
14843 rm -f conftest.$ac_objext conftest$ac_exeext
14844 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14845   (eval $ac_link) 2>conftest.er1
14846   ac_status=$?
14847   grep -v '^ *+' conftest.er1 >conftest.err
14848   rm -f conftest.er1
14849   cat conftest.err >&5
14850   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14851   (exit $ac_status); } &&
14852          { ac_try='test -z "$ac_c_werror_flag"
14853                          || test ! -s conftest.err'
14854   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14855   (eval $ac_try) 2>&5
14856   ac_status=$?
14857   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14858   (exit $ac_status); }; } &&
14859          { ac_try='test -s conftest$ac_exeext'
14860   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14861   (eval $ac_try) 2>&5
14862   ac_status=$?
14863   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14864   (exit $ac_status); }; }; then
14865   ac_cv_lib_m_fabsf=yes
14866 else
14867   echo "$as_me: failed program was:" >&5
14868 sed 's/^/| /' conftest.$ac_ext >&5
14869
14870 ac_cv_lib_m_fabsf=no
14871 fi
14872 rm -f conftest.err conftest.$ac_objext \
14873       conftest$ac_exeext conftest.$ac_ext
14874 LIBS=$ac_check_lib_save_LIBS
14875 fi
14876 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabsf" >&5
14877 echo "${ECHO_T}$ac_cv_lib_m_fabsf" >&6
14878 if test $ac_cv_lib_m_fabsf = yes; then
14879
14880 cat >>confdefs.h <<\_ACEOF
14881 #define HAVE_FABSF 1
14882 _ACEOF
14883
14884 fi
14885
14886 echo "$as_me:$LINENO: checking for fabs in -lm" >&5
14887 echo $ECHO_N "checking for fabs in -lm... $ECHO_C" >&6
14888 if test "${ac_cv_lib_m_fabs+set}" = set; then
14889   echo $ECHO_N "(cached) $ECHO_C" >&6
14890 else
14891   ac_check_lib_save_LIBS=$LIBS
14892 LIBS="-lm  $LIBS"
14893 if test x$gcc_no_link = xyes; then
14894   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14895 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14896    { (exit 1); exit 1; }; }
14897 fi
14898 cat >conftest.$ac_ext <<_ACEOF
14899 /* confdefs.h.  */
14900 _ACEOF
14901 cat confdefs.h >>conftest.$ac_ext
14902 cat >>conftest.$ac_ext <<_ACEOF
14903 /* end confdefs.h.  */
14904
14905 /* Override any gcc2 internal prototype to avoid an error.  */
14906 #ifdef __cplusplus
14907 extern "C"
14908 #endif
14909 /* We use char because int might match the return type of a gcc2
14910    builtin and then its argument prototype would still apply.  */
14911 char fabs ();
14912 int
14913 main ()
14914 {
14915 fabs ();
14916   ;
14917   return 0;
14918 }
14919 _ACEOF
14920 rm -f conftest.$ac_objext conftest$ac_exeext
14921 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14922   (eval $ac_link) 2>conftest.er1
14923   ac_status=$?
14924   grep -v '^ *+' conftest.er1 >conftest.err
14925   rm -f conftest.er1
14926   cat conftest.err >&5
14927   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14928   (exit $ac_status); } &&
14929          { ac_try='test -z "$ac_c_werror_flag"
14930                          || test ! -s conftest.err'
14931   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14932   (eval $ac_try) 2>&5
14933   ac_status=$?
14934   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14935   (exit $ac_status); }; } &&
14936          { ac_try='test -s conftest$ac_exeext'
14937   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14938   (eval $ac_try) 2>&5
14939   ac_status=$?
14940   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14941   (exit $ac_status); }; }; then
14942   ac_cv_lib_m_fabs=yes
14943 else
14944   echo "$as_me: failed program was:" >&5
14945 sed 's/^/| /' conftest.$ac_ext >&5
14946
14947 ac_cv_lib_m_fabs=no
14948 fi
14949 rm -f conftest.err conftest.$ac_objext \
14950       conftest$ac_exeext conftest.$ac_ext
14951 LIBS=$ac_check_lib_save_LIBS
14952 fi
14953 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabs" >&5
14954 echo "${ECHO_T}$ac_cv_lib_m_fabs" >&6
14955 if test $ac_cv_lib_m_fabs = yes; then
14956
14957 cat >>confdefs.h <<\_ACEOF
14958 #define HAVE_FABS 1
14959 _ACEOF
14960
14961 fi
14962
14963 echo "$as_me:$LINENO: checking for fabsl in -lm" >&5
14964 echo $ECHO_N "checking for fabsl in -lm... $ECHO_C" >&6
14965 if test "${ac_cv_lib_m_fabsl+set}" = set; then
14966   echo $ECHO_N "(cached) $ECHO_C" >&6
14967 else
14968   ac_check_lib_save_LIBS=$LIBS
14969 LIBS="-lm  $LIBS"
14970 if test x$gcc_no_link = xyes; then
14971   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14972 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14973    { (exit 1); exit 1; }; }
14974 fi
14975 cat >conftest.$ac_ext <<_ACEOF
14976 /* confdefs.h.  */
14977 _ACEOF
14978 cat confdefs.h >>conftest.$ac_ext
14979 cat >>conftest.$ac_ext <<_ACEOF
14980 /* end confdefs.h.  */
14981
14982 /* Override any gcc2 internal prototype to avoid an error.  */
14983 #ifdef __cplusplus
14984 extern "C"
14985 #endif
14986 /* We use char because int might match the return type of a gcc2
14987    builtin and then its argument prototype would still apply.  */
14988 char fabsl ();
14989 int
14990 main ()
14991 {
14992 fabsl ();
14993   ;
14994   return 0;
14995 }
14996 _ACEOF
14997 rm -f conftest.$ac_objext conftest$ac_exeext
14998 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14999   (eval $ac_link) 2>conftest.er1
15000   ac_status=$?
15001   grep -v '^ *+' conftest.er1 >conftest.err
15002   rm -f conftest.er1
15003   cat conftest.err >&5
15004   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15005   (exit $ac_status); } &&
15006          { ac_try='test -z "$ac_c_werror_flag"
15007                          || test ! -s conftest.err'
15008   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15009   (eval $ac_try) 2>&5
15010   ac_status=$?
15011   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15012   (exit $ac_status); }; } &&
15013          { ac_try='test -s conftest$ac_exeext'
15014   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15015   (eval $ac_try) 2>&5
15016   ac_status=$?
15017   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15018   (exit $ac_status); }; }; then
15019   ac_cv_lib_m_fabsl=yes
15020 else
15021   echo "$as_me: failed program was:" >&5
15022 sed 's/^/| /' conftest.$ac_ext >&5
15023
15024 ac_cv_lib_m_fabsl=no
15025 fi
15026 rm -f conftest.err conftest.$ac_objext \
15027       conftest$ac_exeext conftest.$ac_ext
15028 LIBS=$ac_check_lib_save_LIBS
15029 fi
15030 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabsl" >&5
15031 echo "${ECHO_T}$ac_cv_lib_m_fabsl" >&6
15032 if test $ac_cv_lib_m_fabsl = yes; then
15033
15034 cat >>confdefs.h <<\_ACEOF
15035 #define HAVE_FABSL 1
15036 _ACEOF
15037
15038 fi
15039
15040 echo "$as_me:$LINENO: checking for cabsf in -lm" >&5
15041 echo $ECHO_N "checking for cabsf in -lm... $ECHO_C" >&6
15042 if test "${ac_cv_lib_m_cabsf+set}" = set; then
15043   echo $ECHO_N "(cached) $ECHO_C" >&6
15044 else
15045   ac_check_lib_save_LIBS=$LIBS
15046 LIBS="-lm  $LIBS"
15047 if test x$gcc_no_link = xyes; then
15048   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15049 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15050    { (exit 1); exit 1; }; }
15051 fi
15052 cat >conftest.$ac_ext <<_ACEOF
15053 /* confdefs.h.  */
15054 _ACEOF
15055 cat confdefs.h >>conftest.$ac_ext
15056 cat >>conftest.$ac_ext <<_ACEOF
15057 /* end confdefs.h.  */
15058
15059 /* Override any gcc2 internal prototype to avoid an error.  */
15060 #ifdef __cplusplus
15061 extern "C"
15062 #endif
15063 /* We use char because int might match the return type of a gcc2
15064    builtin and then its argument prototype would still apply.  */
15065 char cabsf ();
15066 int
15067 main ()
15068 {
15069 cabsf ();
15070   ;
15071   return 0;
15072 }
15073 _ACEOF
15074 rm -f conftest.$ac_objext conftest$ac_exeext
15075 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15076   (eval $ac_link) 2>conftest.er1
15077   ac_status=$?
15078   grep -v '^ *+' conftest.er1 >conftest.err
15079   rm -f conftest.er1
15080   cat conftest.err >&5
15081   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15082   (exit $ac_status); } &&
15083          { ac_try='test -z "$ac_c_werror_flag"
15084                          || test ! -s conftest.err'
15085   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15086   (eval $ac_try) 2>&5
15087   ac_status=$?
15088   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15089   (exit $ac_status); }; } &&
15090          { ac_try='test -s conftest$ac_exeext'
15091   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15092   (eval $ac_try) 2>&5
15093   ac_status=$?
15094   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15095   (exit $ac_status); }; }; then
15096   ac_cv_lib_m_cabsf=yes
15097 else
15098   echo "$as_me: failed program was:" >&5
15099 sed 's/^/| /' conftest.$ac_ext >&5
15100
15101 ac_cv_lib_m_cabsf=no
15102 fi
15103 rm -f conftest.err conftest.$ac_objext \
15104       conftest$ac_exeext conftest.$ac_ext
15105 LIBS=$ac_check_lib_save_LIBS
15106 fi
15107 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabsf" >&5
15108 echo "${ECHO_T}$ac_cv_lib_m_cabsf" >&6
15109 if test $ac_cv_lib_m_cabsf = yes; then
15110
15111 cat >>confdefs.h <<\_ACEOF
15112 #define HAVE_CABSF 1
15113 _ACEOF
15114
15115 fi
15116
15117 echo "$as_me:$LINENO: checking for cabs in -lm" >&5
15118 echo $ECHO_N "checking for cabs in -lm... $ECHO_C" >&6
15119 if test "${ac_cv_lib_m_cabs+set}" = set; then
15120   echo $ECHO_N "(cached) $ECHO_C" >&6
15121 else
15122   ac_check_lib_save_LIBS=$LIBS
15123 LIBS="-lm  $LIBS"
15124 if test x$gcc_no_link = xyes; then
15125   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15126 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15127    { (exit 1); exit 1; }; }
15128 fi
15129 cat >conftest.$ac_ext <<_ACEOF
15130 /* confdefs.h.  */
15131 _ACEOF
15132 cat confdefs.h >>conftest.$ac_ext
15133 cat >>conftest.$ac_ext <<_ACEOF
15134 /* end confdefs.h.  */
15135
15136 /* Override any gcc2 internal prototype to avoid an error.  */
15137 #ifdef __cplusplus
15138 extern "C"
15139 #endif
15140 /* We use char because int might match the return type of a gcc2
15141    builtin and then its argument prototype would still apply.  */
15142 char cabs ();
15143 int
15144 main ()
15145 {
15146 cabs ();
15147   ;
15148   return 0;
15149 }
15150 _ACEOF
15151 rm -f conftest.$ac_objext conftest$ac_exeext
15152 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15153   (eval $ac_link) 2>conftest.er1
15154   ac_status=$?
15155   grep -v '^ *+' conftest.er1 >conftest.err
15156   rm -f conftest.er1
15157   cat conftest.err >&5
15158   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15159   (exit $ac_status); } &&
15160          { ac_try='test -z "$ac_c_werror_flag"
15161                          || test ! -s conftest.err'
15162   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15163   (eval $ac_try) 2>&5
15164   ac_status=$?
15165   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15166   (exit $ac_status); }; } &&
15167          { ac_try='test -s conftest$ac_exeext'
15168   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15169   (eval $ac_try) 2>&5
15170   ac_status=$?
15171   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15172   (exit $ac_status); }; }; then
15173   ac_cv_lib_m_cabs=yes
15174 else
15175   echo "$as_me: failed program was:" >&5
15176 sed 's/^/| /' conftest.$ac_ext >&5
15177
15178 ac_cv_lib_m_cabs=no
15179 fi
15180 rm -f conftest.err conftest.$ac_objext \
15181       conftest$ac_exeext conftest.$ac_ext
15182 LIBS=$ac_check_lib_save_LIBS
15183 fi
15184 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabs" >&5
15185 echo "${ECHO_T}$ac_cv_lib_m_cabs" >&6
15186 if test $ac_cv_lib_m_cabs = yes; then
15187
15188 cat >>confdefs.h <<\_ACEOF
15189 #define HAVE_CABS 1
15190 _ACEOF
15191
15192 fi
15193
15194 echo "$as_me:$LINENO: checking for cabsl in -lm" >&5
15195 echo $ECHO_N "checking for cabsl in -lm... $ECHO_C" >&6
15196 if test "${ac_cv_lib_m_cabsl+set}" = set; then
15197   echo $ECHO_N "(cached) $ECHO_C" >&6
15198 else
15199   ac_check_lib_save_LIBS=$LIBS
15200 LIBS="-lm  $LIBS"
15201 if test x$gcc_no_link = xyes; then
15202   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15203 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15204    { (exit 1); exit 1; }; }
15205 fi
15206 cat >conftest.$ac_ext <<_ACEOF
15207 /* confdefs.h.  */
15208 _ACEOF
15209 cat confdefs.h >>conftest.$ac_ext
15210 cat >>conftest.$ac_ext <<_ACEOF
15211 /* end confdefs.h.  */
15212
15213 /* Override any gcc2 internal prototype to avoid an error.  */
15214 #ifdef __cplusplus
15215 extern "C"
15216 #endif
15217 /* We use char because int might match the return type of a gcc2
15218    builtin and then its argument prototype would still apply.  */
15219 char cabsl ();
15220 int
15221 main ()
15222 {
15223 cabsl ();
15224   ;
15225   return 0;
15226 }
15227 _ACEOF
15228 rm -f conftest.$ac_objext conftest$ac_exeext
15229 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15230   (eval $ac_link) 2>conftest.er1
15231   ac_status=$?
15232   grep -v '^ *+' conftest.er1 >conftest.err
15233   rm -f conftest.er1
15234   cat conftest.err >&5
15235   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15236   (exit $ac_status); } &&
15237          { ac_try='test -z "$ac_c_werror_flag"
15238                          || test ! -s conftest.err'
15239   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15240   (eval $ac_try) 2>&5
15241   ac_status=$?
15242   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15243   (exit $ac_status); }; } &&
15244          { ac_try='test -s conftest$ac_exeext'
15245   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15246   (eval $ac_try) 2>&5
15247   ac_status=$?
15248   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15249   (exit $ac_status); }; }; then
15250   ac_cv_lib_m_cabsl=yes
15251 else
15252   echo "$as_me: failed program was:" >&5
15253 sed 's/^/| /' conftest.$ac_ext >&5
15254
15255 ac_cv_lib_m_cabsl=no
15256 fi
15257 rm -f conftest.err conftest.$ac_objext \
15258       conftest$ac_exeext conftest.$ac_ext
15259 LIBS=$ac_check_lib_save_LIBS
15260 fi
15261 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabsl" >&5
15262 echo "${ECHO_T}$ac_cv_lib_m_cabsl" >&6
15263 if test $ac_cv_lib_m_cabsl = yes; then
15264
15265 cat >>confdefs.h <<\_ACEOF
15266 #define HAVE_CABSL 1
15267 _ACEOF
15268
15269 fi
15270
15271 echo "$as_me:$LINENO: checking for floorf in -lm" >&5
15272 echo $ECHO_N "checking for floorf in -lm... $ECHO_C" >&6
15273 if test "${ac_cv_lib_m_floorf+set}" = set; then
15274   echo $ECHO_N "(cached) $ECHO_C" >&6
15275 else
15276   ac_check_lib_save_LIBS=$LIBS
15277 LIBS="-lm  $LIBS"
15278 if test x$gcc_no_link = xyes; then
15279   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15280 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15281    { (exit 1); exit 1; }; }
15282 fi
15283 cat >conftest.$ac_ext <<_ACEOF
15284 /* confdefs.h.  */
15285 _ACEOF
15286 cat confdefs.h >>conftest.$ac_ext
15287 cat >>conftest.$ac_ext <<_ACEOF
15288 /* end confdefs.h.  */
15289
15290 /* Override any gcc2 internal prototype to avoid an error.  */
15291 #ifdef __cplusplus
15292 extern "C"
15293 #endif
15294 /* We use char because int might match the return type of a gcc2
15295    builtin and then its argument prototype would still apply.  */
15296 char floorf ();
15297 int
15298 main ()
15299 {
15300 floorf ();
15301   ;
15302   return 0;
15303 }
15304 _ACEOF
15305 rm -f conftest.$ac_objext conftest$ac_exeext
15306 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15307   (eval $ac_link) 2>conftest.er1
15308   ac_status=$?
15309   grep -v '^ *+' conftest.er1 >conftest.err
15310   rm -f conftest.er1
15311   cat conftest.err >&5
15312   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15313   (exit $ac_status); } &&
15314          { ac_try='test -z "$ac_c_werror_flag"
15315                          || test ! -s conftest.err'
15316   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15317   (eval $ac_try) 2>&5
15318   ac_status=$?
15319   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15320   (exit $ac_status); }; } &&
15321          { ac_try='test -s conftest$ac_exeext'
15322   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15323   (eval $ac_try) 2>&5
15324   ac_status=$?
15325   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15326   (exit $ac_status); }; }; then
15327   ac_cv_lib_m_floorf=yes
15328 else
15329   echo "$as_me: failed program was:" >&5
15330 sed 's/^/| /' conftest.$ac_ext >&5
15331
15332 ac_cv_lib_m_floorf=no
15333 fi
15334 rm -f conftest.err conftest.$ac_objext \
15335       conftest$ac_exeext conftest.$ac_ext
15336 LIBS=$ac_check_lib_save_LIBS
15337 fi
15338 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floorf" >&5
15339 echo "${ECHO_T}$ac_cv_lib_m_floorf" >&6
15340 if test $ac_cv_lib_m_floorf = yes; then
15341
15342 cat >>confdefs.h <<\_ACEOF
15343 #define HAVE_FLOORF 1
15344 _ACEOF
15345
15346 fi
15347
15348 echo "$as_me:$LINENO: checking for floor in -lm" >&5
15349 echo $ECHO_N "checking for floor in -lm... $ECHO_C" >&6
15350 if test "${ac_cv_lib_m_floor+set}" = set; then
15351   echo $ECHO_N "(cached) $ECHO_C" >&6
15352 else
15353   ac_check_lib_save_LIBS=$LIBS
15354 LIBS="-lm  $LIBS"
15355 if test x$gcc_no_link = xyes; then
15356   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15357 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15358    { (exit 1); exit 1; }; }
15359 fi
15360 cat >conftest.$ac_ext <<_ACEOF
15361 /* confdefs.h.  */
15362 _ACEOF
15363 cat confdefs.h >>conftest.$ac_ext
15364 cat >>conftest.$ac_ext <<_ACEOF
15365 /* end confdefs.h.  */
15366
15367 /* Override any gcc2 internal prototype to avoid an error.  */
15368 #ifdef __cplusplus
15369 extern "C"
15370 #endif
15371 /* We use char because int might match the return type of a gcc2
15372    builtin and then its argument prototype would still apply.  */
15373 char floor ();
15374 int
15375 main ()
15376 {
15377 floor ();
15378   ;
15379   return 0;
15380 }
15381 _ACEOF
15382 rm -f conftest.$ac_objext conftest$ac_exeext
15383 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15384   (eval $ac_link) 2>conftest.er1
15385   ac_status=$?
15386   grep -v '^ *+' conftest.er1 >conftest.err
15387   rm -f conftest.er1
15388   cat conftest.err >&5
15389   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15390   (exit $ac_status); } &&
15391          { ac_try='test -z "$ac_c_werror_flag"
15392                          || test ! -s conftest.err'
15393   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15394   (eval $ac_try) 2>&5
15395   ac_status=$?
15396   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15397   (exit $ac_status); }; } &&
15398          { ac_try='test -s conftest$ac_exeext'
15399   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15400   (eval $ac_try) 2>&5
15401   ac_status=$?
15402   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15403   (exit $ac_status); }; }; then
15404   ac_cv_lib_m_floor=yes
15405 else
15406   echo "$as_me: failed program was:" >&5
15407 sed 's/^/| /' conftest.$ac_ext >&5
15408
15409 ac_cv_lib_m_floor=no
15410 fi
15411 rm -f conftest.err conftest.$ac_objext \
15412       conftest$ac_exeext conftest.$ac_ext
15413 LIBS=$ac_check_lib_save_LIBS
15414 fi
15415 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floor" >&5
15416 echo "${ECHO_T}$ac_cv_lib_m_floor" >&6
15417 if test $ac_cv_lib_m_floor = yes; then
15418
15419 cat >>confdefs.h <<\_ACEOF
15420 #define HAVE_FLOOR 1
15421 _ACEOF
15422
15423 fi
15424
15425 echo "$as_me:$LINENO: checking for floorl in -lm" >&5
15426 echo $ECHO_N "checking for floorl in -lm... $ECHO_C" >&6
15427 if test "${ac_cv_lib_m_floorl+set}" = set; then
15428   echo $ECHO_N "(cached) $ECHO_C" >&6
15429 else
15430   ac_check_lib_save_LIBS=$LIBS
15431 LIBS="-lm  $LIBS"
15432 if test x$gcc_no_link = xyes; then
15433   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15434 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15435    { (exit 1); exit 1; }; }
15436 fi
15437 cat >conftest.$ac_ext <<_ACEOF
15438 /* confdefs.h.  */
15439 _ACEOF
15440 cat confdefs.h >>conftest.$ac_ext
15441 cat >>conftest.$ac_ext <<_ACEOF
15442 /* end confdefs.h.  */
15443
15444 /* Override any gcc2 internal prototype to avoid an error.  */
15445 #ifdef __cplusplus
15446 extern "C"
15447 #endif
15448 /* We use char because int might match the return type of a gcc2
15449    builtin and then its argument prototype would still apply.  */
15450 char floorl ();
15451 int
15452 main ()
15453 {
15454 floorl ();
15455   ;
15456   return 0;
15457 }
15458 _ACEOF
15459 rm -f conftest.$ac_objext conftest$ac_exeext
15460 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15461   (eval $ac_link) 2>conftest.er1
15462   ac_status=$?
15463   grep -v '^ *+' conftest.er1 >conftest.err
15464   rm -f conftest.er1
15465   cat conftest.err >&5
15466   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15467   (exit $ac_status); } &&
15468          { ac_try='test -z "$ac_c_werror_flag"
15469                          || test ! -s conftest.err'
15470   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15471   (eval $ac_try) 2>&5
15472   ac_status=$?
15473   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15474   (exit $ac_status); }; } &&
15475          { ac_try='test -s conftest$ac_exeext'
15476   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15477   (eval $ac_try) 2>&5
15478   ac_status=$?
15479   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15480   (exit $ac_status); }; }; then
15481   ac_cv_lib_m_floorl=yes
15482 else
15483   echo "$as_me: failed program was:" >&5
15484 sed 's/^/| /' conftest.$ac_ext >&5
15485
15486 ac_cv_lib_m_floorl=no
15487 fi
15488 rm -f conftest.err conftest.$ac_objext \
15489       conftest$ac_exeext conftest.$ac_ext
15490 LIBS=$ac_check_lib_save_LIBS
15491 fi
15492 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floorl" >&5
15493 echo "${ECHO_T}$ac_cv_lib_m_floorl" >&6
15494 if test $ac_cv_lib_m_floorl = yes; then
15495
15496 cat >>confdefs.h <<\_ACEOF
15497 #define HAVE_FLOORL 1
15498 _ACEOF
15499
15500 fi
15501
15502 echo "$as_me:$LINENO: checking for fmodf in -lm" >&5
15503 echo $ECHO_N "checking for fmodf in -lm... $ECHO_C" >&6
15504 if test "${ac_cv_lib_m_fmodf+set}" = set; then
15505   echo $ECHO_N "(cached) $ECHO_C" >&6
15506 else
15507   ac_check_lib_save_LIBS=$LIBS
15508 LIBS="-lm  $LIBS"
15509 if test x$gcc_no_link = xyes; then
15510   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15511 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15512    { (exit 1); exit 1; }; }
15513 fi
15514 cat >conftest.$ac_ext <<_ACEOF
15515 /* confdefs.h.  */
15516 _ACEOF
15517 cat confdefs.h >>conftest.$ac_ext
15518 cat >>conftest.$ac_ext <<_ACEOF
15519 /* end confdefs.h.  */
15520
15521 /* Override any gcc2 internal prototype to avoid an error.  */
15522 #ifdef __cplusplus
15523 extern "C"
15524 #endif
15525 /* We use char because int might match the return type of a gcc2
15526    builtin and then its argument prototype would still apply.  */
15527 char fmodf ();
15528 int
15529 main ()
15530 {
15531 fmodf ();
15532   ;
15533   return 0;
15534 }
15535 _ACEOF
15536 rm -f conftest.$ac_objext conftest$ac_exeext
15537 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15538   (eval $ac_link) 2>conftest.er1
15539   ac_status=$?
15540   grep -v '^ *+' conftest.er1 >conftest.err
15541   rm -f conftest.er1
15542   cat conftest.err >&5
15543   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15544   (exit $ac_status); } &&
15545          { ac_try='test -z "$ac_c_werror_flag"
15546                          || test ! -s conftest.err'
15547   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15548   (eval $ac_try) 2>&5
15549   ac_status=$?
15550   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15551   (exit $ac_status); }; } &&
15552          { ac_try='test -s conftest$ac_exeext'
15553   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15554   (eval $ac_try) 2>&5
15555   ac_status=$?
15556   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15557   (exit $ac_status); }; }; then
15558   ac_cv_lib_m_fmodf=yes
15559 else
15560   echo "$as_me: failed program was:" >&5
15561 sed 's/^/| /' conftest.$ac_ext >&5
15562
15563 ac_cv_lib_m_fmodf=no
15564 fi
15565 rm -f conftest.err conftest.$ac_objext \
15566       conftest$ac_exeext conftest.$ac_ext
15567 LIBS=$ac_check_lib_save_LIBS
15568 fi
15569 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fmodf" >&5
15570 echo "${ECHO_T}$ac_cv_lib_m_fmodf" >&6
15571 if test $ac_cv_lib_m_fmodf = yes; then
15572
15573 cat >>confdefs.h <<\_ACEOF
15574 #define HAVE_FMODF 1
15575 _ACEOF
15576
15577 fi
15578
15579 echo "$as_me:$LINENO: checking for fmod in -lm" >&5
15580 echo $ECHO_N "checking for fmod in -lm... $ECHO_C" >&6
15581 if test "${ac_cv_lib_m_fmod+set}" = set; then
15582   echo $ECHO_N "(cached) $ECHO_C" >&6
15583 else
15584   ac_check_lib_save_LIBS=$LIBS
15585 LIBS="-lm  $LIBS"
15586 if test x$gcc_no_link = xyes; then
15587   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15588 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15589    { (exit 1); exit 1; }; }
15590 fi
15591 cat >conftest.$ac_ext <<_ACEOF
15592 /* confdefs.h.  */
15593 _ACEOF
15594 cat confdefs.h >>conftest.$ac_ext
15595 cat >>conftest.$ac_ext <<_ACEOF
15596 /* end confdefs.h.  */
15597
15598 /* Override any gcc2 internal prototype to avoid an error.  */
15599 #ifdef __cplusplus
15600 extern "C"
15601 #endif
15602 /* We use char because int might match the return type of a gcc2
15603    builtin and then its argument prototype would still apply.  */
15604 char fmod ();
15605 int
15606 main ()
15607 {
15608 fmod ();
15609   ;
15610   return 0;
15611 }
15612 _ACEOF
15613 rm -f conftest.$ac_objext conftest$ac_exeext
15614 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15615   (eval $ac_link) 2>conftest.er1
15616   ac_status=$?
15617   grep -v '^ *+' conftest.er1 >conftest.err
15618   rm -f conftest.er1
15619   cat conftest.err >&5
15620   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15621   (exit $ac_status); } &&
15622          { ac_try='test -z "$ac_c_werror_flag"
15623                          || test ! -s conftest.err'
15624   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15625   (eval $ac_try) 2>&5
15626   ac_status=$?
15627   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15628   (exit $ac_status); }; } &&
15629          { ac_try='test -s conftest$ac_exeext'
15630   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15631   (eval $ac_try) 2>&5
15632   ac_status=$?
15633   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15634   (exit $ac_status); }; }; then
15635   ac_cv_lib_m_fmod=yes
15636 else
15637   echo "$as_me: failed program was:" >&5
15638 sed 's/^/| /' conftest.$ac_ext >&5
15639
15640 ac_cv_lib_m_fmod=no
15641 fi
15642 rm -f conftest.err conftest.$ac_objext \
15643       conftest$ac_exeext conftest.$ac_ext
15644 LIBS=$ac_check_lib_save_LIBS
15645 fi
15646 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fmod" >&5
15647 echo "${ECHO_T}$ac_cv_lib_m_fmod" >&6
15648 if test $ac_cv_lib_m_fmod = yes; then
15649
15650 cat >>confdefs.h <<\_ACEOF
15651 #define HAVE_FMOD 1
15652 _ACEOF
15653
15654 fi
15655
15656 echo "$as_me:$LINENO: checking for fmodl in -lm" >&5
15657 echo $ECHO_N "checking for fmodl in -lm... $ECHO_C" >&6
15658 if test "${ac_cv_lib_m_fmodl+set}" = set; then
15659   echo $ECHO_N "(cached) $ECHO_C" >&6
15660 else
15661   ac_check_lib_save_LIBS=$LIBS
15662 LIBS="-lm  $LIBS"
15663 if test x$gcc_no_link = xyes; then
15664   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15665 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15666    { (exit 1); exit 1; }; }
15667 fi
15668 cat >conftest.$ac_ext <<_ACEOF
15669 /* confdefs.h.  */
15670 _ACEOF
15671 cat confdefs.h >>conftest.$ac_ext
15672 cat >>conftest.$ac_ext <<_ACEOF
15673 /* end confdefs.h.  */
15674
15675 /* Override any gcc2 internal prototype to avoid an error.  */
15676 #ifdef __cplusplus
15677 extern "C"
15678 #endif
15679 /* We use char because int might match the return type of a gcc2
15680    builtin and then its argument prototype would still apply.  */
15681 char fmodl ();
15682 int
15683 main ()
15684 {
15685 fmodl ();
15686   ;
15687   return 0;
15688 }
15689 _ACEOF
15690 rm -f conftest.$ac_objext conftest$ac_exeext
15691 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15692   (eval $ac_link) 2>conftest.er1
15693   ac_status=$?
15694   grep -v '^ *+' conftest.er1 >conftest.err
15695   rm -f conftest.er1
15696   cat conftest.err >&5
15697   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15698   (exit $ac_status); } &&
15699          { ac_try='test -z "$ac_c_werror_flag"
15700                          || test ! -s conftest.err'
15701   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15702   (eval $ac_try) 2>&5
15703   ac_status=$?
15704   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15705   (exit $ac_status); }; } &&
15706          { ac_try='test -s conftest$ac_exeext'
15707   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15708   (eval $ac_try) 2>&5
15709   ac_status=$?
15710   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15711   (exit $ac_status); }; }; then
15712   ac_cv_lib_m_fmodl=yes
15713 else
15714   echo "$as_me: failed program was:" >&5
15715 sed 's/^/| /' conftest.$ac_ext >&5
15716
15717 ac_cv_lib_m_fmodl=no
15718 fi
15719 rm -f conftest.err conftest.$ac_objext \
15720       conftest$ac_exeext conftest.$ac_ext
15721 LIBS=$ac_check_lib_save_LIBS
15722 fi
15723 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fmodl" >&5
15724 echo "${ECHO_T}$ac_cv_lib_m_fmodl" >&6
15725 if test $ac_cv_lib_m_fmodl = yes; then
15726
15727 cat >>confdefs.h <<\_ACEOF
15728 #define HAVE_FMODL 1
15729 _ACEOF
15730
15731 fi
15732
15733 echo "$as_me:$LINENO: checking for frexpf in -lm" >&5
15734 echo $ECHO_N "checking for frexpf in -lm... $ECHO_C" >&6
15735 if test "${ac_cv_lib_m_frexpf+set}" = set; then
15736   echo $ECHO_N "(cached) $ECHO_C" >&6
15737 else
15738   ac_check_lib_save_LIBS=$LIBS
15739 LIBS="-lm  $LIBS"
15740 if test x$gcc_no_link = xyes; then
15741   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15742 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15743    { (exit 1); exit 1; }; }
15744 fi
15745 cat >conftest.$ac_ext <<_ACEOF
15746 /* confdefs.h.  */
15747 _ACEOF
15748 cat confdefs.h >>conftest.$ac_ext
15749 cat >>conftest.$ac_ext <<_ACEOF
15750 /* end confdefs.h.  */
15751
15752 /* Override any gcc2 internal prototype to avoid an error.  */
15753 #ifdef __cplusplus
15754 extern "C"
15755 #endif
15756 /* We use char because int might match the return type of a gcc2
15757    builtin and then its argument prototype would still apply.  */
15758 char frexpf ();
15759 int
15760 main ()
15761 {
15762 frexpf ();
15763   ;
15764   return 0;
15765 }
15766 _ACEOF
15767 rm -f conftest.$ac_objext conftest$ac_exeext
15768 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15769   (eval $ac_link) 2>conftest.er1
15770   ac_status=$?
15771   grep -v '^ *+' conftest.er1 >conftest.err
15772   rm -f conftest.er1
15773   cat conftest.err >&5
15774   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15775   (exit $ac_status); } &&
15776          { ac_try='test -z "$ac_c_werror_flag"
15777                          || test ! -s conftest.err'
15778   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15779   (eval $ac_try) 2>&5
15780   ac_status=$?
15781   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15782   (exit $ac_status); }; } &&
15783          { ac_try='test -s conftest$ac_exeext'
15784   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15785   (eval $ac_try) 2>&5
15786   ac_status=$?
15787   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15788   (exit $ac_status); }; }; then
15789   ac_cv_lib_m_frexpf=yes
15790 else
15791   echo "$as_me: failed program was:" >&5
15792 sed 's/^/| /' conftest.$ac_ext >&5
15793
15794 ac_cv_lib_m_frexpf=no
15795 fi
15796 rm -f conftest.err conftest.$ac_objext \
15797       conftest$ac_exeext conftest.$ac_ext
15798 LIBS=$ac_check_lib_save_LIBS
15799 fi
15800 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexpf" >&5
15801 echo "${ECHO_T}$ac_cv_lib_m_frexpf" >&6
15802 if test $ac_cv_lib_m_frexpf = yes; then
15803
15804 cat >>confdefs.h <<\_ACEOF
15805 #define HAVE_FREXPF 1
15806 _ACEOF
15807
15808 fi
15809
15810 echo "$as_me:$LINENO: checking for frexp in -lm" >&5
15811 echo $ECHO_N "checking for frexp in -lm... $ECHO_C" >&6
15812 if test "${ac_cv_lib_m_frexp+set}" = set; then
15813   echo $ECHO_N "(cached) $ECHO_C" >&6
15814 else
15815   ac_check_lib_save_LIBS=$LIBS
15816 LIBS="-lm  $LIBS"
15817 if test x$gcc_no_link = xyes; then
15818   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15819 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15820    { (exit 1); exit 1; }; }
15821 fi
15822 cat >conftest.$ac_ext <<_ACEOF
15823 /* confdefs.h.  */
15824 _ACEOF
15825 cat confdefs.h >>conftest.$ac_ext
15826 cat >>conftest.$ac_ext <<_ACEOF
15827 /* end confdefs.h.  */
15828
15829 /* Override any gcc2 internal prototype to avoid an error.  */
15830 #ifdef __cplusplus
15831 extern "C"
15832 #endif
15833 /* We use char because int might match the return type of a gcc2
15834    builtin and then its argument prototype would still apply.  */
15835 char frexp ();
15836 int
15837 main ()
15838 {
15839 frexp ();
15840   ;
15841   return 0;
15842 }
15843 _ACEOF
15844 rm -f conftest.$ac_objext conftest$ac_exeext
15845 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15846   (eval $ac_link) 2>conftest.er1
15847   ac_status=$?
15848   grep -v '^ *+' conftest.er1 >conftest.err
15849   rm -f conftest.er1
15850   cat conftest.err >&5
15851   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15852   (exit $ac_status); } &&
15853          { ac_try='test -z "$ac_c_werror_flag"
15854                          || test ! -s conftest.err'
15855   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15856   (eval $ac_try) 2>&5
15857   ac_status=$?
15858   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15859   (exit $ac_status); }; } &&
15860          { ac_try='test -s conftest$ac_exeext'
15861   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15862   (eval $ac_try) 2>&5
15863   ac_status=$?
15864   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15865   (exit $ac_status); }; }; then
15866   ac_cv_lib_m_frexp=yes
15867 else
15868   echo "$as_me: failed program was:" >&5
15869 sed 's/^/| /' conftest.$ac_ext >&5
15870
15871 ac_cv_lib_m_frexp=no
15872 fi
15873 rm -f conftest.err conftest.$ac_objext \
15874       conftest$ac_exeext conftest.$ac_ext
15875 LIBS=$ac_check_lib_save_LIBS
15876 fi
15877 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexp" >&5
15878 echo "${ECHO_T}$ac_cv_lib_m_frexp" >&6
15879 if test $ac_cv_lib_m_frexp = yes; then
15880
15881 cat >>confdefs.h <<\_ACEOF
15882 #define HAVE_FREXP 1
15883 _ACEOF
15884
15885 fi
15886
15887 echo "$as_me:$LINENO: checking for frexpl in -lm" >&5
15888 echo $ECHO_N "checking for frexpl in -lm... $ECHO_C" >&6
15889 if test "${ac_cv_lib_m_frexpl+set}" = set; then
15890   echo $ECHO_N "(cached) $ECHO_C" >&6
15891 else
15892   ac_check_lib_save_LIBS=$LIBS
15893 LIBS="-lm  $LIBS"
15894 if test x$gcc_no_link = xyes; then
15895   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15896 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15897    { (exit 1); exit 1; }; }
15898 fi
15899 cat >conftest.$ac_ext <<_ACEOF
15900 /* confdefs.h.  */
15901 _ACEOF
15902 cat confdefs.h >>conftest.$ac_ext
15903 cat >>conftest.$ac_ext <<_ACEOF
15904 /* end confdefs.h.  */
15905
15906 /* Override any gcc2 internal prototype to avoid an error.  */
15907 #ifdef __cplusplus
15908 extern "C"
15909 #endif
15910 /* We use char because int might match the return type of a gcc2
15911    builtin and then its argument prototype would still apply.  */
15912 char frexpl ();
15913 int
15914 main ()
15915 {
15916 frexpl ();
15917   ;
15918   return 0;
15919 }
15920 _ACEOF
15921 rm -f conftest.$ac_objext conftest$ac_exeext
15922 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15923   (eval $ac_link) 2>conftest.er1
15924   ac_status=$?
15925   grep -v '^ *+' conftest.er1 >conftest.err
15926   rm -f conftest.er1
15927   cat conftest.err >&5
15928   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15929   (exit $ac_status); } &&
15930          { ac_try='test -z "$ac_c_werror_flag"
15931                          || test ! -s conftest.err'
15932   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15933   (eval $ac_try) 2>&5
15934   ac_status=$?
15935   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15936   (exit $ac_status); }; } &&
15937          { ac_try='test -s conftest$ac_exeext'
15938   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15939   (eval $ac_try) 2>&5
15940   ac_status=$?
15941   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15942   (exit $ac_status); }; }; then
15943   ac_cv_lib_m_frexpl=yes
15944 else
15945   echo "$as_me: failed program was:" >&5
15946 sed 's/^/| /' conftest.$ac_ext >&5
15947
15948 ac_cv_lib_m_frexpl=no
15949 fi
15950 rm -f conftest.err conftest.$ac_objext \
15951       conftest$ac_exeext conftest.$ac_ext
15952 LIBS=$ac_check_lib_save_LIBS
15953 fi
15954 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexpl" >&5
15955 echo "${ECHO_T}$ac_cv_lib_m_frexpl" >&6
15956 if test $ac_cv_lib_m_frexpl = yes; then
15957
15958 cat >>confdefs.h <<\_ACEOF
15959 #define HAVE_FREXPL 1
15960 _ACEOF
15961
15962 fi
15963
15964 echo "$as_me:$LINENO: checking for hypotf in -lm" >&5
15965 echo $ECHO_N "checking for hypotf in -lm... $ECHO_C" >&6
15966 if test "${ac_cv_lib_m_hypotf+set}" = set; then
15967   echo $ECHO_N "(cached) $ECHO_C" >&6
15968 else
15969   ac_check_lib_save_LIBS=$LIBS
15970 LIBS="-lm  $LIBS"
15971 if test x$gcc_no_link = xyes; then
15972   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15973 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15974    { (exit 1); exit 1; }; }
15975 fi
15976 cat >conftest.$ac_ext <<_ACEOF
15977 /* confdefs.h.  */
15978 _ACEOF
15979 cat confdefs.h >>conftest.$ac_ext
15980 cat >>conftest.$ac_ext <<_ACEOF
15981 /* end confdefs.h.  */
15982
15983 /* Override any gcc2 internal prototype to avoid an error.  */
15984 #ifdef __cplusplus
15985 extern "C"
15986 #endif
15987 /* We use char because int might match the return type of a gcc2
15988    builtin and then its argument prototype would still apply.  */
15989 char hypotf ();
15990 int
15991 main ()
15992 {
15993 hypotf ();
15994   ;
15995   return 0;
15996 }
15997 _ACEOF
15998 rm -f conftest.$ac_objext conftest$ac_exeext
15999 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16000   (eval $ac_link) 2>conftest.er1
16001   ac_status=$?
16002   grep -v '^ *+' conftest.er1 >conftest.err
16003   rm -f conftest.er1
16004   cat conftest.err >&5
16005   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16006   (exit $ac_status); } &&
16007          { ac_try='test -z "$ac_c_werror_flag"
16008                          || test ! -s conftest.err'
16009   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16010   (eval $ac_try) 2>&5
16011   ac_status=$?
16012   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16013   (exit $ac_status); }; } &&
16014          { ac_try='test -s conftest$ac_exeext'
16015   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16016   (eval $ac_try) 2>&5
16017   ac_status=$?
16018   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16019   (exit $ac_status); }; }; then
16020   ac_cv_lib_m_hypotf=yes
16021 else
16022   echo "$as_me: failed program was:" >&5
16023 sed 's/^/| /' conftest.$ac_ext >&5
16024
16025 ac_cv_lib_m_hypotf=no
16026 fi
16027 rm -f conftest.err conftest.$ac_objext \
16028       conftest$ac_exeext conftest.$ac_ext
16029 LIBS=$ac_check_lib_save_LIBS
16030 fi
16031 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypotf" >&5
16032 echo "${ECHO_T}$ac_cv_lib_m_hypotf" >&6
16033 if test $ac_cv_lib_m_hypotf = yes; then
16034
16035 cat >>confdefs.h <<\_ACEOF
16036 #define HAVE_HYPOTF 1
16037 _ACEOF
16038
16039 fi
16040
16041 echo "$as_me:$LINENO: checking for hypot in -lm" >&5
16042 echo $ECHO_N "checking for hypot in -lm... $ECHO_C" >&6
16043 if test "${ac_cv_lib_m_hypot+set}" = set; then
16044   echo $ECHO_N "(cached) $ECHO_C" >&6
16045 else
16046   ac_check_lib_save_LIBS=$LIBS
16047 LIBS="-lm  $LIBS"
16048 if test x$gcc_no_link = xyes; then
16049   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16050 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16051    { (exit 1); exit 1; }; }
16052 fi
16053 cat >conftest.$ac_ext <<_ACEOF
16054 /* confdefs.h.  */
16055 _ACEOF
16056 cat confdefs.h >>conftest.$ac_ext
16057 cat >>conftest.$ac_ext <<_ACEOF
16058 /* end confdefs.h.  */
16059
16060 /* Override any gcc2 internal prototype to avoid an error.  */
16061 #ifdef __cplusplus
16062 extern "C"
16063 #endif
16064 /* We use char because int might match the return type of a gcc2
16065    builtin and then its argument prototype would still apply.  */
16066 char hypot ();
16067 int
16068 main ()
16069 {
16070 hypot ();
16071   ;
16072   return 0;
16073 }
16074 _ACEOF
16075 rm -f conftest.$ac_objext conftest$ac_exeext
16076 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16077   (eval $ac_link) 2>conftest.er1
16078   ac_status=$?
16079   grep -v '^ *+' conftest.er1 >conftest.err
16080   rm -f conftest.er1
16081   cat conftest.err >&5
16082   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16083   (exit $ac_status); } &&
16084          { ac_try='test -z "$ac_c_werror_flag"
16085                          || test ! -s conftest.err'
16086   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16087   (eval $ac_try) 2>&5
16088   ac_status=$?
16089   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16090   (exit $ac_status); }; } &&
16091          { ac_try='test -s conftest$ac_exeext'
16092   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16093   (eval $ac_try) 2>&5
16094   ac_status=$?
16095   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16096   (exit $ac_status); }; }; then
16097   ac_cv_lib_m_hypot=yes
16098 else
16099   echo "$as_me: failed program was:" >&5
16100 sed 's/^/| /' conftest.$ac_ext >&5
16101
16102 ac_cv_lib_m_hypot=no
16103 fi
16104 rm -f conftest.err conftest.$ac_objext \
16105       conftest$ac_exeext conftest.$ac_ext
16106 LIBS=$ac_check_lib_save_LIBS
16107 fi
16108 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypot" >&5
16109 echo "${ECHO_T}$ac_cv_lib_m_hypot" >&6
16110 if test $ac_cv_lib_m_hypot = yes; then
16111
16112 cat >>confdefs.h <<\_ACEOF
16113 #define HAVE_HYPOT 1
16114 _ACEOF
16115
16116 fi
16117
16118 echo "$as_me:$LINENO: checking for hypotl in -lm" >&5
16119 echo $ECHO_N "checking for hypotl in -lm... $ECHO_C" >&6
16120 if test "${ac_cv_lib_m_hypotl+set}" = set; then
16121   echo $ECHO_N "(cached) $ECHO_C" >&6
16122 else
16123   ac_check_lib_save_LIBS=$LIBS
16124 LIBS="-lm  $LIBS"
16125 if test x$gcc_no_link = xyes; then
16126   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16127 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16128    { (exit 1); exit 1; }; }
16129 fi
16130 cat >conftest.$ac_ext <<_ACEOF
16131 /* confdefs.h.  */
16132 _ACEOF
16133 cat confdefs.h >>conftest.$ac_ext
16134 cat >>conftest.$ac_ext <<_ACEOF
16135 /* end confdefs.h.  */
16136
16137 /* Override any gcc2 internal prototype to avoid an error.  */
16138 #ifdef __cplusplus
16139 extern "C"
16140 #endif
16141 /* We use char because int might match the return type of a gcc2
16142    builtin and then its argument prototype would still apply.  */
16143 char hypotl ();
16144 int
16145 main ()
16146 {
16147 hypotl ();
16148   ;
16149   return 0;
16150 }
16151 _ACEOF
16152 rm -f conftest.$ac_objext conftest$ac_exeext
16153 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16154   (eval $ac_link) 2>conftest.er1
16155   ac_status=$?
16156   grep -v '^ *+' conftest.er1 >conftest.err
16157   rm -f conftest.er1
16158   cat conftest.err >&5
16159   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16160   (exit $ac_status); } &&
16161          { ac_try='test -z "$ac_c_werror_flag"
16162                          || test ! -s conftest.err'
16163   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16164   (eval $ac_try) 2>&5
16165   ac_status=$?
16166   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16167   (exit $ac_status); }; } &&
16168          { ac_try='test -s conftest$ac_exeext'
16169   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16170   (eval $ac_try) 2>&5
16171   ac_status=$?
16172   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16173   (exit $ac_status); }; }; then
16174   ac_cv_lib_m_hypotl=yes
16175 else
16176   echo "$as_me: failed program was:" >&5
16177 sed 's/^/| /' conftest.$ac_ext >&5
16178
16179 ac_cv_lib_m_hypotl=no
16180 fi
16181 rm -f conftest.err conftest.$ac_objext \
16182       conftest$ac_exeext conftest.$ac_ext
16183 LIBS=$ac_check_lib_save_LIBS
16184 fi
16185 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypotl" >&5
16186 echo "${ECHO_T}$ac_cv_lib_m_hypotl" >&6
16187 if test $ac_cv_lib_m_hypotl = yes; then
16188
16189 cat >>confdefs.h <<\_ACEOF
16190 #define HAVE_HYPOTL 1
16191 _ACEOF
16192
16193 fi
16194
16195 echo "$as_me:$LINENO: checking for ldexpf in -lm" >&5
16196 echo $ECHO_N "checking for ldexpf in -lm... $ECHO_C" >&6
16197 if test "${ac_cv_lib_m_ldexpf+set}" = set; then
16198   echo $ECHO_N "(cached) $ECHO_C" >&6
16199 else
16200   ac_check_lib_save_LIBS=$LIBS
16201 LIBS="-lm  $LIBS"
16202 if test x$gcc_no_link = xyes; then
16203   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16204 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16205    { (exit 1); exit 1; }; }
16206 fi
16207 cat >conftest.$ac_ext <<_ACEOF
16208 /* confdefs.h.  */
16209 _ACEOF
16210 cat confdefs.h >>conftest.$ac_ext
16211 cat >>conftest.$ac_ext <<_ACEOF
16212 /* end confdefs.h.  */
16213
16214 /* Override any gcc2 internal prototype to avoid an error.  */
16215 #ifdef __cplusplus
16216 extern "C"
16217 #endif
16218 /* We use char because int might match the return type of a gcc2
16219    builtin and then its argument prototype would still apply.  */
16220 char ldexpf ();
16221 int
16222 main ()
16223 {
16224 ldexpf ();
16225   ;
16226   return 0;
16227 }
16228 _ACEOF
16229 rm -f conftest.$ac_objext conftest$ac_exeext
16230 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16231   (eval $ac_link) 2>conftest.er1
16232   ac_status=$?
16233   grep -v '^ *+' conftest.er1 >conftest.err
16234   rm -f conftest.er1
16235   cat conftest.err >&5
16236   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16237   (exit $ac_status); } &&
16238          { ac_try='test -z "$ac_c_werror_flag"
16239                          || test ! -s conftest.err'
16240   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16241   (eval $ac_try) 2>&5
16242   ac_status=$?
16243   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16244   (exit $ac_status); }; } &&
16245          { ac_try='test -s conftest$ac_exeext'
16246   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16247   (eval $ac_try) 2>&5
16248   ac_status=$?
16249   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16250   (exit $ac_status); }; }; then
16251   ac_cv_lib_m_ldexpf=yes
16252 else
16253   echo "$as_me: failed program was:" >&5
16254 sed 's/^/| /' conftest.$ac_ext >&5
16255
16256 ac_cv_lib_m_ldexpf=no
16257 fi
16258 rm -f conftest.err conftest.$ac_objext \
16259       conftest$ac_exeext conftest.$ac_ext
16260 LIBS=$ac_check_lib_save_LIBS
16261 fi
16262 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ldexpf" >&5
16263 echo "${ECHO_T}$ac_cv_lib_m_ldexpf" >&6
16264 if test $ac_cv_lib_m_ldexpf = yes; then
16265
16266 cat >>confdefs.h <<\_ACEOF
16267 #define HAVE_LDEXPF 1
16268 _ACEOF
16269
16270 fi
16271
16272 echo "$as_me:$LINENO: checking for ldexp in -lm" >&5
16273 echo $ECHO_N "checking for ldexp in -lm... $ECHO_C" >&6
16274 if test "${ac_cv_lib_m_ldexp+set}" = set; then
16275   echo $ECHO_N "(cached) $ECHO_C" >&6
16276 else
16277   ac_check_lib_save_LIBS=$LIBS
16278 LIBS="-lm  $LIBS"
16279 if test x$gcc_no_link = xyes; then
16280   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16281 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16282    { (exit 1); exit 1; }; }
16283 fi
16284 cat >conftest.$ac_ext <<_ACEOF
16285 /* confdefs.h.  */
16286 _ACEOF
16287 cat confdefs.h >>conftest.$ac_ext
16288 cat >>conftest.$ac_ext <<_ACEOF
16289 /* end confdefs.h.  */
16290
16291 /* Override any gcc2 internal prototype to avoid an error.  */
16292 #ifdef __cplusplus
16293 extern "C"
16294 #endif
16295 /* We use char because int might match the return type of a gcc2
16296    builtin and then its argument prototype would still apply.  */
16297 char ldexp ();
16298 int
16299 main ()
16300 {
16301 ldexp ();
16302   ;
16303   return 0;
16304 }
16305 _ACEOF
16306 rm -f conftest.$ac_objext conftest$ac_exeext
16307 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16308   (eval $ac_link) 2>conftest.er1
16309   ac_status=$?
16310   grep -v '^ *+' conftest.er1 >conftest.err
16311   rm -f conftest.er1
16312   cat conftest.err >&5
16313   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16314   (exit $ac_status); } &&
16315          { ac_try='test -z "$ac_c_werror_flag"
16316                          || test ! -s conftest.err'
16317   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16318   (eval $ac_try) 2>&5
16319   ac_status=$?
16320   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16321   (exit $ac_status); }; } &&
16322          { ac_try='test -s conftest$ac_exeext'
16323   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16324   (eval $ac_try) 2>&5
16325   ac_status=$?
16326   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16327   (exit $ac_status); }; }; then
16328   ac_cv_lib_m_ldexp=yes
16329 else
16330   echo "$as_me: failed program was:" >&5
16331 sed 's/^/| /' conftest.$ac_ext >&5
16332
16333 ac_cv_lib_m_ldexp=no
16334 fi
16335 rm -f conftest.err conftest.$ac_objext \
16336       conftest$ac_exeext conftest.$ac_ext
16337 LIBS=$ac_check_lib_save_LIBS
16338 fi
16339 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ldexp" >&5
16340 echo "${ECHO_T}$ac_cv_lib_m_ldexp" >&6
16341 if test $ac_cv_lib_m_ldexp = yes; then
16342
16343 cat >>confdefs.h <<\_ACEOF
16344 #define HAVE_LDEXP 1
16345 _ACEOF
16346
16347 fi
16348
16349 echo "$as_me:$LINENO: checking for ldexpl in -lm" >&5
16350 echo $ECHO_N "checking for ldexpl in -lm... $ECHO_C" >&6
16351 if test "${ac_cv_lib_m_ldexpl+set}" = set; then
16352   echo $ECHO_N "(cached) $ECHO_C" >&6
16353 else
16354   ac_check_lib_save_LIBS=$LIBS
16355 LIBS="-lm  $LIBS"
16356 if test x$gcc_no_link = xyes; then
16357   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16358 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16359    { (exit 1); exit 1; }; }
16360 fi
16361 cat >conftest.$ac_ext <<_ACEOF
16362 /* confdefs.h.  */
16363 _ACEOF
16364 cat confdefs.h >>conftest.$ac_ext
16365 cat >>conftest.$ac_ext <<_ACEOF
16366 /* end confdefs.h.  */
16367
16368 /* Override any gcc2 internal prototype to avoid an error.  */
16369 #ifdef __cplusplus
16370 extern "C"
16371 #endif
16372 /* We use char because int might match the return type of a gcc2
16373    builtin and then its argument prototype would still apply.  */
16374 char ldexpl ();
16375 int
16376 main ()
16377 {
16378 ldexpl ();
16379   ;
16380   return 0;
16381 }
16382 _ACEOF
16383 rm -f conftest.$ac_objext conftest$ac_exeext
16384 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16385   (eval $ac_link) 2>conftest.er1
16386   ac_status=$?
16387   grep -v '^ *+' conftest.er1 >conftest.err
16388   rm -f conftest.er1
16389   cat conftest.err >&5
16390   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16391   (exit $ac_status); } &&
16392          { ac_try='test -z "$ac_c_werror_flag"
16393                          || test ! -s conftest.err'
16394   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16395   (eval $ac_try) 2>&5
16396   ac_status=$?
16397   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16398   (exit $ac_status); }; } &&
16399          { ac_try='test -s conftest$ac_exeext'
16400   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16401   (eval $ac_try) 2>&5
16402   ac_status=$?
16403   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16404   (exit $ac_status); }; }; then
16405   ac_cv_lib_m_ldexpl=yes
16406 else
16407   echo "$as_me: failed program was:" >&5
16408 sed 's/^/| /' conftest.$ac_ext >&5
16409
16410 ac_cv_lib_m_ldexpl=no
16411 fi
16412 rm -f conftest.err conftest.$ac_objext \
16413       conftest$ac_exeext conftest.$ac_ext
16414 LIBS=$ac_check_lib_save_LIBS
16415 fi
16416 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ldexpl" >&5
16417 echo "${ECHO_T}$ac_cv_lib_m_ldexpl" >&6
16418 if test $ac_cv_lib_m_ldexpl = yes; then
16419
16420 cat >>confdefs.h <<\_ACEOF
16421 #define HAVE_LDEXPL 1
16422 _ACEOF
16423
16424 fi
16425
16426 echo "$as_me:$LINENO: checking for logf in -lm" >&5
16427 echo $ECHO_N "checking for logf in -lm... $ECHO_C" >&6
16428 if test "${ac_cv_lib_m_logf+set}" = set; then
16429   echo $ECHO_N "(cached) $ECHO_C" >&6
16430 else
16431   ac_check_lib_save_LIBS=$LIBS
16432 LIBS="-lm  $LIBS"
16433 if test x$gcc_no_link = xyes; then
16434   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16435 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16436    { (exit 1); exit 1; }; }
16437 fi
16438 cat >conftest.$ac_ext <<_ACEOF
16439 /* confdefs.h.  */
16440 _ACEOF
16441 cat confdefs.h >>conftest.$ac_ext
16442 cat >>conftest.$ac_ext <<_ACEOF
16443 /* end confdefs.h.  */
16444
16445 /* Override any gcc2 internal prototype to avoid an error.  */
16446 #ifdef __cplusplus
16447 extern "C"
16448 #endif
16449 /* We use char because int might match the return type of a gcc2
16450    builtin and then its argument prototype would still apply.  */
16451 char logf ();
16452 int
16453 main ()
16454 {
16455 logf ();
16456   ;
16457   return 0;
16458 }
16459 _ACEOF
16460 rm -f conftest.$ac_objext conftest$ac_exeext
16461 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16462   (eval $ac_link) 2>conftest.er1
16463   ac_status=$?
16464   grep -v '^ *+' conftest.er1 >conftest.err
16465   rm -f conftest.er1
16466   cat conftest.err >&5
16467   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16468   (exit $ac_status); } &&
16469          { ac_try='test -z "$ac_c_werror_flag"
16470                          || test ! -s conftest.err'
16471   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16472   (eval $ac_try) 2>&5
16473   ac_status=$?
16474   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16475   (exit $ac_status); }; } &&
16476          { ac_try='test -s conftest$ac_exeext'
16477   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16478   (eval $ac_try) 2>&5
16479   ac_status=$?
16480   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16481   (exit $ac_status); }; }; then
16482   ac_cv_lib_m_logf=yes
16483 else
16484   echo "$as_me: failed program was:" >&5
16485 sed 's/^/| /' conftest.$ac_ext >&5
16486
16487 ac_cv_lib_m_logf=no
16488 fi
16489 rm -f conftest.err conftest.$ac_objext \
16490       conftest$ac_exeext conftest.$ac_ext
16491 LIBS=$ac_check_lib_save_LIBS
16492 fi
16493 echo "$as_me:$LINENO: result: $ac_cv_lib_m_logf" >&5
16494 echo "${ECHO_T}$ac_cv_lib_m_logf" >&6
16495 if test $ac_cv_lib_m_logf = yes; then
16496
16497 cat >>confdefs.h <<\_ACEOF
16498 #define HAVE_LOGF 1
16499 _ACEOF
16500
16501 fi
16502
16503 echo "$as_me:$LINENO: checking for log in -lm" >&5
16504 echo $ECHO_N "checking for log in -lm... $ECHO_C" >&6
16505 if test "${ac_cv_lib_m_log+set}" = set; then
16506   echo $ECHO_N "(cached) $ECHO_C" >&6
16507 else
16508   ac_check_lib_save_LIBS=$LIBS
16509 LIBS="-lm  $LIBS"
16510 if test x$gcc_no_link = xyes; then
16511   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16512 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16513    { (exit 1); exit 1; }; }
16514 fi
16515 cat >conftest.$ac_ext <<_ACEOF
16516 /* confdefs.h.  */
16517 _ACEOF
16518 cat confdefs.h >>conftest.$ac_ext
16519 cat >>conftest.$ac_ext <<_ACEOF
16520 /* end confdefs.h.  */
16521
16522 /* Override any gcc2 internal prototype to avoid an error.  */
16523 #ifdef __cplusplus
16524 extern "C"
16525 #endif
16526 /* We use char because int might match the return type of a gcc2
16527    builtin and then its argument prototype would still apply.  */
16528 char log ();
16529 int
16530 main ()
16531 {
16532 log ();
16533   ;
16534   return 0;
16535 }
16536 _ACEOF
16537 rm -f conftest.$ac_objext conftest$ac_exeext
16538 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16539   (eval $ac_link) 2>conftest.er1
16540   ac_status=$?
16541   grep -v '^ *+' conftest.er1 >conftest.err
16542   rm -f conftest.er1
16543   cat conftest.err >&5
16544   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16545   (exit $ac_status); } &&
16546          { ac_try='test -z "$ac_c_werror_flag"
16547                          || test ! -s conftest.err'
16548   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16549   (eval $ac_try) 2>&5
16550   ac_status=$?
16551   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16552   (exit $ac_status); }; } &&
16553          { ac_try='test -s conftest$ac_exeext'
16554   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16555   (eval $ac_try) 2>&5
16556   ac_status=$?
16557   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16558   (exit $ac_status); }; }; then
16559   ac_cv_lib_m_log=yes
16560 else
16561   echo "$as_me: failed program was:" >&5
16562 sed 's/^/| /' conftest.$ac_ext >&5
16563
16564 ac_cv_lib_m_log=no
16565 fi
16566 rm -f conftest.err conftest.$ac_objext \
16567       conftest$ac_exeext conftest.$ac_ext
16568 LIBS=$ac_check_lib_save_LIBS
16569 fi
16570 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log" >&5
16571 echo "${ECHO_T}$ac_cv_lib_m_log" >&6
16572 if test $ac_cv_lib_m_log = yes; then
16573
16574 cat >>confdefs.h <<\_ACEOF
16575 #define HAVE_LOG 1
16576 _ACEOF
16577
16578 fi
16579
16580 echo "$as_me:$LINENO: checking for logl in -lm" >&5
16581 echo $ECHO_N "checking for logl in -lm... $ECHO_C" >&6
16582 if test "${ac_cv_lib_m_logl+set}" = set; then
16583   echo $ECHO_N "(cached) $ECHO_C" >&6
16584 else
16585   ac_check_lib_save_LIBS=$LIBS
16586 LIBS="-lm  $LIBS"
16587 if test x$gcc_no_link = xyes; then
16588   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16589 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16590    { (exit 1); exit 1; }; }
16591 fi
16592 cat >conftest.$ac_ext <<_ACEOF
16593 /* confdefs.h.  */
16594 _ACEOF
16595 cat confdefs.h >>conftest.$ac_ext
16596 cat >>conftest.$ac_ext <<_ACEOF
16597 /* end confdefs.h.  */
16598
16599 /* Override any gcc2 internal prototype to avoid an error.  */
16600 #ifdef __cplusplus
16601 extern "C"
16602 #endif
16603 /* We use char because int might match the return type of a gcc2
16604    builtin and then its argument prototype would still apply.  */
16605 char logl ();
16606 int
16607 main ()
16608 {
16609 logl ();
16610   ;
16611   return 0;
16612 }
16613 _ACEOF
16614 rm -f conftest.$ac_objext conftest$ac_exeext
16615 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16616   (eval $ac_link) 2>conftest.er1
16617   ac_status=$?
16618   grep -v '^ *+' conftest.er1 >conftest.err
16619   rm -f conftest.er1
16620   cat conftest.err >&5
16621   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16622   (exit $ac_status); } &&
16623          { ac_try='test -z "$ac_c_werror_flag"
16624                          || test ! -s conftest.err'
16625   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16626   (eval $ac_try) 2>&5
16627   ac_status=$?
16628   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16629   (exit $ac_status); }; } &&
16630          { ac_try='test -s conftest$ac_exeext'
16631   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16632   (eval $ac_try) 2>&5
16633   ac_status=$?
16634   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16635   (exit $ac_status); }; }; then
16636   ac_cv_lib_m_logl=yes
16637 else
16638   echo "$as_me: failed program was:" >&5
16639 sed 's/^/| /' conftest.$ac_ext >&5
16640
16641 ac_cv_lib_m_logl=no
16642 fi
16643 rm -f conftest.err conftest.$ac_objext \
16644       conftest$ac_exeext conftest.$ac_ext
16645 LIBS=$ac_check_lib_save_LIBS
16646 fi
16647 echo "$as_me:$LINENO: result: $ac_cv_lib_m_logl" >&5
16648 echo "${ECHO_T}$ac_cv_lib_m_logl" >&6
16649 if test $ac_cv_lib_m_logl = yes; then
16650
16651 cat >>confdefs.h <<\_ACEOF
16652 #define HAVE_LOGL 1
16653 _ACEOF
16654
16655 fi
16656
16657 echo "$as_me:$LINENO: checking for clogf in -lm" >&5
16658 echo $ECHO_N "checking for clogf in -lm... $ECHO_C" >&6
16659 if test "${ac_cv_lib_m_clogf+set}" = set; then
16660   echo $ECHO_N "(cached) $ECHO_C" >&6
16661 else
16662   ac_check_lib_save_LIBS=$LIBS
16663 LIBS="-lm  $LIBS"
16664 if test x$gcc_no_link = xyes; then
16665   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16666 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16667    { (exit 1); exit 1; }; }
16668 fi
16669 cat >conftest.$ac_ext <<_ACEOF
16670 /* confdefs.h.  */
16671 _ACEOF
16672 cat confdefs.h >>conftest.$ac_ext
16673 cat >>conftest.$ac_ext <<_ACEOF
16674 /* end confdefs.h.  */
16675
16676 /* Override any gcc2 internal prototype to avoid an error.  */
16677 #ifdef __cplusplus
16678 extern "C"
16679 #endif
16680 /* We use char because int might match the return type of a gcc2
16681    builtin and then its argument prototype would still apply.  */
16682 char clogf ();
16683 int
16684 main ()
16685 {
16686 clogf ();
16687   ;
16688   return 0;
16689 }
16690 _ACEOF
16691 rm -f conftest.$ac_objext conftest$ac_exeext
16692 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16693   (eval $ac_link) 2>conftest.er1
16694   ac_status=$?
16695   grep -v '^ *+' conftest.er1 >conftest.err
16696   rm -f conftest.er1
16697   cat conftest.err >&5
16698   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16699   (exit $ac_status); } &&
16700          { ac_try='test -z "$ac_c_werror_flag"
16701                          || test ! -s conftest.err'
16702   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16703   (eval $ac_try) 2>&5
16704   ac_status=$?
16705   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16706   (exit $ac_status); }; } &&
16707          { ac_try='test -s conftest$ac_exeext'
16708   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16709   (eval $ac_try) 2>&5
16710   ac_status=$?
16711   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16712   (exit $ac_status); }; }; then
16713   ac_cv_lib_m_clogf=yes
16714 else
16715   echo "$as_me: failed program was:" >&5
16716 sed 's/^/| /' conftest.$ac_ext >&5
16717
16718 ac_cv_lib_m_clogf=no
16719 fi
16720 rm -f conftest.err conftest.$ac_objext \
16721       conftest$ac_exeext conftest.$ac_ext
16722 LIBS=$ac_check_lib_save_LIBS
16723 fi
16724 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clogf" >&5
16725 echo "${ECHO_T}$ac_cv_lib_m_clogf" >&6
16726 if test $ac_cv_lib_m_clogf = yes; then
16727
16728 cat >>confdefs.h <<\_ACEOF
16729 #define HAVE_CLOGF 1
16730 _ACEOF
16731
16732 fi
16733
16734 echo "$as_me:$LINENO: checking for clog in -lm" >&5
16735 echo $ECHO_N "checking for clog in -lm... $ECHO_C" >&6
16736 if test "${ac_cv_lib_m_clog+set}" = set; then
16737   echo $ECHO_N "(cached) $ECHO_C" >&6
16738 else
16739   ac_check_lib_save_LIBS=$LIBS
16740 LIBS="-lm  $LIBS"
16741 if test x$gcc_no_link = xyes; then
16742   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16743 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16744    { (exit 1); exit 1; }; }
16745 fi
16746 cat >conftest.$ac_ext <<_ACEOF
16747 /* confdefs.h.  */
16748 _ACEOF
16749 cat confdefs.h >>conftest.$ac_ext
16750 cat >>conftest.$ac_ext <<_ACEOF
16751 /* end confdefs.h.  */
16752
16753 /* Override any gcc2 internal prototype to avoid an error.  */
16754 #ifdef __cplusplus
16755 extern "C"
16756 #endif
16757 /* We use char because int might match the return type of a gcc2
16758    builtin and then its argument prototype would still apply.  */
16759 char clog ();
16760 int
16761 main ()
16762 {
16763 clog ();
16764   ;
16765   return 0;
16766 }
16767 _ACEOF
16768 rm -f conftest.$ac_objext conftest$ac_exeext
16769 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16770   (eval $ac_link) 2>conftest.er1
16771   ac_status=$?
16772   grep -v '^ *+' conftest.er1 >conftest.err
16773   rm -f conftest.er1
16774   cat conftest.err >&5
16775   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16776   (exit $ac_status); } &&
16777          { ac_try='test -z "$ac_c_werror_flag"
16778                          || test ! -s conftest.err'
16779   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16780   (eval $ac_try) 2>&5
16781   ac_status=$?
16782   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16783   (exit $ac_status); }; } &&
16784          { ac_try='test -s conftest$ac_exeext'
16785   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16786   (eval $ac_try) 2>&5
16787   ac_status=$?
16788   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16789   (exit $ac_status); }; }; then
16790   ac_cv_lib_m_clog=yes
16791 else
16792   echo "$as_me: failed program was:" >&5
16793 sed 's/^/| /' conftest.$ac_ext >&5
16794
16795 ac_cv_lib_m_clog=no
16796 fi
16797 rm -f conftest.err conftest.$ac_objext \
16798       conftest$ac_exeext conftest.$ac_ext
16799 LIBS=$ac_check_lib_save_LIBS
16800 fi
16801 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog" >&5
16802 echo "${ECHO_T}$ac_cv_lib_m_clog" >&6
16803 if test $ac_cv_lib_m_clog = yes; then
16804
16805 cat >>confdefs.h <<\_ACEOF
16806 #define HAVE_CLOG 1
16807 _ACEOF
16808
16809 fi
16810
16811 echo "$as_me:$LINENO: checking for clogl in -lm" >&5
16812 echo $ECHO_N "checking for clogl in -lm... $ECHO_C" >&6
16813 if test "${ac_cv_lib_m_clogl+set}" = set; then
16814   echo $ECHO_N "(cached) $ECHO_C" >&6
16815 else
16816   ac_check_lib_save_LIBS=$LIBS
16817 LIBS="-lm  $LIBS"
16818 if test x$gcc_no_link = xyes; then
16819   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16820 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16821    { (exit 1); exit 1; }; }
16822 fi
16823 cat >conftest.$ac_ext <<_ACEOF
16824 /* confdefs.h.  */
16825 _ACEOF
16826 cat confdefs.h >>conftest.$ac_ext
16827 cat >>conftest.$ac_ext <<_ACEOF
16828 /* end confdefs.h.  */
16829
16830 /* Override any gcc2 internal prototype to avoid an error.  */
16831 #ifdef __cplusplus
16832 extern "C"
16833 #endif
16834 /* We use char because int might match the return type of a gcc2
16835    builtin and then its argument prototype would still apply.  */
16836 char clogl ();
16837 int
16838 main ()
16839 {
16840 clogl ();
16841   ;
16842   return 0;
16843 }
16844 _ACEOF
16845 rm -f conftest.$ac_objext conftest$ac_exeext
16846 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16847   (eval $ac_link) 2>conftest.er1
16848   ac_status=$?
16849   grep -v '^ *+' conftest.er1 >conftest.err
16850   rm -f conftest.er1
16851   cat conftest.err >&5
16852   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16853   (exit $ac_status); } &&
16854          { ac_try='test -z "$ac_c_werror_flag"
16855                          || test ! -s conftest.err'
16856   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16857   (eval $ac_try) 2>&5
16858   ac_status=$?
16859   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16860   (exit $ac_status); }; } &&
16861          { ac_try='test -s conftest$ac_exeext'
16862   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16863   (eval $ac_try) 2>&5
16864   ac_status=$?
16865   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16866   (exit $ac_status); }; }; then
16867   ac_cv_lib_m_clogl=yes
16868 else
16869   echo "$as_me: failed program was:" >&5
16870 sed 's/^/| /' conftest.$ac_ext >&5
16871
16872 ac_cv_lib_m_clogl=no
16873 fi
16874 rm -f conftest.err conftest.$ac_objext \
16875       conftest$ac_exeext conftest.$ac_ext
16876 LIBS=$ac_check_lib_save_LIBS
16877 fi
16878 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clogl" >&5
16879 echo "${ECHO_T}$ac_cv_lib_m_clogl" >&6
16880 if test $ac_cv_lib_m_clogl = yes; then
16881
16882 cat >>confdefs.h <<\_ACEOF
16883 #define HAVE_CLOGL 1
16884 _ACEOF
16885
16886 fi
16887
16888 echo "$as_me:$LINENO: checking for log10f in -lm" >&5
16889 echo $ECHO_N "checking for log10f in -lm... $ECHO_C" >&6
16890 if test "${ac_cv_lib_m_log10f+set}" = set; then
16891   echo $ECHO_N "(cached) $ECHO_C" >&6
16892 else
16893   ac_check_lib_save_LIBS=$LIBS
16894 LIBS="-lm  $LIBS"
16895 if test x$gcc_no_link = xyes; then
16896   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16897 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16898    { (exit 1); exit 1; }; }
16899 fi
16900 cat >conftest.$ac_ext <<_ACEOF
16901 /* confdefs.h.  */
16902 _ACEOF
16903 cat confdefs.h >>conftest.$ac_ext
16904 cat >>conftest.$ac_ext <<_ACEOF
16905 /* end confdefs.h.  */
16906
16907 /* Override any gcc2 internal prototype to avoid an error.  */
16908 #ifdef __cplusplus
16909 extern "C"
16910 #endif
16911 /* We use char because int might match the return type of a gcc2
16912    builtin and then its argument prototype would still apply.  */
16913 char log10f ();
16914 int
16915 main ()
16916 {
16917 log10f ();
16918   ;
16919   return 0;
16920 }
16921 _ACEOF
16922 rm -f conftest.$ac_objext conftest$ac_exeext
16923 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16924   (eval $ac_link) 2>conftest.er1
16925   ac_status=$?
16926   grep -v '^ *+' conftest.er1 >conftest.err
16927   rm -f conftest.er1
16928   cat conftest.err >&5
16929   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16930   (exit $ac_status); } &&
16931          { ac_try='test -z "$ac_c_werror_flag"
16932                          || test ! -s conftest.err'
16933   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16934   (eval $ac_try) 2>&5
16935   ac_status=$?
16936   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16937   (exit $ac_status); }; } &&
16938          { ac_try='test -s conftest$ac_exeext'
16939   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16940   (eval $ac_try) 2>&5
16941   ac_status=$?
16942   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16943   (exit $ac_status); }; }; then
16944   ac_cv_lib_m_log10f=yes
16945 else
16946   echo "$as_me: failed program was:" >&5
16947 sed 's/^/| /' conftest.$ac_ext >&5
16948
16949 ac_cv_lib_m_log10f=no
16950 fi
16951 rm -f conftest.err conftest.$ac_objext \
16952       conftest$ac_exeext conftest.$ac_ext
16953 LIBS=$ac_check_lib_save_LIBS
16954 fi
16955 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10f" >&5
16956 echo "${ECHO_T}$ac_cv_lib_m_log10f" >&6
16957 if test $ac_cv_lib_m_log10f = yes; then
16958
16959 cat >>confdefs.h <<\_ACEOF
16960 #define HAVE_LOG10F 1
16961 _ACEOF
16962
16963 fi
16964
16965 echo "$as_me:$LINENO: checking for log10 in -lm" >&5
16966 echo $ECHO_N "checking for log10 in -lm... $ECHO_C" >&6
16967 if test "${ac_cv_lib_m_log10+set}" = set; then
16968   echo $ECHO_N "(cached) $ECHO_C" >&6
16969 else
16970   ac_check_lib_save_LIBS=$LIBS
16971 LIBS="-lm  $LIBS"
16972 if test x$gcc_no_link = xyes; then
16973   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16974 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16975    { (exit 1); exit 1; }; }
16976 fi
16977 cat >conftest.$ac_ext <<_ACEOF
16978 /* confdefs.h.  */
16979 _ACEOF
16980 cat confdefs.h >>conftest.$ac_ext
16981 cat >>conftest.$ac_ext <<_ACEOF
16982 /* end confdefs.h.  */
16983
16984 /* Override any gcc2 internal prototype to avoid an error.  */
16985 #ifdef __cplusplus
16986 extern "C"
16987 #endif
16988 /* We use char because int might match the return type of a gcc2
16989    builtin and then its argument prototype would still apply.  */
16990 char log10 ();
16991 int
16992 main ()
16993 {
16994 log10 ();
16995   ;
16996   return 0;
16997 }
16998 _ACEOF
16999 rm -f conftest.$ac_objext conftest$ac_exeext
17000 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17001   (eval $ac_link) 2>conftest.er1
17002   ac_status=$?
17003   grep -v '^ *+' conftest.er1 >conftest.err
17004   rm -f conftest.er1
17005   cat conftest.err >&5
17006   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17007   (exit $ac_status); } &&
17008          { ac_try='test -z "$ac_c_werror_flag"
17009                          || test ! -s conftest.err'
17010   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17011   (eval $ac_try) 2>&5
17012   ac_status=$?
17013   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17014   (exit $ac_status); }; } &&
17015          { ac_try='test -s conftest$ac_exeext'
17016   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17017   (eval $ac_try) 2>&5
17018   ac_status=$?
17019   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17020   (exit $ac_status); }; }; then
17021   ac_cv_lib_m_log10=yes
17022 else
17023   echo "$as_me: failed program was:" >&5
17024 sed 's/^/| /' conftest.$ac_ext >&5
17025
17026 ac_cv_lib_m_log10=no
17027 fi
17028 rm -f conftest.err conftest.$ac_objext \
17029       conftest$ac_exeext conftest.$ac_ext
17030 LIBS=$ac_check_lib_save_LIBS
17031 fi
17032 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10" >&5
17033 echo "${ECHO_T}$ac_cv_lib_m_log10" >&6
17034 if test $ac_cv_lib_m_log10 = yes; then
17035
17036 cat >>confdefs.h <<\_ACEOF
17037 #define HAVE_LOG10 1
17038 _ACEOF
17039
17040 fi
17041
17042 echo "$as_me:$LINENO: checking for log10l in -lm" >&5
17043 echo $ECHO_N "checking for log10l in -lm... $ECHO_C" >&6
17044 if test "${ac_cv_lib_m_log10l+set}" = set; then
17045   echo $ECHO_N "(cached) $ECHO_C" >&6
17046 else
17047   ac_check_lib_save_LIBS=$LIBS
17048 LIBS="-lm  $LIBS"
17049 if test x$gcc_no_link = xyes; then
17050   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17051 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17052    { (exit 1); exit 1; }; }
17053 fi
17054 cat >conftest.$ac_ext <<_ACEOF
17055 /* confdefs.h.  */
17056 _ACEOF
17057 cat confdefs.h >>conftest.$ac_ext
17058 cat >>conftest.$ac_ext <<_ACEOF
17059 /* end confdefs.h.  */
17060
17061 /* Override any gcc2 internal prototype to avoid an error.  */
17062 #ifdef __cplusplus
17063 extern "C"
17064 #endif
17065 /* We use char because int might match the return type of a gcc2
17066    builtin and then its argument prototype would still apply.  */
17067 char log10l ();
17068 int
17069 main ()
17070 {
17071 log10l ();
17072   ;
17073   return 0;
17074 }
17075 _ACEOF
17076 rm -f conftest.$ac_objext conftest$ac_exeext
17077 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17078   (eval $ac_link) 2>conftest.er1
17079   ac_status=$?
17080   grep -v '^ *+' conftest.er1 >conftest.err
17081   rm -f conftest.er1
17082   cat conftest.err >&5
17083   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17084   (exit $ac_status); } &&
17085          { ac_try='test -z "$ac_c_werror_flag"
17086                          || test ! -s conftest.err'
17087   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17088   (eval $ac_try) 2>&5
17089   ac_status=$?
17090   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17091   (exit $ac_status); }; } &&
17092          { ac_try='test -s conftest$ac_exeext'
17093   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17094   (eval $ac_try) 2>&5
17095   ac_status=$?
17096   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17097   (exit $ac_status); }; }; then
17098   ac_cv_lib_m_log10l=yes
17099 else
17100   echo "$as_me: failed program was:" >&5
17101 sed 's/^/| /' conftest.$ac_ext >&5
17102
17103 ac_cv_lib_m_log10l=no
17104 fi
17105 rm -f conftest.err conftest.$ac_objext \
17106       conftest$ac_exeext conftest.$ac_ext
17107 LIBS=$ac_check_lib_save_LIBS
17108 fi
17109 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10l" >&5
17110 echo "${ECHO_T}$ac_cv_lib_m_log10l" >&6
17111 if test $ac_cv_lib_m_log10l = yes; then
17112
17113 cat >>confdefs.h <<\_ACEOF
17114 #define HAVE_LOG10L 1
17115 _ACEOF
17116
17117 fi
17118
17119 echo "$as_me:$LINENO: checking for clog10f in -lm" >&5
17120 echo $ECHO_N "checking for clog10f in -lm... $ECHO_C" >&6
17121 if test "${ac_cv_lib_m_clog10f+set}" = set; then
17122   echo $ECHO_N "(cached) $ECHO_C" >&6
17123 else
17124   ac_check_lib_save_LIBS=$LIBS
17125 LIBS="-lm  $LIBS"
17126 if test x$gcc_no_link = xyes; then
17127   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17128 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17129    { (exit 1); exit 1; }; }
17130 fi
17131 cat >conftest.$ac_ext <<_ACEOF
17132 /* confdefs.h.  */
17133 _ACEOF
17134 cat confdefs.h >>conftest.$ac_ext
17135 cat >>conftest.$ac_ext <<_ACEOF
17136 /* end confdefs.h.  */
17137
17138 /* Override any gcc2 internal prototype to avoid an error.  */
17139 #ifdef __cplusplus
17140 extern "C"
17141 #endif
17142 /* We use char because int might match the return type of a gcc2
17143    builtin and then its argument prototype would still apply.  */
17144 char clog10f ();
17145 int
17146 main ()
17147 {
17148 clog10f ();
17149   ;
17150   return 0;
17151 }
17152 _ACEOF
17153 rm -f conftest.$ac_objext conftest$ac_exeext
17154 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17155   (eval $ac_link) 2>conftest.er1
17156   ac_status=$?
17157   grep -v '^ *+' conftest.er1 >conftest.err
17158   rm -f conftest.er1
17159   cat conftest.err >&5
17160   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17161   (exit $ac_status); } &&
17162          { ac_try='test -z "$ac_c_werror_flag"
17163                          || test ! -s conftest.err'
17164   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17165   (eval $ac_try) 2>&5
17166   ac_status=$?
17167   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17168   (exit $ac_status); }; } &&
17169          { ac_try='test -s conftest$ac_exeext'
17170   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17171   (eval $ac_try) 2>&5
17172   ac_status=$?
17173   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17174   (exit $ac_status); }; }; then
17175   ac_cv_lib_m_clog10f=yes
17176 else
17177   echo "$as_me: failed program was:" >&5
17178 sed 's/^/| /' conftest.$ac_ext >&5
17179
17180 ac_cv_lib_m_clog10f=no
17181 fi
17182 rm -f conftest.err conftest.$ac_objext \
17183       conftest$ac_exeext conftest.$ac_ext
17184 LIBS=$ac_check_lib_save_LIBS
17185 fi
17186 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10f" >&5
17187 echo "${ECHO_T}$ac_cv_lib_m_clog10f" >&6
17188 if test $ac_cv_lib_m_clog10f = yes; then
17189
17190 cat >>confdefs.h <<\_ACEOF
17191 #define HAVE_CLOG10F 1
17192 _ACEOF
17193
17194 fi
17195
17196 echo "$as_me:$LINENO: checking for clog10 in -lm" >&5
17197 echo $ECHO_N "checking for clog10 in -lm... $ECHO_C" >&6
17198 if test "${ac_cv_lib_m_clog10+set}" = set; then
17199   echo $ECHO_N "(cached) $ECHO_C" >&6
17200 else
17201   ac_check_lib_save_LIBS=$LIBS
17202 LIBS="-lm  $LIBS"
17203 if test x$gcc_no_link = xyes; then
17204   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17205 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17206    { (exit 1); exit 1; }; }
17207 fi
17208 cat >conftest.$ac_ext <<_ACEOF
17209 /* confdefs.h.  */
17210 _ACEOF
17211 cat confdefs.h >>conftest.$ac_ext
17212 cat >>conftest.$ac_ext <<_ACEOF
17213 /* end confdefs.h.  */
17214
17215 /* Override any gcc2 internal prototype to avoid an error.  */
17216 #ifdef __cplusplus
17217 extern "C"
17218 #endif
17219 /* We use char because int might match the return type of a gcc2
17220    builtin and then its argument prototype would still apply.  */
17221 char clog10 ();
17222 int
17223 main ()
17224 {
17225 clog10 ();
17226   ;
17227   return 0;
17228 }
17229 _ACEOF
17230 rm -f conftest.$ac_objext conftest$ac_exeext
17231 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17232   (eval $ac_link) 2>conftest.er1
17233   ac_status=$?
17234   grep -v '^ *+' conftest.er1 >conftest.err
17235   rm -f conftest.er1
17236   cat conftest.err >&5
17237   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17238   (exit $ac_status); } &&
17239          { ac_try='test -z "$ac_c_werror_flag"
17240                          || test ! -s conftest.err'
17241   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17242   (eval $ac_try) 2>&5
17243   ac_status=$?
17244   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17245   (exit $ac_status); }; } &&
17246          { ac_try='test -s conftest$ac_exeext'
17247   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17248   (eval $ac_try) 2>&5
17249   ac_status=$?
17250   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17251   (exit $ac_status); }; }; then
17252   ac_cv_lib_m_clog10=yes
17253 else
17254   echo "$as_me: failed program was:" >&5
17255 sed 's/^/| /' conftest.$ac_ext >&5
17256
17257 ac_cv_lib_m_clog10=no
17258 fi
17259 rm -f conftest.err conftest.$ac_objext \
17260       conftest$ac_exeext conftest.$ac_ext
17261 LIBS=$ac_check_lib_save_LIBS
17262 fi
17263 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10" >&5
17264 echo "${ECHO_T}$ac_cv_lib_m_clog10" >&6
17265 if test $ac_cv_lib_m_clog10 = yes; then
17266
17267 cat >>confdefs.h <<\_ACEOF
17268 #define HAVE_CLOG10 1
17269 _ACEOF
17270
17271 fi
17272
17273 echo "$as_me:$LINENO: checking for clog10l in -lm" >&5
17274 echo $ECHO_N "checking for clog10l in -lm... $ECHO_C" >&6
17275 if test "${ac_cv_lib_m_clog10l+set}" = set; then
17276   echo $ECHO_N "(cached) $ECHO_C" >&6
17277 else
17278   ac_check_lib_save_LIBS=$LIBS
17279 LIBS="-lm  $LIBS"
17280 if test x$gcc_no_link = xyes; then
17281   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17282 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17283    { (exit 1); exit 1; }; }
17284 fi
17285 cat >conftest.$ac_ext <<_ACEOF
17286 /* confdefs.h.  */
17287 _ACEOF
17288 cat confdefs.h >>conftest.$ac_ext
17289 cat >>conftest.$ac_ext <<_ACEOF
17290 /* end confdefs.h.  */
17291
17292 /* Override any gcc2 internal prototype to avoid an error.  */
17293 #ifdef __cplusplus
17294 extern "C"
17295 #endif
17296 /* We use char because int might match the return type of a gcc2
17297    builtin and then its argument prototype would still apply.  */
17298 char clog10l ();
17299 int
17300 main ()
17301 {
17302 clog10l ();
17303   ;
17304   return 0;
17305 }
17306 _ACEOF
17307 rm -f conftest.$ac_objext conftest$ac_exeext
17308 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17309   (eval $ac_link) 2>conftest.er1
17310   ac_status=$?
17311   grep -v '^ *+' conftest.er1 >conftest.err
17312   rm -f conftest.er1
17313   cat conftest.err >&5
17314   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17315   (exit $ac_status); } &&
17316          { ac_try='test -z "$ac_c_werror_flag"
17317                          || test ! -s conftest.err'
17318   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17319   (eval $ac_try) 2>&5
17320   ac_status=$?
17321   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17322   (exit $ac_status); }; } &&
17323          { ac_try='test -s conftest$ac_exeext'
17324   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17325   (eval $ac_try) 2>&5
17326   ac_status=$?
17327   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17328   (exit $ac_status); }; }; then
17329   ac_cv_lib_m_clog10l=yes
17330 else
17331   echo "$as_me: failed program was:" >&5
17332 sed 's/^/| /' conftest.$ac_ext >&5
17333
17334 ac_cv_lib_m_clog10l=no
17335 fi
17336 rm -f conftest.err conftest.$ac_objext \
17337       conftest$ac_exeext conftest.$ac_ext
17338 LIBS=$ac_check_lib_save_LIBS
17339 fi
17340 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10l" >&5
17341 echo "${ECHO_T}$ac_cv_lib_m_clog10l" >&6
17342 if test $ac_cv_lib_m_clog10l = yes; then
17343
17344 cat >>confdefs.h <<\_ACEOF
17345 #define HAVE_CLOG10L 1
17346 _ACEOF
17347
17348 fi
17349
17350 echo "$as_me:$LINENO: checking for nextafterf in -lm" >&5
17351 echo $ECHO_N "checking for nextafterf in -lm... $ECHO_C" >&6
17352 if test "${ac_cv_lib_m_nextafterf+set}" = set; then
17353   echo $ECHO_N "(cached) $ECHO_C" >&6
17354 else
17355   ac_check_lib_save_LIBS=$LIBS
17356 LIBS="-lm  $LIBS"
17357 if test x$gcc_no_link = xyes; then
17358   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17359 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17360    { (exit 1); exit 1; }; }
17361 fi
17362 cat >conftest.$ac_ext <<_ACEOF
17363 /* confdefs.h.  */
17364 _ACEOF
17365 cat confdefs.h >>conftest.$ac_ext
17366 cat >>conftest.$ac_ext <<_ACEOF
17367 /* end confdefs.h.  */
17368
17369 /* Override any gcc2 internal prototype to avoid an error.  */
17370 #ifdef __cplusplus
17371 extern "C"
17372 #endif
17373 /* We use char because int might match the return type of a gcc2
17374    builtin and then its argument prototype would still apply.  */
17375 char nextafterf ();
17376 int
17377 main ()
17378 {
17379 nextafterf ();
17380   ;
17381   return 0;
17382 }
17383 _ACEOF
17384 rm -f conftest.$ac_objext conftest$ac_exeext
17385 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17386   (eval $ac_link) 2>conftest.er1
17387   ac_status=$?
17388   grep -v '^ *+' conftest.er1 >conftest.err
17389   rm -f conftest.er1
17390   cat conftest.err >&5
17391   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17392   (exit $ac_status); } &&
17393          { ac_try='test -z "$ac_c_werror_flag"
17394                          || test ! -s conftest.err'
17395   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17396   (eval $ac_try) 2>&5
17397   ac_status=$?
17398   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17399   (exit $ac_status); }; } &&
17400          { ac_try='test -s conftest$ac_exeext'
17401   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17402   (eval $ac_try) 2>&5
17403   ac_status=$?
17404   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17405   (exit $ac_status); }; }; then
17406   ac_cv_lib_m_nextafterf=yes
17407 else
17408   echo "$as_me: failed program was:" >&5
17409 sed 's/^/| /' conftest.$ac_ext >&5
17410
17411 ac_cv_lib_m_nextafterf=no
17412 fi
17413 rm -f conftest.err conftest.$ac_objext \
17414       conftest$ac_exeext conftest.$ac_ext
17415 LIBS=$ac_check_lib_save_LIBS
17416 fi
17417 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafterf" >&5
17418 echo "${ECHO_T}$ac_cv_lib_m_nextafterf" >&6
17419 if test $ac_cv_lib_m_nextafterf = yes; then
17420
17421 cat >>confdefs.h <<\_ACEOF
17422 #define HAVE_NEXTAFTERF 1
17423 _ACEOF
17424
17425 fi
17426
17427 echo "$as_me:$LINENO: checking for nextafter in -lm" >&5
17428 echo $ECHO_N "checking for nextafter in -lm... $ECHO_C" >&6
17429 if test "${ac_cv_lib_m_nextafter+set}" = set; then
17430   echo $ECHO_N "(cached) $ECHO_C" >&6
17431 else
17432   ac_check_lib_save_LIBS=$LIBS
17433 LIBS="-lm  $LIBS"
17434 if test x$gcc_no_link = xyes; then
17435   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17436 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17437    { (exit 1); exit 1; }; }
17438 fi
17439 cat >conftest.$ac_ext <<_ACEOF
17440 /* confdefs.h.  */
17441 _ACEOF
17442 cat confdefs.h >>conftest.$ac_ext
17443 cat >>conftest.$ac_ext <<_ACEOF
17444 /* end confdefs.h.  */
17445
17446 /* Override any gcc2 internal prototype to avoid an error.  */
17447 #ifdef __cplusplus
17448 extern "C"
17449 #endif
17450 /* We use char because int might match the return type of a gcc2
17451    builtin and then its argument prototype would still apply.  */
17452 char nextafter ();
17453 int
17454 main ()
17455 {
17456 nextafter ();
17457   ;
17458   return 0;
17459 }
17460 _ACEOF
17461 rm -f conftest.$ac_objext conftest$ac_exeext
17462 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17463   (eval $ac_link) 2>conftest.er1
17464   ac_status=$?
17465   grep -v '^ *+' conftest.er1 >conftest.err
17466   rm -f conftest.er1
17467   cat conftest.err >&5
17468   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17469   (exit $ac_status); } &&
17470          { ac_try='test -z "$ac_c_werror_flag"
17471                          || test ! -s conftest.err'
17472   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17473   (eval $ac_try) 2>&5
17474   ac_status=$?
17475   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17476   (exit $ac_status); }; } &&
17477          { ac_try='test -s conftest$ac_exeext'
17478   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17479   (eval $ac_try) 2>&5
17480   ac_status=$?
17481   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17482   (exit $ac_status); }; }; then
17483   ac_cv_lib_m_nextafter=yes
17484 else
17485   echo "$as_me: failed program was:" >&5
17486 sed 's/^/| /' conftest.$ac_ext >&5
17487
17488 ac_cv_lib_m_nextafter=no
17489 fi
17490 rm -f conftest.err conftest.$ac_objext \
17491       conftest$ac_exeext conftest.$ac_ext
17492 LIBS=$ac_check_lib_save_LIBS
17493 fi
17494 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafter" >&5
17495 echo "${ECHO_T}$ac_cv_lib_m_nextafter" >&6
17496 if test $ac_cv_lib_m_nextafter = yes; then
17497
17498 cat >>confdefs.h <<\_ACEOF
17499 #define HAVE_NEXTAFTER 1
17500 _ACEOF
17501
17502 fi
17503
17504 echo "$as_me:$LINENO: checking for nextafterl in -lm" >&5
17505 echo $ECHO_N "checking for nextafterl in -lm... $ECHO_C" >&6
17506 if test "${ac_cv_lib_m_nextafterl+set}" = set; then
17507   echo $ECHO_N "(cached) $ECHO_C" >&6
17508 else
17509   ac_check_lib_save_LIBS=$LIBS
17510 LIBS="-lm  $LIBS"
17511 if test x$gcc_no_link = xyes; then
17512   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17513 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17514    { (exit 1); exit 1; }; }
17515 fi
17516 cat >conftest.$ac_ext <<_ACEOF
17517 /* confdefs.h.  */
17518 _ACEOF
17519 cat confdefs.h >>conftest.$ac_ext
17520 cat >>conftest.$ac_ext <<_ACEOF
17521 /* end confdefs.h.  */
17522
17523 /* Override any gcc2 internal prototype to avoid an error.  */
17524 #ifdef __cplusplus
17525 extern "C"
17526 #endif
17527 /* We use char because int might match the return type of a gcc2
17528    builtin and then its argument prototype would still apply.  */
17529 char nextafterl ();
17530 int
17531 main ()
17532 {
17533 nextafterl ();
17534   ;
17535   return 0;
17536 }
17537 _ACEOF
17538 rm -f conftest.$ac_objext conftest$ac_exeext
17539 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17540   (eval $ac_link) 2>conftest.er1
17541   ac_status=$?
17542   grep -v '^ *+' conftest.er1 >conftest.err
17543   rm -f conftest.er1
17544   cat conftest.err >&5
17545   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17546   (exit $ac_status); } &&
17547          { ac_try='test -z "$ac_c_werror_flag"
17548                          || test ! -s conftest.err'
17549   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17550   (eval $ac_try) 2>&5
17551   ac_status=$?
17552   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17553   (exit $ac_status); }; } &&
17554          { ac_try='test -s conftest$ac_exeext'
17555   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17556   (eval $ac_try) 2>&5
17557   ac_status=$?
17558   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17559   (exit $ac_status); }; }; then
17560   ac_cv_lib_m_nextafterl=yes
17561 else
17562   echo "$as_me: failed program was:" >&5
17563 sed 's/^/| /' conftest.$ac_ext >&5
17564
17565 ac_cv_lib_m_nextafterl=no
17566 fi
17567 rm -f conftest.err conftest.$ac_objext \
17568       conftest$ac_exeext conftest.$ac_ext
17569 LIBS=$ac_check_lib_save_LIBS
17570 fi
17571 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafterl" >&5
17572 echo "${ECHO_T}$ac_cv_lib_m_nextafterl" >&6
17573 if test $ac_cv_lib_m_nextafterl = yes; then
17574
17575 cat >>confdefs.h <<\_ACEOF
17576 #define HAVE_NEXTAFTERL 1
17577 _ACEOF
17578
17579 fi
17580
17581 echo "$as_me:$LINENO: checking for powf in -lm" >&5
17582 echo $ECHO_N "checking for powf in -lm... $ECHO_C" >&6
17583 if test "${ac_cv_lib_m_powf+set}" = set; then
17584   echo $ECHO_N "(cached) $ECHO_C" >&6
17585 else
17586   ac_check_lib_save_LIBS=$LIBS
17587 LIBS="-lm  $LIBS"
17588 if test x$gcc_no_link = xyes; then
17589   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17590 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17591    { (exit 1); exit 1; }; }
17592 fi
17593 cat >conftest.$ac_ext <<_ACEOF
17594 /* confdefs.h.  */
17595 _ACEOF
17596 cat confdefs.h >>conftest.$ac_ext
17597 cat >>conftest.$ac_ext <<_ACEOF
17598 /* end confdefs.h.  */
17599
17600 /* Override any gcc2 internal prototype to avoid an error.  */
17601 #ifdef __cplusplus
17602 extern "C"
17603 #endif
17604 /* We use char because int might match the return type of a gcc2
17605    builtin and then its argument prototype would still apply.  */
17606 char powf ();
17607 int
17608 main ()
17609 {
17610 powf ();
17611   ;
17612   return 0;
17613 }
17614 _ACEOF
17615 rm -f conftest.$ac_objext conftest$ac_exeext
17616 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17617   (eval $ac_link) 2>conftest.er1
17618   ac_status=$?
17619   grep -v '^ *+' conftest.er1 >conftest.err
17620   rm -f conftest.er1
17621   cat conftest.err >&5
17622   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17623   (exit $ac_status); } &&
17624          { ac_try='test -z "$ac_c_werror_flag"
17625                          || test ! -s conftest.err'
17626   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17627   (eval $ac_try) 2>&5
17628   ac_status=$?
17629   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17630   (exit $ac_status); }; } &&
17631          { ac_try='test -s conftest$ac_exeext'
17632   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17633   (eval $ac_try) 2>&5
17634   ac_status=$?
17635   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17636   (exit $ac_status); }; }; then
17637   ac_cv_lib_m_powf=yes
17638 else
17639   echo "$as_me: failed program was:" >&5
17640 sed 's/^/| /' conftest.$ac_ext >&5
17641
17642 ac_cv_lib_m_powf=no
17643 fi
17644 rm -f conftest.err conftest.$ac_objext \
17645       conftest$ac_exeext conftest.$ac_ext
17646 LIBS=$ac_check_lib_save_LIBS
17647 fi
17648 echo "$as_me:$LINENO: result: $ac_cv_lib_m_powf" >&5
17649 echo "${ECHO_T}$ac_cv_lib_m_powf" >&6
17650 if test $ac_cv_lib_m_powf = yes; then
17651
17652 cat >>confdefs.h <<\_ACEOF
17653 #define HAVE_POWF 1
17654 _ACEOF
17655
17656 fi
17657
17658 echo "$as_me:$LINENO: checking for pow in -lm" >&5
17659 echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
17660 if test "${ac_cv_lib_m_pow+set}" = set; then
17661   echo $ECHO_N "(cached) $ECHO_C" >&6
17662 else
17663   ac_check_lib_save_LIBS=$LIBS
17664 LIBS="-lm  $LIBS"
17665 if test x$gcc_no_link = xyes; then
17666   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17667 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17668    { (exit 1); exit 1; }; }
17669 fi
17670 cat >conftest.$ac_ext <<_ACEOF
17671 /* confdefs.h.  */
17672 _ACEOF
17673 cat confdefs.h >>conftest.$ac_ext
17674 cat >>conftest.$ac_ext <<_ACEOF
17675 /* end confdefs.h.  */
17676
17677 /* Override any gcc2 internal prototype to avoid an error.  */
17678 #ifdef __cplusplus
17679 extern "C"
17680 #endif
17681 /* We use char because int might match the return type of a gcc2
17682    builtin and then its argument prototype would still apply.  */
17683 char pow ();
17684 int
17685 main ()
17686 {
17687 pow ();
17688   ;
17689   return 0;
17690 }
17691 _ACEOF
17692 rm -f conftest.$ac_objext conftest$ac_exeext
17693 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17694   (eval $ac_link) 2>conftest.er1
17695   ac_status=$?
17696   grep -v '^ *+' conftest.er1 >conftest.err
17697   rm -f conftest.er1
17698   cat conftest.err >&5
17699   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17700   (exit $ac_status); } &&
17701          { ac_try='test -z "$ac_c_werror_flag"
17702                          || test ! -s conftest.err'
17703   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17704   (eval $ac_try) 2>&5
17705   ac_status=$?
17706   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17707   (exit $ac_status); }; } &&
17708          { ac_try='test -s conftest$ac_exeext'
17709   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17710   (eval $ac_try) 2>&5
17711   ac_status=$?
17712   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17713   (exit $ac_status); }; }; then
17714   ac_cv_lib_m_pow=yes
17715 else
17716   echo "$as_me: failed program was:" >&5
17717 sed 's/^/| /' conftest.$ac_ext >&5
17718
17719 ac_cv_lib_m_pow=no
17720 fi
17721 rm -f conftest.err conftest.$ac_objext \
17722       conftest$ac_exeext conftest.$ac_ext
17723 LIBS=$ac_check_lib_save_LIBS
17724 fi
17725 echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
17726 echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
17727 if test $ac_cv_lib_m_pow = yes; then
17728
17729 cat >>confdefs.h <<\_ACEOF
17730 #define HAVE_POW 1
17731 _ACEOF
17732
17733 fi
17734
17735 echo "$as_me:$LINENO: checking for powl in -lm" >&5
17736 echo $ECHO_N "checking for powl in -lm... $ECHO_C" >&6
17737 if test "${ac_cv_lib_m_powl+set}" = set; then
17738   echo $ECHO_N "(cached) $ECHO_C" >&6
17739 else
17740   ac_check_lib_save_LIBS=$LIBS
17741 LIBS="-lm  $LIBS"
17742 if test x$gcc_no_link = xyes; then
17743   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17744 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17745    { (exit 1); exit 1; }; }
17746 fi
17747 cat >conftest.$ac_ext <<_ACEOF
17748 /* confdefs.h.  */
17749 _ACEOF
17750 cat confdefs.h >>conftest.$ac_ext
17751 cat >>conftest.$ac_ext <<_ACEOF
17752 /* end confdefs.h.  */
17753
17754 /* Override any gcc2 internal prototype to avoid an error.  */
17755 #ifdef __cplusplus
17756 extern "C"
17757 #endif
17758 /* We use char because int might match the return type of a gcc2
17759    builtin and then its argument prototype would still apply.  */
17760 char powl ();
17761 int
17762 main ()
17763 {
17764 powl ();
17765   ;
17766   return 0;
17767 }
17768 _ACEOF
17769 rm -f conftest.$ac_objext conftest$ac_exeext
17770 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17771   (eval $ac_link) 2>conftest.er1
17772   ac_status=$?
17773   grep -v '^ *+' conftest.er1 >conftest.err
17774   rm -f conftest.er1
17775   cat conftest.err >&5
17776   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17777   (exit $ac_status); } &&
17778          { ac_try='test -z "$ac_c_werror_flag"
17779                          || test ! -s conftest.err'
17780   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17781   (eval $ac_try) 2>&5
17782   ac_status=$?
17783   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17784   (exit $ac_status); }; } &&
17785          { ac_try='test -s conftest$ac_exeext'
17786   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17787   (eval $ac_try) 2>&5
17788   ac_status=$?
17789   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17790   (exit $ac_status); }; }; then
17791   ac_cv_lib_m_powl=yes
17792 else
17793   echo "$as_me: failed program was:" >&5
17794 sed 's/^/| /' conftest.$ac_ext >&5
17795
17796 ac_cv_lib_m_powl=no
17797 fi
17798 rm -f conftest.err conftest.$ac_objext \
17799       conftest$ac_exeext conftest.$ac_ext
17800 LIBS=$ac_check_lib_save_LIBS
17801 fi
17802 echo "$as_me:$LINENO: result: $ac_cv_lib_m_powl" >&5
17803 echo "${ECHO_T}$ac_cv_lib_m_powl" >&6
17804 if test $ac_cv_lib_m_powl = yes; then
17805
17806 cat >>confdefs.h <<\_ACEOF
17807 #define HAVE_POWL 1
17808 _ACEOF
17809
17810 fi
17811
17812 echo "$as_me:$LINENO: checking for cpowf in -lm" >&5
17813 echo $ECHO_N "checking for cpowf in -lm... $ECHO_C" >&6
17814 if test "${ac_cv_lib_m_cpowf+set}" = set; then
17815   echo $ECHO_N "(cached) $ECHO_C" >&6
17816 else
17817   ac_check_lib_save_LIBS=$LIBS
17818 LIBS="-lm  $LIBS"
17819 if test x$gcc_no_link = xyes; then
17820   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17821 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17822    { (exit 1); exit 1; }; }
17823 fi
17824 cat >conftest.$ac_ext <<_ACEOF
17825 /* confdefs.h.  */
17826 _ACEOF
17827 cat confdefs.h >>conftest.$ac_ext
17828 cat >>conftest.$ac_ext <<_ACEOF
17829 /* end confdefs.h.  */
17830
17831 /* Override any gcc2 internal prototype to avoid an error.  */
17832 #ifdef __cplusplus
17833 extern "C"
17834 #endif
17835 /* We use char because int might match the return type of a gcc2
17836    builtin and then its argument prototype would still apply.  */
17837 char cpowf ();
17838 int
17839 main ()
17840 {
17841 cpowf ();
17842   ;
17843   return 0;
17844 }
17845 _ACEOF
17846 rm -f conftest.$ac_objext conftest$ac_exeext
17847 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17848   (eval $ac_link) 2>conftest.er1
17849   ac_status=$?
17850   grep -v '^ *+' conftest.er1 >conftest.err
17851   rm -f conftest.er1
17852   cat conftest.err >&5
17853   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17854   (exit $ac_status); } &&
17855          { ac_try='test -z "$ac_c_werror_flag"
17856                          || test ! -s conftest.err'
17857   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17858   (eval $ac_try) 2>&5
17859   ac_status=$?
17860   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17861   (exit $ac_status); }; } &&
17862          { ac_try='test -s conftest$ac_exeext'
17863   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17864   (eval $ac_try) 2>&5
17865   ac_status=$?
17866   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17867   (exit $ac_status); }; }; then
17868   ac_cv_lib_m_cpowf=yes
17869 else
17870   echo "$as_me: failed program was:" >&5
17871 sed 's/^/| /' conftest.$ac_ext >&5
17872
17873 ac_cv_lib_m_cpowf=no
17874 fi
17875 rm -f conftest.err conftest.$ac_objext \
17876       conftest$ac_exeext conftest.$ac_ext
17877 LIBS=$ac_check_lib_save_LIBS
17878 fi
17879 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpowf" >&5
17880 echo "${ECHO_T}$ac_cv_lib_m_cpowf" >&6
17881 if test $ac_cv_lib_m_cpowf = yes; then
17882
17883 cat >>confdefs.h <<\_ACEOF
17884 #define HAVE_CPOWF 1
17885 _ACEOF
17886
17887 fi
17888
17889 echo "$as_me:$LINENO: checking for cpow in -lm" >&5
17890 echo $ECHO_N "checking for cpow in -lm... $ECHO_C" >&6
17891 if test "${ac_cv_lib_m_cpow+set}" = set; then
17892   echo $ECHO_N "(cached) $ECHO_C" >&6
17893 else
17894   ac_check_lib_save_LIBS=$LIBS
17895 LIBS="-lm  $LIBS"
17896 if test x$gcc_no_link = xyes; then
17897   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17898 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17899    { (exit 1); exit 1; }; }
17900 fi
17901 cat >conftest.$ac_ext <<_ACEOF
17902 /* confdefs.h.  */
17903 _ACEOF
17904 cat confdefs.h >>conftest.$ac_ext
17905 cat >>conftest.$ac_ext <<_ACEOF
17906 /* end confdefs.h.  */
17907
17908 /* Override any gcc2 internal prototype to avoid an error.  */
17909 #ifdef __cplusplus
17910 extern "C"
17911 #endif
17912 /* We use char because int might match the return type of a gcc2
17913    builtin and then its argument prototype would still apply.  */
17914 char cpow ();
17915 int
17916 main ()
17917 {
17918 cpow ();
17919   ;
17920   return 0;
17921 }
17922 _ACEOF
17923 rm -f conftest.$ac_objext conftest$ac_exeext
17924 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17925   (eval $ac_link) 2>conftest.er1
17926   ac_status=$?
17927   grep -v '^ *+' conftest.er1 >conftest.err
17928   rm -f conftest.er1
17929   cat conftest.err >&5
17930   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17931   (exit $ac_status); } &&
17932          { ac_try='test -z "$ac_c_werror_flag"
17933                          || test ! -s conftest.err'
17934   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17935   (eval $ac_try) 2>&5
17936   ac_status=$?
17937   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17938   (exit $ac_status); }; } &&
17939          { ac_try='test -s conftest$ac_exeext'
17940   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17941   (eval $ac_try) 2>&5
17942   ac_status=$?
17943   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17944   (exit $ac_status); }; }; then
17945   ac_cv_lib_m_cpow=yes
17946 else
17947   echo "$as_me: failed program was:" >&5
17948 sed 's/^/| /' conftest.$ac_ext >&5
17949
17950 ac_cv_lib_m_cpow=no
17951 fi
17952 rm -f conftest.err conftest.$ac_objext \
17953       conftest$ac_exeext conftest.$ac_ext
17954 LIBS=$ac_check_lib_save_LIBS
17955 fi
17956 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpow" >&5
17957 echo "${ECHO_T}$ac_cv_lib_m_cpow" >&6
17958 if test $ac_cv_lib_m_cpow = yes; then
17959
17960 cat >>confdefs.h <<\_ACEOF
17961 #define HAVE_CPOW 1
17962 _ACEOF
17963
17964 fi
17965
17966 echo "$as_me:$LINENO: checking for cpowl in -lm" >&5
17967 echo $ECHO_N "checking for cpowl in -lm... $ECHO_C" >&6
17968 if test "${ac_cv_lib_m_cpowl+set}" = set; then
17969   echo $ECHO_N "(cached) $ECHO_C" >&6
17970 else
17971   ac_check_lib_save_LIBS=$LIBS
17972 LIBS="-lm  $LIBS"
17973 if test x$gcc_no_link = xyes; then
17974   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17975 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17976    { (exit 1); exit 1; }; }
17977 fi
17978 cat >conftest.$ac_ext <<_ACEOF
17979 /* confdefs.h.  */
17980 _ACEOF
17981 cat confdefs.h >>conftest.$ac_ext
17982 cat >>conftest.$ac_ext <<_ACEOF
17983 /* end confdefs.h.  */
17984
17985 /* Override any gcc2 internal prototype to avoid an error.  */
17986 #ifdef __cplusplus
17987 extern "C"
17988 #endif
17989 /* We use char because int might match the return type of a gcc2
17990    builtin and then its argument prototype would still apply.  */
17991 char cpowl ();
17992 int
17993 main ()
17994 {
17995 cpowl ();
17996   ;
17997   return 0;
17998 }
17999 _ACEOF
18000 rm -f conftest.$ac_objext conftest$ac_exeext
18001 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18002   (eval $ac_link) 2>conftest.er1
18003   ac_status=$?
18004   grep -v '^ *+' conftest.er1 >conftest.err
18005   rm -f conftest.er1
18006   cat conftest.err >&5
18007   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18008   (exit $ac_status); } &&
18009          { ac_try='test -z "$ac_c_werror_flag"
18010                          || test ! -s conftest.err'
18011   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18012   (eval $ac_try) 2>&5
18013   ac_status=$?
18014   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18015   (exit $ac_status); }; } &&
18016          { ac_try='test -s conftest$ac_exeext'
18017   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18018   (eval $ac_try) 2>&5
18019   ac_status=$?
18020   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18021   (exit $ac_status); }; }; then
18022   ac_cv_lib_m_cpowl=yes
18023 else
18024   echo "$as_me: failed program was:" >&5
18025 sed 's/^/| /' conftest.$ac_ext >&5
18026
18027 ac_cv_lib_m_cpowl=no
18028 fi
18029 rm -f conftest.err conftest.$ac_objext \
18030       conftest$ac_exeext conftest.$ac_ext
18031 LIBS=$ac_check_lib_save_LIBS
18032 fi
18033 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpowl" >&5
18034 echo "${ECHO_T}$ac_cv_lib_m_cpowl" >&6
18035 if test $ac_cv_lib_m_cpowl = yes; then
18036
18037 cat >>confdefs.h <<\_ACEOF
18038 #define HAVE_CPOWL 1
18039 _ACEOF
18040
18041 fi
18042
18043 echo "$as_me:$LINENO: checking for roundf in -lm" >&5
18044 echo $ECHO_N "checking for roundf in -lm... $ECHO_C" >&6
18045 if test "${ac_cv_lib_m_roundf+set}" = set; then
18046   echo $ECHO_N "(cached) $ECHO_C" >&6
18047 else
18048   ac_check_lib_save_LIBS=$LIBS
18049 LIBS="-lm  $LIBS"
18050 if test x$gcc_no_link = xyes; then
18051   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18052 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18053    { (exit 1); exit 1; }; }
18054 fi
18055 cat >conftest.$ac_ext <<_ACEOF
18056 /* confdefs.h.  */
18057 _ACEOF
18058 cat confdefs.h >>conftest.$ac_ext
18059 cat >>conftest.$ac_ext <<_ACEOF
18060 /* end confdefs.h.  */
18061
18062 /* Override any gcc2 internal prototype to avoid an error.  */
18063 #ifdef __cplusplus
18064 extern "C"
18065 #endif
18066 /* We use char because int might match the return type of a gcc2
18067    builtin and then its argument prototype would still apply.  */
18068 char roundf ();
18069 int
18070 main ()
18071 {
18072 roundf ();
18073   ;
18074   return 0;
18075 }
18076 _ACEOF
18077 rm -f conftest.$ac_objext conftest$ac_exeext
18078 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18079   (eval $ac_link) 2>conftest.er1
18080   ac_status=$?
18081   grep -v '^ *+' conftest.er1 >conftest.err
18082   rm -f conftest.er1
18083   cat conftest.err >&5
18084   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18085   (exit $ac_status); } &&
18086          { ac_try='test -z "$ac_c_werror_flag"
18087                          || test ! -s conftest.err'
18088   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18089   (eval $ac_try) 2>&5
18090   ac_status=$?
18091   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18092   (exit $ac_status); }; } &&
18093          { ac_try='test -s conftest$ac_exeext'
18094   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18095   (eval $ac_try) 2>&5
18096   ac_status=$?
18097   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18098   (exit $ac_status); }; }; then
18099   ac_cv_lib_m_roundf=yes
18100 else
18101   echo "$as_me: failed program was:" >&5
18102 sed 's/^/| /' conftest.$ac_ext >&5
18103
18104 ac_cv_lib_m_roundf=no
18105 fi
18106 rm -f conftest.err conftest.$ac_objext \
18107       conftest$ac_exeext conftest.$ac_ext
18108 LIBS=$ac_check_lib_save_LIBS
18109 fi
18110 echo "$as_me:$LINENO: result: $ac_cv_lib_m_roundf" >&5
18111 echo "${ECHO_T}$ac_cv_lib_m_roundf" >&6
18112 if test $ac_cv_lib_m_roundf = yes; then
18113
18114 cat >>confdefs.h <<\_ACEOF
18115 #define HAVE_ROUNDF 1
18116 _ACEOF
18117
18118 fi
18119
18120 echo "$as_me:$LINENO: checking for round in -lm" >&5
18121 echo $ECHO_N "checking for round in -lm... $ECHO_C" >&6
18122 if test "${ac_cv_lib_m_round+set}" = set; then
18123   echo $ECHO_N "(cached) $ECHO_C" >&6
18124 else
18125   ac_check_lib_save_LIBS=$LIBS
18126 LIBS="-lm  $LIBS"
18127 if test x$gcc_no_link = xyes; then
18128   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18129 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18130    { (exit 1); exit 1; }; }
18131 fi
18132 cat >conftest.$ac_ext <<_ACEOF
18133 /* confdefs.h.  */
18134 _ACEOF
18135 cat confdefs.h >>conftest.$ac_ext
18136 cat >>conftest.$ac_ext <<_ACEOF
18137 /* end confdefs.h.  */
18138
18139 /* Override any gcc2 internal prototype to avoid an error.  */
18140 #ifdef __cplusplus
18141 extern "C"
18142 #endif
18143 /* We use char because int might match the return type of a gcc2
18144    builtin and then its argument prototype would still apply.  */
18145 char round ();
18146 int
18147 main ()
18148 {
18149 round ();
18150   ;
18151   return 0;
18152 }
18153 _ACEOF
18154 rm -f conftest.$ac_objext conftest$ac_exeext
18155 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18156   (eval $ac_link) 2>conftest.er1
18157   ac_status=$?
18158   grep -v '^ *+' conftest.er1 >conftest.err
18159   rm -f conftest.er1
18160   cat conftest.err >&5
18161   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18162   (exit $ac_status); } &&
18163          { ac_try='test -z "$ac_c_werror_flag"
18164                          || test ! -s conftest.err'
18165   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18166   (eval $ac_try) 2>&5
18167   ac_status=$?
18168   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18169   (exit $ac_status); }; } &&
18170          { ac_try='test -s conftest$ac_exeext'
18171   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18172   (eval $ac_try) 2>&5
18173   ac_status=$?
18174   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18175   (exit $ac_status); }; }; then
18176   ac_cv_lib_m_round=yes
18177 else
18178   echo "$as_me: failed program was:" >&5
18179 sed 's/^/| /' conftest.$ac_ext >&5
18180
18181 ac_cv_lib_m_round=no
18182 fi
18183 rm -f conftest.err conftest.$ac_objext \
18184       conftest$ac_exeext conftest.$ac_ext
18185 LIBS=$ac_check_lib_save_LIBS
18186 fi
18187 echo "$as_me:$LINENO: result: $ac_cv_lib_m_round" >&5
18188 echo "${ECHO_T}$ac_cv_lib_m_round" >&6
18189 if test $ac_cv_lib_m_round = yes; then
18190
18191 cat >>confdefs.h <<\_ACEOF
18192 #define HAVE_ROUND 1
18193 _ACEOF
18194
18195 fi
18196
18197 echo "$as_me:$LINENO: checking for roundl in -lm" >&5
18198 echo $ECHO_N "checking for roundl in -lm... $ECHO_C" >&6
18199 if test "${ac_cv_lib_m_roundl+set}" = set; then
18200   echo $ECHO_N "(cached) $ECHO_C" >&6
18201 else
18202   ac_check_lib_save_LIBS=$LIBS
18203 LIBS="-lm  $LIBS"
18204 if test x$gcc_no_link = xyes; then
18205   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18206 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18207    { (exit 1); exit 1; }; }
18208 fi
18209 cat >conftest.$ac_ext <<_ACEOF
18210 /* confdefs.h.  */
18211 _ACEOF
18212 cat confdefs.h >>conftest.$ac_ext
18213 cat >>conftest.$ac_ext <<_ACEOF
18214 /* end confdefs.h.  */
18215
18216 /* Override any gcc2 internal prototype to avoid an error.  */
18217 #ifdef __cplusplus
18218 extern "C"
18219 #endif
18220 /* We use char because int might match the return type of a gcc2
18221    builtin and then its argument prototype would still apply.  */
18222 char roundl ();
18223 int
18224 main ()
18225 {
18226 roundl ();
18227   ;
18228   return 0;
18229 }
18230 _ACEOF
18231 rm -f conftest.$ac_objext conftest$ac_exeext
18232 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18233   (eval $ac_link) 2>conftest.er1
18234   ac_status=$?
18235   grep -v '^ *+' conftest.er1 >conftest.err
18236   rm -f conftest.er1
18237   cat conftest.err >&5
18238   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18239   (exit $ac_status); } &&
18240          { ac_try='test -z "$ac_c_werror_flag"
18241                          || test ! -s conftest.err'
18242   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18243   (eval $ac_try) 2>&5
18244   ac_status=$?
18245   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18246   (exit $ac_status); }; } &&
18247          { ac_try='test -s conftest$ac_exeext'
18248   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18249   (eval $ac_try) 2>&5
18250   ac_status=$?
18251   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18252   (exit $ac_status); }; }; then
18253   ac_cv_lib_m_roundl=yes
18254 else
18255   echo "$as_me: failed program was:" >&5
18256 sed 's/^/| /' conftest.$ac_ext >&5
18257
18258 ac_cv_lib_m_roundl=no
18259 fi
18260 rm -f conftest.err conftest.$ac_objext \
18261       conftest$ac_exeext conftest.$ac_ext
18262 LIBS=$ac_check_lib_save_LIBS
18263 fi
18264 echo "$as_me:$LINENO: result: $ac_cv_lib_m_roundl" >&5
18265 echo "${ECHO_T}$ac_cv_lib_m_roundl" >&6
18266 if test $ac_cv_lib_m_roundl = yes; then
18267
18268 cat >>confdefs.h <<\_ACEOF
18269 #define HAVE_ROUNDL 1
18270 _ACEOF
18271
18272 fi
18273
18274 echo "$as_me:$LINENO: checking for scalbnf in -lm" >&5
18275 echo $ECHO_N "checking for scalbnf in -lm... $ECHO_C" >&6
18276 if test "${ac_cv_lib_m_scalbnf+set}" = set; then
18277   echo $ECHO_N "(cached) $ECHO_C" >&6
18278 else
18279   ac_check_lib_save_LIBS=$LIBS
18280 LIBS="-lm  $LIBS"
18281 if test x$gcc_no_link = xyes; then
18282   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18283 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18284    { (exit 1); exit 1; }; }
18285 fi
18286 cat >conftest.$ac_ext <<_ACEOF
18287 /* confdefs.h.  */
18288 _ACEOF
18289 cat confdefs.h >>conftest.$ac_ext
18290 cat >>conftest.$ac_ext <<_ACEOF
18291 /* end confdefs.h.  */
18292
18293 /* Override any gcc2 internal prototype to avoid an error.  */
18294 #ifdef __cplusplus
18295 extern "C"
18296 #endif
18297 /* We use char because int might match the return type of a gcc2
18298    builtin and then its argument prototype would still apply.  */
18299 char scalbnf ();
18300 int
18301 main ()
18302 {
18303 scalbnf ();
18304   ;
18305   return 0;
18306 }
18307 _ACEOF
18308 rm -f conftest.$ac_objext conftest$ac_exeext
18309 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18310   (eval $ac_link) 2>conftest.er1
18311   ac_status=$?
18312   grep -v '^ *+' conftest.er1 >conftest.err
18313   rm -f conftest.er1
18314   cat conftest.err >&5
18315   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18316   (exit $ac_status); } &&
18317          { ac_try='test -z "$ac_c_werror_flag"
18318                          || test ! -s conftest.err'
18319   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18320   (eval $ac_try) 2>&5
18321   ac_status=$?
18322   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18323   (exit $ac_status); }; } &&
18324          { ac_try='test -s conftest$ac_exeext'
18325   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18326   (eval $ac_try) 2>&5
18327   ac_status=$?
18328   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18329   (exit $ac_status); }; }; then
18330   ac_cv_lib_m_scalbnf=yes
18331 else
18332   echo "$as_me: failed program was:" >&5
18333 sed 's/^/| /' conftest.$ac_ext >&5
18334
18335 ac_cv_lib_m_scalbnf=no
18336 fi
18337 rm -f conftest.err conftest.$ac_objext \
18338       conftest$ac_exeext conftest.$ac_ext
18339 LIBS=$ac_check_lib_save_LIBS
18340 fi
18341 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbnf" >&5
18342 echo "${ECHO_T}$ac_cv_lib_m_scalbnf" >&6
18343 if test $ac_cv_lib_m_scalbnf = yes; then
18344
18345 cat >>confdefs.h <<\_ACEOF
18346 #define HAVE_SCALBNF 1
18347 _ACEOF
18348
18349 fi
18350
18351 echo "$as_me:$LINENO: checking for scalbn in -lm" >&5
18352 echo $ECHO_N "checking for scalbn in -lm... $ECHO_C" >&6
18353 if test "${ac_cv_lib_m_scalbn+set}" = set; then
18354   echo $ECHO_N "(cached) $ECHO_C" >&6
18355 else
18356   ac_check_lib_save_LIBS=$LIBS
18357 LIBS="-lm  $LIBS"
18358 if test x$gcc_no_link = xyes; then
18359   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18360 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18361    { (exit 1); exit 1; }; }
18362 fi
18363 cat >conftest.$ac_ext <<_ACEOF
18364 /* confdefs.h.  */
18365 _ACEOF
18366 cat confdefs.h >>conftest.$ac_ext
18367 cat >>conftest.$ac_ext <<_ACEOF
18368 /* end confdefs.h.  */
18369
18370 /* Override any gcc2 internal prototype to avoid an error.  */
18371 #ifdef __cplusplus
18372 extern "C"
18373 #endif
18374 /* We use char because int might match the return type of a gcc2
18375    builtin and then its argument prototype would still apply.  */
18376 char scalbn ();
18377 int
18378 main ()
18379 {
18380 scalbn ();
18381   ;
18382   return 0;
18383 }
18384 _ACEOF
18385 rm -f conftest.$ac_objext conftest$ac_exeext
18386 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18387   (eval $ac_link) 2>conftest.er1
18388   ac_status=$?
18389   grep -v '^ *+' conftest.er1 >conftest.err
18390   rm -f conftest.er1
18391   cat conftest.err >&5
18392   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18393   (exit $ac_status); } &&
18394          { ac_try='test -z "$ac_c_werror_flag"
18395                          || test ! -s conftest.err'
18396   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18397   (eval $ac_try) 2>&5
18398   ac_status=$?
18399   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18400   (exit $ac_status); }; } &&
18401          { ac_try='test -s conftest$ac_exeext'
18402   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18403   (eval $ac_try) 2>&5
18404   ac_status=$?
18405   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18406   (exit $ac_status); }; }; then
18407   ac_cv_lib_m_scalbn=yes
18408 else
18409   echo "$as_me: failed program was:" >&5
18410 sed 's/^/| /' conftest.$ac_ext >&5
18411
18412 ac_cv_lib_m_scalbn=no
18413 fi
18414 rm -f conftest.err conftest.$ac_objext \
18415       conftest$ac_exeext conftest.$ac_ext
18416 LIBS=$ac_check_lib_save_LIBS
18417 fi
18418 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbn" >&5
18419 echo "${ECHO_T}$ac_cv_lib_m_scalbn" >&6
18420 if test $ac_cv_lib_m_scalbn = yes; then
18421
18422 cat >>confdefs.h <<\_ACEOF
18423 #define HAVE_SCALBN 1
18424 _ACEOF
18425
18426 fi
18427
18428 echo "$as_me:$LINENO: checking for scalbnl in -lm" >&5
18429 echo $ECHO_N "checking for scalbnl in -lm... $ECHO_C" >&6
18430 if test "${ac_cv_lib_m_scalbnl+set}" = set; then
18431   echo $ECHO_N "(cached) $ECHO_C" >&6
18432 else
18433   ac_check_lib_save_LIBS=$LIBS
18434 LIBS="-lm  $LIBS"
18435 if test x$gcc_no_link = xyes; then
18436   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18437 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18438    { (exit 1); exit 1; }; }
18439 fi
18440 cat >conftest.$ac_ext <<_ACEOF
18441 /* confdefs.h.  */
18442 _ACEOF
18443 cat confdefs.h >>conftest.$ac_ext
18444 cat >>conftest.$ac_ext <<_ACEOF
18445 /* end confdefs.h.  */
18446
18447 /* Override any gcc2 internal prototype to avoid an error.  */
18448 #ifdef __cplusplus
18449 extern "C"
18450 #endif
18451 /* We use char because int might match the return type of a gcc2
18452    builtin and then its argument prototype would still apply.  */
18453 char scalbnl ();
18454 int
18455 main ()
18456 {
18457 scalbnl ();
18458   ;
18459   return 0;
18460 }
18461 _ACEOF
18462 rm -f conftest.$ac_objext conftest$ac_exeext
18463 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18464   (eval $ac_link) 2>conftest.er1
18465   ac_status=$?
18466   grep -v '^ *+' conftest.er1 >conftest.err
18467   rm -f conftest.er1
18468   cat conftest.err >&5
18469   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18470   (exit $ac_status); } &&
18471          { ac_try='test -z "$ac_c_werror_flag"
18472                          || test ! -s conftest.err'
18473   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18474   (eval $ac_try) 2>&5
18475   ac_status=$?
18476   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18477   (exit $ac_status); }; } &&
18478          { ac_try='test -s conftest$ac_exeext'
18479   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18480   (eval $ac_try) 2>&5
18481   ac_status=$?
18482   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18483   (exit $ac_status); }; }; then
18484   ac_cv_lib_m_scalbnl=yes
18485 else
18486   echo "$as_me: failed program was:" >&5
18487 sed 's/^/| /' conftest.$ac_ext >&5
18488
18489 ac_cv_lib_m_scalbnl=no
18490 fi
18491 rm -f conftest.err conftest.$ac_objext \
18492       conftest$ac_exeext conftest.$ac_ext
18493 LIBS=$ac_check_lib_save_LIBS
18494 fi
18495 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbnl" >&5
18496 echo "${ECHO_T}$ac_cv_lib_m_scalbnl" >&6
18497 if test $ac_cv_lib_m_scalbnl = yes; then
18498
18499 cat >>confdefs.h <<\_ACEOF
18500 #define HAVE_SCALBNL 1
18501 _ACEOF
18502
18503 fi
18504
18505 echo "$as_me:$LINENO: checking for sinf in -lm" >&5
18506 echo $ECHO_N "checking for sinf in -lm... $ECHO_C" >&6
18507 if test "${ac_cv_lib_m_sinf+set}" = set; then
18508   echo $ECHO_N "(cached) $ECHO_C" >&6
18509 else
18510   ac_check_lib_save_LIBS=$LIBS
18511 LIBS="-lm  $LIBS"
18512 if test x$gcc_no_link = xyes; then
18513   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18514 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18515    { (exit 1); exit 1; }; }
18516 fi
18517 cat >conftest.$ac_ext <<_ACEOF
18518 /* confdefs.h.  */
18519 _ACEOF
18520 cat confdefs.h >>conftest.$ac_ext
18521 cat >>conftest.$ac_ext <<_ACEOF
18522 /* end confdefs.h.  */
18523
18524 /* Override any gcc2 internal prototype to avoid an error.  */
18525 #ifdef __cplusplus
18526 extern "C"
18527 #endif
18528 /* We use char because int might match the return type of a gcc2
18529    builtin and then its argument prototype would still apply.  */
18530 char sinf ();
18531 int
18532 main ()
18533 {
18534 sinf ();
18535   ;
18536   return 0;
18537 }
18538 _ACEOF
18539 rm -f conftest.$ac_objext conftest$ac_exeext
18540 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18541   (eval $ac_link) 2>conftest.er1
18542   ac_status=$?
18543   grep -v '^ *+' conftest.er1 >conftest.err
18544   rm -f conftest.er1
18545   cat conftest.err >&5
18546   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18547   (exit $ac_status); } &&
18548          { ac_try='test -z "$ac_c_werror_flag"
18549                          || test ! -s conftest.err'
18550   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18551   (eval $ac_try) 2>&5
18552   ac_status=$?
18553   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18554   (exit $ac_status); }; } &&
18555          { ac_try='test -s conftest$ac_exeext'
18556   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18557   (eval $ac_try) 2>&5
18558   ac_status=$?
18559   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18560   (exit $ac_status); }; }; then
18561   ac_cv_lib_m_sinf=yes
18562 else
18563   echo "$as_me: failed program was:" >&5
18564 sed 's/^/| /' conftest.$ac_ext >&5
18565
18566 ac_cv_lib_m_sinf=no
18567 fi
18568 rm -f conftest.err conftest.$ac_objext \
18569       conftest$ac_exeext conftest.$ac_ext
18570 LIBS=$ac_check_lib_save_LIBS
18571 fi
18572 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinf" >&5
18573 echo "${ECHO_T}$ac_cv_lib_m_sinf" >&6
18574 if test $ac_cv_lib_m_sinf = yes; then
18575
18576 cat >>confdefs.h <<\_ACEOF
18577 #define HAVE_SINF 1
18578 _ACEOF
18579
18580 fi
18581
18582 echo "$as_me:$LINENO: checking for sin in -lm" >&5
18583 echo $ECHO_N "checking for sin in -lm... $ECHO_C" >&6
18584 if test "${ac_cv_lib_m_sin+set}" = set; then
18585   echo $ECHO_N "(cached) $ECHO_C" >&6
18586 else
18587   ac_check_lib_save_LIBS=$LIBS
18588 LIBS="-lm  $LIBS"
18589 if test x$gcc_no_link = xyes; then
18590   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18591 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18592    { (exit 1); exit 1; }; }
18593 fi
18594 cat >conftest.$ac_ext <<_ACEOF
18595 /* confdefs.h.  */
18596 _ACEOF
18597 cat confdefs.h >>conftest.$ac_ext
18598 cat >>conftest.$ac_ext <<_ACEOF
18599 /* end confdefs.h.  */
18600
18601 /* Override any gcc2 internal prototype to avoid an error.  */
18602 #ifdef __cplusplus
18603 extern "C"
18604 #endif
18605 /* We use char because int might match the return type of a gcc2
18606    builtin and then its argument prototype would still apply.  */
18607 char sin ();
18608 int
18609 main ()
18610 {
18611 sin ();
18612   ;
18613   return 0;
18614 }
18615 _ACEOF
18616 rm -f conftest.$ac_objext conftest$ac_exeext
18617 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18618   (eval $ac_link) 2>conftest.er1
18619   ac_status=$?
18620   grep -v '^ *+' conftest.er1 >conftest.err
18621   rm -f conftest.er1
18622   cat conftest.err >&5
18623   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18624   (exit $ac_status); } &&
18625          { ac_try='test -z "$ac_c_werror_flag"
18626                          || test ! -s conftest.err'
18627   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18628   (eval $ac_try) 2>&5
18629   ac_status=$?
18630   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18631   (exit $ac_status); }; } &&
18632          { ac_try='test -s conftest$ac_exeext'
18633   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18634   (eval $ac_try) 2>&5
18635   ac_status=$?
18636   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18637   (exit $ac_status); }; }; then
18638   ac_cv_lib_m_sin=yes
18639 else
18640   echo "$as_me: failed program was:" >&5
18641 sed 's/^/| /' conftest.$ac_ext >&5
18642
18643 ac_cv_lib_m_sin=no
18644 fi
18645 rm -f conftest.err conftest.$ac_objext \
18646       conftest$ac_exeext conftest.$ac_ext
18647 LIBS=$ac_check_lib_save_LIBS
18648 fi
18649 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sin" >&5
18650 echo "${ECHO_T}$ac_cv_lib_m_sin" >&6
18651 if test $ac_cv_lib_m_sin = yes; then
18652
18653 cat >>confdefs.h <<\_ACEOF
18654 #define HAVE_SIN 1
18655 _ACEOF
18656
18657 fi
18658
18659 echo "$as_me:$LINENO: checking for sinl in -lm" >&5
18660 echo $ECHO_N "checking for sinl in -lm... $ECHO_C" >&6
18661 if test "${ac_cv_lib_m_sinl+set}" = set; then
18662   echo $ECHO_N "(cached) $ECHO_C" >&6
18663 else
18664   ac_check_lib_save_LIBS=$LIBS
18665 LIBS="-lm  $LIBS"
18666 if test x$gcc_no_link = xyes; then
18667   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18668 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18669    { (exit 1); exit 1; }; }
18670 fi
18671 cat >conftest.$ac_ext <<_ACEOF
18672 /* confdefs.h.  */
18673 _ACEOF
18674 cat confdefs.h >>conftest.$ac_ext
18675 cat >>conftest.$ac_ext <<_ACEOF
18676 /* end confdefs.h.  */
18677
18678 /* Override any gcc2 internal prototype to avoid an error.  */
18679 #ifdef __cplusplus
18680 extern "C"
18681 #endif
18682 /* We use char because int might match the return type of a gcc2
18683    builtin and then its argument prototype would still apply.  */
18684 char sinl ();
18685 int
18686 main ()
18687 {
18688 sinl ();
18689   ;
18690   return 0;
18691 }
18692 _ACEOF
18693 rm -f conftest.$ac_objext conftest$ac_exeext
18694 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18695   (eval $ac_link) 2>conftest.er1
18696   ac_status=$?
18697   grep -v '^ *+' conftest.er1 >conftest.err
18698   rm -f conftest.er1
18699   cat conftest.err >&5
18700   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18701   (exit $ac_status); } &&
18702          { ac_try='test -z "$ac_c_werror_flag"
18703                          || test ! -s conftest.err'
18704   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18705   (eval $ac_try) 2>&5
18706   ac_status=$?
18707   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18708   (exit $ac_status); }; } &&
18709          { ac_try='test -s conftest$ac_exeext'
18710   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18711   (eval $ac_try) 2>&5
18712   ac_status=$?
18713   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18714   (exit $ac_status); }; }; then
18715   ac_cv_lib_m_sinl=yes
18716 else
18717   echo "$as_me: failed program was:" >&5
18718 sed 's/^/| /' conftest.$ac_ext >&5
18719
18720 ac_cv_lib_m_sinl=no
18721 fi
18722 rm -f conftest.err conftest.$ac_objext \
18723       conftest$ac_exeext conftest.$ac_ext
18724 LIBS=$ac_check_lib_save_LIBS
18725 fi
18726 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinl" >&5
18727 echo "${ECHO_T}$ac_cv_lib_m_sinl" >&6
18728 if test $ac_cv_lib_m_sinl = yes; then
18729
18730 cat >>confdefs.h <<\_ACEOF
18731 #define HAVE_SINL 1
18732 _ACEOF
18733
18734 fi
18735
18736 echo "$as_me:$LINENO: checking for csinf in -lm" >&5
18737 echo $ECHO_N "checking for csinf in -lm... $ECHO_C" >&6
18738 if test "${ac_cv_lib_m_csinf+set}" = set; then
18739   echo $ECHO_N "(cached) $ECHO_C" >&6
18740 else
18741   ac_check_lib_save_LIBS=$LIBS
18742 LIBS="-lm  $LIBS"
18743 if test x$gcc_no_link = xyes; then
18744   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18745 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18746    { (exit 1); exit 1; }; }
18747 fi
18748 cat >conftest.$ac_ext <<_ACEOF
18749 /* confdefs.h.  */
18750 _ACEOF
18751 cat confdefs.h >>conftest.$ac_ext
18752 cat >>conftest.$ac_ext <<_ACEOF
18753 /* end confdefs.h.  */
18754
18755 /* Override any gcc2 internal prototype to avoid an error.  */
18756 #ifdef __cplusplus
18757 extern "C"
18758 #endif
18759 /* We use char because int might match the return type of a gcc2
18760    builtin and then its argument prototype would still apply.  */
18761 char csinf ();
18762 int
18763 main ()
18764 {
18765 csinf ();
18766   ;
18767   return 0;
18768 }
18769 _ACEOF
18770 rm -f conftest.$ac_objext conftest$ac_exeext
18771 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18772   (eval $ac_link) 2>conftest.er1
18773   ac_status=$?
18774   grep -v '^ *+' conftest.er1 >conftest.err
18775   rm -f conftest.er1
18776   cat conftest.err >&5
18777   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18778   (exit $ac_status); } &&
18779          { ac_try='test -z "$ac_c_werror_flag"
18780                          || test ! -s conftest.err'
18781   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18782   (eval $ac_try) 2>&5
18783   ac_status=$?
18784   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18785   (exit $ac_status); }; } &&
18786          { ac_try='test -s conftest$ac_exeext'
18787   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18788   (eval $ac_try) 2>&5
18789   ac_status=$?
18790   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18791   (exit $ac_status); }; }; then
18792   ac_cv_lib_m_csinf=yes
18793 else
18794   echo "$as_me: failed program was:" >&5
18795 sed 's/^/| /' conftest.$ac_ext >&5
18796
18797 ac_cv_lib_m_csinf=no
18798 fi
18799 rm -f conftest.err conftest.$ac_objext \
18800       conftest$ac_exeext conftest.$ac_ext
18801 LIBS=$ac_check_lib_save_LIBS
18802 fi
18803 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinf" >&5
18804 echo "${ECHO_T}$ac_cv_lib_m_csinf" >&6
18805 if test $ac_cv_lib_m_csinf = yes; then
18806
18807 cat >>confdefs.h <<\_ACEOF
18808 #define HAVE_CSINF 1
18809 _ACEOF
18810
18811 fi
18812
18813 echo "$as_me:$LINENO: checking for csin in -lm" >&5
18814 echo $ECHO_N "checking for csin in -lm... $ECHO_C" >&6
18815 if test "${ac_cv_lib_m_csin+set}" = set; then
18816   echo $ECHO_N "(cached) $ECHO_C" >&6
18817 else
18818   ac_check_lib_save_LIBS=$LIBS
18819 LIBS="-lm  $LIBS"
18820 if test x$gcc_no_link = xyes; then
18821   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18822 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18823    { (exit 1); exit 1; }; }
18824 fi
18825 cat >conftest.$ac_ext <<_ACEOF
18826 /* confdefs.h.  */
18827 _ACEOF
18828 cat confdefs.h >>conftest.$ac_ext
18829 cat >>conftest.$ac_ext <<_ACEOF
18830 /* end confdefs.h.  */
18831
18832 /* Override any gcc2 internal prototype to avoid an error.  */
18833 #ifdef __cplusplus
18834 extern "C"
18835 #endif
18836 /* We use char because int might match the return type of a gcc2
18837    builtin and then its argument prototype would still apply.  */
18838 char csin ();
18839 int
18840 main ()
18841 {
18842 csin ();
18843   ;
18844   return 0;
18845 }
18846 _ACEOF
18847 rm -f conftest.$ac_objext conftest$ac_exeext
18848 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18849   (eval $ac_link) 2>conftest.er1
18850   ac_status=$?
18851   grep -v '^ *+' conftest.er1 >conftest.err
18852   rm -f conftest.er1
18853   cat conftest.err >&5
18854   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18855   (exit $ac_status); } &&
18856          { ac_try='test -z "$ac_c_werror_flag"
18857                          || test ! -s conftest.err'
18858   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18859   (eval $ac_try) 2>&5
18860   ac_status=$?
18861   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18862   (exit $ac_status); }; } &&
18863          { ac_try='test -s conftest$ac_exeext'
18864   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18865   (eval $ac_try) 2>&5
18866   ac_status=$?
18867   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18868   (exit $ac_status); }; }; then
18869   ac_cv_lib_m_csin=yes
18870 else
18871   echo "$as_me: failed program was:" >&5
18872 sed 's/^/| /' conftest.$ac_ext >&5
18873
18874 ac_cv_lib_m_csin=no
18875 fi
18876 rm -f conftest.err conftest.$ac_objext \
18877       conftest$ac_exeext conftest.$ac_ext
18878 LIBS=$ac_check_lib_save_LIBS
18879 fi
18880 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csin" >&5
18881 echo "${ECHO_T}$ac_cv_lib_m_csin" >&6
18882 if test $ac_cv_lib_m_csin = yes; then
18883
18884 cat >>confdefs.h <<\_ACEOF
18885 #define HAVE_CSIN 1
18886 _ACEOF
18887
18888 fi
18889
18890 echo "$as_me:$LINENO: checking for csinl in -lm" >&5
18891 echo $ECHO_N "checking for csinl in -lm... $ECHO_C" >&6
18892 if test "${ac_cv_lib_m_csinl+set}" = set; then
18893   echo $ECHO_N "(cached) $ECHO_C" >&6
18894 else
18895   ac_check_lib_save_LIBS=$LIBS
18896 LIBS="-lm  $LIBS"
18897 if test x$gcc_no_link = xyes; then
18898   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18899 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18900    { (exit 1); exit 1; }; }
18901 fi
18902 cat >conftest.$ac_ext <<_ACEOF
18903 /* confdefs.h.  */
18904 _ACEOF
18905 cat confdefs.h >>conftest.$ac_ext
18906 cat >>conftest.$ac_ext <<_ACEOF
18907 /* end confdefs.h.  */
18908
18909 /* Override any gcc2 internal prototype to avoid an error.  */
18910 #ifdef __cplusplus
18911 extern "C"
18912 #endif
18913 /* We use char because int might match the return type of a gcc2
18914    builtin and then its argument prototype would still apply.  */
18915 char csinl ();
18916 int
18917 main ()
18918 {
18919 csinl ();
18920   ;
18921   return 0;
18922 }
18923 _ACEOF
18924 rm -f conftest.$ac_objext conftest$ac_exeext
18925 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18926   (eval $ac_link) 2>conftest.er1
18927   ac_status=$?
18928   grep -v '^ *+' conftest.er1 >conftest.err
18929   rm -f conftest.er1
18930   cat conftest.err >&5
18931   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18932   (exit $ac_status); } &&
18933          { ac_try='test -z "$ac_c_werror_flag"
18934                          || test ! -s conftest.err'
18935   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18936   (eval $ac_try) 2>&5
18937   ac_status=$?
18938   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18939   (exit $ac_status); }; } &&
18940          { ac_try='test -s conftest$ac_exeext'
18941   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18942   (eval $ac_try) 2>&5
18943   ac_status=$?
18944   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18945   (exit $ac_status); }; }; then
18946   ac_cv_lib_m_csinl=yes
18947 else
18948   echo "$as_me: failed program was:" >&5
18949 sed 's/^/| /' conftest.$ac_ext >&5
18950
18951 ac_cv_lib_m_csinl=no
18952 fi
18953 rm -f conftest.err conftest.$ac_objext \
18954       conftest$ac_exeext conftest.$ac_ext
18955 LIBS=$ac_check_lib_save_LIBS
18956 fi
18957 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinl" >&5
18958 echo "${ECHO_T}$ac_cv_lib_m_csinl" >&6
18959 if test $ac_cv_lib_m_csinl = yes; then
18960
18961 cat >>confdefs.h <<\_ACEOF
18962 #define HAVE_CSINL 1
18963 _ACEOF
18964
18965 fi
18966
18967 echo "$as_me:$LINENO: checking for sinhf in -lm" >&5
18968 echo $ECHO_N "checking for sinhf in -lm... $ECHO_C" >&6
18969 if test "${ac_cv_lib_m_sinhf+set}" = set; then
18970   echo $ECHO_N "(cached) $ECHO_C" >&6
18971 else
18972   ac_check_lib_save_LIBS=$LIBS
18973 LIBS="-lm  $LIBS"
18974 if test x$gcc_no_link = xyes; then
18975   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18976 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18977    { (exit 1); exit 1; }; }
18978 fi
18979 cat >conftest.$ac_ext <<_ACEOF
18980 /* confdefs.h.  */
18981 _ACEOF
18982 cat confdefs.h >>conftest.$ac_ext
18983 cat >>conftest.$ac_ext <<_ACEOF
18984 /* end confdefs.h.  */
18985
18986 /* Override any gcc2 internal prototype to avoid an error.  */
18987 #ifdef __cplusplus
18988 extern "C"
18989 #endif
18990 /* We use char because int might match the return type of a gcc2
18991    builtin and then its argument prototype would still apply.  */
18992 char sinhf ();
18993 int
18994 main ()
18995 {
18996 sinhf ();
18997   ;
18998   return 0;
18999 }
19000 _ACEOF
19001 rm -f conftest.$ac_objext conftest$ac_exeext
19002 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19003   (eval $ac_link) 2>conftest.er1
19004   ac_status=$?
19005   grep -v '^ *+' conftest.er1 >conftest.err
19006   rm -f conftest.er1
19007   cat conftest.err >&5
19008   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19009   (exit $ac_status); } &&
19010          { ac_try='test -z "$ac_c_werror_flag"
19011                          || test ! -s conftest.err'
19012   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19013   (eval $ac_try) 2>&5
19014   ac_status=$?
19015   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19016   (exit $ac_status); }; } &&
19017          { ac_try='test -s conftest$ac_exeext'
19018   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19019   (eval $ac_try) 2>&5
19020   ac_status=$?
19021   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19022   (exit $ac_status); }; }; then
19023   ac_cv_lib_m_sinhf=yes
19024 else
19025   echo "$as_me: failed program was:" >&5
19026 sed 's/^/| /' conftest.$ac_ext >&5
19027
19028 ac_cv_lib_m_sinhf=no
19029 fi
19030 rm -f conftest.err conftest.$ac_objext \
19031       conftest$ac_exeext conftest.$ac_ext
19032 LIBS=$ac_check_lib_save_LIBS
19033 fi
19034 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinhf" >&5
19035 echo "${ECHO_T}$ac_cv_lib_m_sinhf" >&6
19036 if test $ac_cv_lib_m_sinhf = yes; then
19037
19038 cat >>confdefs.h <<\_ACEOF
19039 #define HAVE_SINHF 1
19040 _ACEOF
19041
19042 fi
19043
19044 echo "$as_me:$LINENO: checking for sinh in -lm" >&5
19045 echo $ECHO_N "checking for sinh in -lm... $ECHO_C" >&6
19046 if test "${ac_cv_lib_m_sinh+set}" = set; then
19047   echo $ECHO_N "(cached) $ECHO_C" >&6
19048 else
19049   ac_check_lib_save_LIBS=$LIBS
19050 LIBS="-lm  $LIBS"
19051 if test x$gcc_no_link = xyes; then
19052   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19053 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19054    { (exit 1); exit 1; }; }
19055 fi
19056 cat >conftest.$ac_ext <<_ACEOF
19057 /* confdefs.h.  */
19058 _ACEOF
19059 cat confdefs.h >>conftest.$ac_ext
19060 cat >>conftest.$ac_ext <<_ACEOF
19061 /* end confdefs.h.  */
19062
19063 /* Override any gcc2 internal prototype to avoid an error.  */
19064 #ifdef __cplusplus
19065 extern "C"
19066 #endif
19067 /* We use char because int might match the return type of a gcc2
19068    builtin and then its argument prototype would still apply.  */
19069 char sinh ();
19070 int
19071 main ()
19072 {
19073 sinh ();
19074   ;
19075   return 0;
19076 }
19077 _ACEOF
19078 rm -f conftest.$ac_objext conftest$ac_exeext
19079 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19080   (eval $ac_link) 2>conftest.er1
19081   ac_status=$?
19082   grep -v '^ *+' conftest.er1 >conftest.err
19083   rm -f conftest.er1
19084   cat conftest.err >&5
19085   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19086   (exit $ac_status); } &&
19087          { ac_try='test -z "$ac_c_werror_flag"
19088                          || test ! -s conftest.err'
19089   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19090   (eval $ac_try) 2>&5
19091   ac_status=$?
19092   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19093   (exit $ac_status); }; } &&
19094          { ac_try='test -s conftest$ac_exeext'
19095   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19096   (eval $ac_try) 2>&5
19097   ac_status=$?
19098   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19099   (exit $ac_status); }; }; then
19100   ac_cv_lib_m_sinh=yes
19101 else
19102   echo "$as_me: failed program was:" >&5
19103 sed 's/^/| /' conftest.$ac_ext >&5
19104
19105 ac_cv_lib_m_sinh=no
19106 fi
19107 rm -f conftest.err conftest.$ac_objext \
19108       conftest$ac_exeext conftest.$ac_ext
19109 LIBS=$ac_check_lib_save_LIBS
19110 fi
19111 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinh" >&5
19112 echo "${ECHO_T}$ac_cv_lib_m_sinh" >&6
19113 if test $ac_cv_lib_m_sinh = yes; then
19114
19115 cat >>confdefs.h <<\_ACEOF
19116 #define HAVE_SINH 1
19117 _ACEOF
19118
19119 fi
19120
19121 echo "$as_me:$LINENO: checking for sinhl in -lm" >&5
19122 echo $ECHO_N "checking for sinhl in -lm... $ECHO_C" >&6
19123 if test "${ac_cv_lib_m_sinhl+set}" = set; then
19124   echo $ECHO_N "(cached) $ECHO_C" >&6
19125 else
19126   ac_check_lib_save_LIBS=$LIBS
19127 LIBS="-lm  $LIBS"
19128 if test x$gcc_no_link = xyes; then
19129   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19130 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19131    { (exit 1); exit 1; }; }
19132 fi
19133 cat >conftest.$ac_ext <<_ACEOF
19134 /* confdefs.h.  */
19135 _ACEOF
19136 cat confdefs.h >>conftest.$ac_ext
19137 cat >>conftest.$ac_ext <<_ACEOF
19138 /* end confdefs.h.  */
19139
19140 /* Override any gcc2 internal prototype to avoid an error.  */
19141 #ifdef __cplusplus
19142 extern "C"
19143 #endif
19144 /* We use char because int might match the return type of a gcc2
19145    builtin and then its argument prototype would still apply.  */
19146 char sinhl ();
19147 int
19148 main ()
19149 {
19150 sinhl ();
19151   ;
19152   return 0;
19153 }
19154 _ACEOF
19155 rm -f conftest.$ac_objext conftest$ac_exeext
19156 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19157   (eval $ac_link) 2>conftest.er1
19158   ac_status=$?
19159   grep -v '^ *+' conftest.er1 >conftest.err
19160   rm -f conftest.er1
19161   cat conftest.err >&5
19162   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19163   (exit $ac_status); } &&
19164          { ac_try='test -z "$ac_c_werror_flag"
19165                          || test ! -s conftest.err'
19166   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19167   (eval $ac_try) 2>&5
19168   ac_status=$?
19169   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19170   (exit $ac_status); }; } &&
19171          { ac_try='test -s conftest$ac_exeext'
19172   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19173   (eval $ac_try) 2>&5
19174   ac_status=$?
19175   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19176   (exit $ac_status); }; }; then
19177   ac_cv_lib_m_sinhl=yes
19178 else
19179   echo "$as_me: failed program was:" >&5
19180 sed 's/^/| /' conftest.$ac_ext >&5
19181
19182 ac_cv_lib_m_sinhl=no
19183 fi
19184 rm -f conftest.err conftest.$ac_objext \
19185       conftest$ac_exeext conftest.$ac_ext
19186 LIBS=$ac_check_lib_save_LIBS
19187 fi
19188 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinhl" >&5
19189 echo "${ECHO_T}$ac_cv_lib_m_sinhl" >&6
19190 if test $ac_cv_lib_m_sinhl = yes; then
19191
19192 cat >>confdefs.h <<\_ACEOF
19193 #define HAVE_SINHL 1
19194 _ACEOF
19195
19196 fi
19197
19198 echo "$as_me:$LINENO: checking for csinhf in -lm" >&5
19199 echo $ECHO_N "checking for csinhf in -lm... $ECHO_C" >&6
19200 if test "${ac_cv_lib_m_csinhf+set}" = set; then
19201   echo $ECHO_N "(cached) $ECHO_C" >&6
19202 else
19203   ac_check_lib_save_LIBS=$LIBS
19204 LIBS="-lm  $LIBS"
19205 if test x$gcc_no_link = xyes; then
19206   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19207 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19208    { (exit 1); exit 1; }; }
19209 fi
19210 cat >conftest.$ac_ext <<_ACEOF
19211 /* confdefs.h.  */
19212 _ACEOF
19213 cat confdefs.h >>conftest.$ac_ext
19214 cat >>conftest.$ac_ext <<_ACEOF
19215 /* end confdefs.h.  */
19216
19217 /* Override any gcc2 internal prototype to avoid an error.  */
19218 #ifdef __cplusplus
19219 extern "C"
19220 #endif
19221 /* We use char because int might match the return type of a gcc2
19222    builtin and then its argument prototype would still apply.  */
19223 char csinhf ();
19224 int
19225 main ()
19226 {
19227 csinhf ();
19228   ;
19229   return 0;
19230 }
19231 _ACEOF
19232 rm -f conftest.$ac_objext conftest$ac_exeext
19233 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19234   (eval $ac_link) 2>conftest.er1
19235   ac_status=$?
19236   grep -v '^ *+' conftest.er1 >conftest.err
19237   rm -f conftest.er1
19238   cat conftest.err >&5
19239   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19240   (exit $ac_status); } &&
19241          { ac_try='test -z "$ac_c_werror_flag"
19242                          || test ! -s conftest.err'
19243   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19244   (eval $ac_try) 2>&5
19245   ac_status=$?
19246   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19247   (exit $ac_status); }; } &&
19248          { ac_try='test -s conftest$ac_exeext'
19249   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19250   (eval $ac_try) 2>&5
19251   ac_status=$?
19252   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19253   (exit $ac_status); }; }; then
19254   ac_cv_lib_m_csinhf=yes
19255 else
19256   echo "$as_me: failed program was:" >&5
19257 sed 's/^/| /' conftest.$ac_ext >&5
19258
19259 ac_cv_lib_m_csinhf=no
19260 fi
19261 rm -f conftest.err conftest.$ac_objext \
19262       conftest$ac_exeext conftest.$ac_ext
19263 LIBS=$ac_check_lib_save_LIBS
19264 fi
19265 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinhf" >&5
19266 echo "${ECHO_T}$ac_cv_lib_m_csinhf" >&6
19267 if test $ac_cv_lib_m_csinhf = yes; then
19268
19269 cat >>confdefs.h <<\_ACEOF
19270 #define HAVE_CSINHF 1
19271 _ACEOF
19272
19273 fi
19274
19275 echo "$as_me:$LINENO: checking for csinh in -lm" >&5
19276 echo $ECHO_N "checking for csinh in -lm... $ECHO_C" >&6
19277 if test "${ac_cv_lib_m_csinh+set}" = set; then
19278   echo $ECHO_N "(cached) $ECHO_C" >&6
19279 else
19280   ac_check_lib_save_LIBS=$LIBS
19281 LIBS="-lm  $LIBS"
19282 if test x$gcc_no_link = xyes; then
19283   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19284 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19285    { (exit 1); exit 1; }; }
19286 fi
19287 cat >conftest.$ac_ext <<_ACEOF
19288 /* confdefs.h.  */
19289 _ACEOF
19290 cat confdefs.h >>conftest.$ac_ext
19291 cat >>conftest.$ac_ext <<_ACEOF
19292 /* end confdefs.h.  */
19293
19294 /* Override any gcc2 internal prototype to avoid an error.  */
19295 #ifdef __cplusplus
19296 extern "C"
19297 #endif
19298 /* We use char because int might match the return type of a gcc2
19299    builtin and then its argument prototype would still apply.  */
19300 char csinh ();
19301 int
19302 main ()
19303 {
19304 csinh ();
19305   ;
19306   return 0;
19307 }
19308 _ACEOF
19309 rm -f conftest.$ac_objext conftest$ac_exeext
19310 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19311   (eval $ac_link) 2>conftest.er1
19312   ac_status=$?
19313   grep -v '^ *+' conftest.er1 >conftest.err
19314   rm -f conftest.er1
19315   cat conftest.err >&5
19316   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19317   (exit $ac_status); } &&
19318          { ac_try='test -z "$ac_c_werror_flag"
19319                          || test ! -s conftest.err'
19320   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19321   (eval $ac_try) 2>&5
19322   ac_status=$?
19323   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19324   (exit $ac_status); }; } &&
19325          { ac_try='test -s conftest$ac_exeext'
19326   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19327   (eval $ac_try) 2>&5
19328   ac_status=$?
19329   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19330   (exit $ac_status); }; }; then
19331   ac_cv_lib_m_csinh=yes
19332 else
19333   echo "$as_me: failed program was:" >&5
19334 sed 's/^/| /' conftest.$ac_ext >&5
19335
19336 ac_cv_lib_m_csinh=no
19337 fi
19338 rm -f conftest.err conftest.$ac_objext \
19339       conftest$ac_exeext conftest.$ac_ext
19340 LIBS=$ac_check_lib_save_LIBS
19341 fi
19342 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinh" >&5
19343 echo "${ECHO_T}$ac_cv_lib_m_csinh" >&6
19344 if test $ac_cv_lib_m_csinh = yes; then
19345
19346 cat >>confdefs.h <<\_ACEOF
19347 #define HAVE_CSINH 1
19348 _ACEOF
19349
19350 fi
19351
19352 echo "$as_me:$LINENO: checking for csinhl in -lm" >&5
19353 echo $ECHO_N "checking for csinhl in -lm... $ECHO_C" >&6
19354 if test "${ac_cv_lib_m_csinhl+set}" = set; then
19355   echo $ECHO_N "(cached) $ECHO_C" >&6
19356 else
19357   ac_check_lib_save_LIBS=$LIBS
19358 LIBS="-lm  $LIBS"
19359 if test x$gcc_no_link = xyes; then
19360   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19361 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19362    { (exit 1); exit 1; }; }
19363 fi
19364 cat >conftest.$ac_ext <<_ACEOF
19365 /* confdefs.h.  */
19366 _ACEOF
19367 cat confdefs.h >>conftest.$ac_ext
19368 cat >>conftest.$ac_ext <<_ACEOF
19369 /* end confdefs.h.  */
19370
19371 /* Override any gcc2 internal prototype to avoid an error.  */
19372 #ifdef __cplusplus
19373 extern "C"
19374 #endif
19375 /* We use char because int might match the return type of a gcc2
19376    builtin and then its argument prototype would still apply.  */
19377 char csinhl ();
19378 int
19379 main ()
19380 {
19381 csinhl ();
19382   ;
19383   return 0;
19384 }
19385 _ACEOF
19386 rm -f conftest.$ac_objext conftest$ac_exeext
19387 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19388   (eval $ac_link) 2>conftest.er1
19389   ac_status=$?
19390   grep -v '^ *+' conftest.er1 >conftest.err
19391   rm -f conftest.er1
19392   cat conftest.err >&5
19393   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19394   (exit $ac_status); } &&
19395          { ac_try='test -z "$ac_c_werror_flag"
19396                          || test ! -s conftest.err'
19397   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19398   (eval $ac_try) 2>&5
19399   ac_status=$?
19400   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19401   (exit $ac_status); }; } &&
19402          { ac_try='test -s conftest$ac_exeext'
19403   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19404   (eval $ac_try) 2>&5
19405   ac_status=$?
19406   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19407   (exit $ac_status); }; }; then
19408   ac_cv_lib_m_csinhl=yes
19409 else
19410   echo "$as_me: failed program was:" >&5
19411 sed 's/^/| /' conftest.$ac_ext >&5
19412
19413 ac_cv_lib_m_csinhl=no
19414 fi
19415 rm -f conftest.err conftest.$ac_objext \
19416       conftest$ac_exeext conftest.$ac_ext
19417 LIBS=$ac_check_lib_save_LIBS
19418 fi
19419 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinhl" >&5
19420 echo "${ECHO_T}$ac_cv_lib_m_csinhl" >&6
19421 if test $ac_cv_lib_m_csinhl = yes; then
19422
19423 cat >>confdefs.h <<\_ACEOF
19424 #define HAVE_CSINHL 1
19425 _ACEOF
19426
19427 fi
19428
19429 echo "$as_me:$LINENO: checking for sqrtf in -lm" >&5
19430 echo $ECHO_N "checking for sqrtf in -lm... $ECHO_C" >&6
19431 if test "${ac_cv_lib_m_sqrtf+set}" = set; then
19432   echo $ECHO_N "(cached) $ECHO_C" >&6
19433 else
19434   ac_check_lib_save_LIBS=$LIBS
19435 LIBS="-lm  $LIBS"
19436 if test x$gcc_no_link = xyes; then
19437   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19438 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19439    { (exit 1); exit 1; }; }
19440 fi
19441 cat >conftest.$ac_ext <<_ACEOF
19442 /* confdefs.h.  */
19443 _ACEOF
19444 cat confdefs.h >>conftest.$ac_ext
19445 cat >>conftest.$ac_ext <<_ACEOF
19446 /* end confdefs.h.  */
19447
19448 /* Override any gcc2 internal prototype to avoid an error.  */
19449 #ifdef __cplusplus
19450 extern "C"
19451 #endif
19452 /* We use char because int might match the return type of a gcc2
19453    builtin and then its argument prototype would still apply.  */
19454 char sqrtf ();
19455 int
19456 main ()
19457 {
19458 sqrtf ();
19459   ;
19460   return 0;
19461 }
19462 _ACEOF
19463 rm -f conftest.$ac_objext conftest$ac_exeext
19464 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19465   (eval $ac_link) 2>conftest.er1
19466   ac_status=$?
19467   grep -v '^ *+' conftest.er1 >conftest.err
19468   rm -f conftest.er1
19469   cat conftest.err >&5
19470   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19471   (exit $ac_status); } &&
19472          { ac_try='test -z "$ac_c_werror_flag"
19473                          || test ! -s conftest.err'
19474   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19475   (eval $ac_try) 2>&5
19476   ac_status=$?
19477   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19478   (exit $ac_status); }; } &&
19479          { ac_try='test -s conftest$ac_exeext'
19480   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19481   (eval $ac_try) 2>&5
19482   ac_status=$?
19483   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19484   (exit $ac_status); }; }; then
19485   ac_cv_lib_m_sqrtf=yes
19486 else
19487   echo "$as_me: failed program was:" >&5
19488 sed 's/^/| /' conftest.$ac_ext >&5
19489
19490 ac_cv_lib_m_sqrtf=no
19491 fi
19492 rm -f conftest.err conftest.$ac_objext \
19493       conftest$ac_exeext conftest.$ac_ext
19494 LIBS=$ac_check_lib_save_LIBS
19495 fi
19496 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrtf" >&5
19497 echo "${ECHO_T}$ac_cv_lib_m_sqrtf" >&6
19498 if test $ac_cv_lib_m_sqrtf = yes; then
19499
19500 cat >>confdefs.h <<\_ACEOF
19501 #define HAVE_SQRTF 1
19502 _ACEOF
19503
19504 fi
19505
19506 echo "$as_me:$LINENO: checking for sqrt in -lm" >&5
19507 echo $ECHO_N "checking for sqrt in -lm... $ECHO_C" >&6
19508 if test "${ac_cv_lib_m_sqrt+set}" = set; then
19509   echo $ECHO_N "(cached) $ECHO_C" >&6
19510 else
19511   ac_check_lib_save_LIBS=$LIBS
19512 LIBS="-lm  $LIBS"
19513 if test x$gcc_no_link = xyes; then
19514   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19515 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19516    { (exit 1); exit 1; }; }
19517 fi
19518 cat >conftest.$ac_ext <<_ACEOF
19519 /* confdefs.h.  */
19520 _ACEOF
19521 cat confdefs.h >>conftest.$ac_ext
19522 cat >>conftest.$ac_ext <<_ACEOF
19523 /* end confdefs.h.  */
19524
19525 /* Override any gcc2 internal prototype to avoid an error.  */
19526 #ifdef __cplusplus
19527 extern "C"
19528 #endif
19529 /* We use char because int might match the return type of a gcc2
19530    builtin and then its argument prototype would still apply.  */
19531 char sqrt ();
19532 int
19533 main ()
19534 {
19535 sqrt ();
19536   ;
19537   return 0;
19538 }
19539 _ACEOF
19540 rm -f conftest.$ac_objext conftest$ac_exeext
19541 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19542   (eval $ac_link) 2>conftest.er1
19543   ac_status=$?
19544   grep -v '^ *+' conftest.er1 >conftest.err
19545   rm -f conftest.er1
19546   cat conftest.err >&5
19547   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19548   (exit $ac_status); } &&
19549          { ac_try='test -z "$ac_c_werror_flag"
19550                          || test ! -s conftest.err'
19551   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19552   (eval $ac_try) 2>&5
19553   ac_status=$?
19554   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19555   (exit $ac_status); }; } &&
19556          { ac_try='test -s conftest$ac_exeext'
19557   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19558   (eval $ac_try) 2>&5
19559   ac_status=$?
19560   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19561   (exit $ac_status); }; }; then
19562   ac_cv_lib_m_sqrt=yes
19563 else
19564   echo "$as_me: failed program was:" >&5
19565 sed 's/^/| /' conftest.$ac_ext >&5
19566
19567 ac_cv_lib_m_sqrt=no
19568 fi
19569 rm -f conftest.err conftest.$ac_objext \
19570       conftest$ac_exeext conftest.$ac_ext
19571 LIBS=$ac_check_lib_save_LIBS
19572 fi
19573 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrt" >&5
19574 echo "${ECHO_T}$ac_cv_lib_m_sqrt" >&6
19575 if test $ac_cv_lib_m_sqrt = yes; then
19576
19577 cat >>confdefs.h <<\_ACEOF
19578 #define HAVE_SQRT 1
19579 _ACEOF
19580
19581 fi
19582
19583 echo "$as_me:$LINENO: checking for sqrtl in -lm" >&5
19584 echo $ECHO_N "checking for sqrtl in -lm... $ECHO_C" >&6
19585 if test "${ac_cv_lib_m_sqrtl+set}" = set; then
19586   echo $ECHO_N "(cached) $ECHO_C" >&6
19587 else
19588   ac_check_lib_save_LIBS=$LIBS
19589 LIBS="-lm  $LIBS"
19590 if test x$gcc_no_link = xyes; then
19591   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19592 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19593    { (exit 1); exit 1; }; }
19594 fi
19595 cat >conftest.$ac_ext <<_ACEOF
19596 /* confdefs.h.  */
19597 _ACEOF
19598 cat confdefs.h >>conftest.$ac_ext
19599 cat >>conftest.$ac_ext <<_ACEOF
19600 /* end confdefs.h.  */
19601
19602 /* Override any gcc2 internal prototype to avoid an error.  */
19603 #ifdef __cplusplus
19604 extern "C"
19605 #endif
19606 /* We use char because int might match the return type of a gcc2
19607    builtin and then its argument prototype would still apply.  */
19608 char sqrtl ();
19609 int
19610 main ()
19611 {
19612 sqrtl ();
19613   ;
19614   return 0;
19615 }
19616 _ACEOF
19617 rm -f conftest.$ac_objext conftest$ac_exeext
19618 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19619   (eval $ac_link) 2>conftest.er1
19620   ac_status=$?
19621   grep -v '^ *+' conftest.er1 >conftest.err
19622   rm -f conftest.er1
19623   cat conftest.err >&5
19624   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19625   (exit $ac_status); } &&
19626          { ac_try='test -z "$ac_c_werror_flag"
19627                          || test ! -s conftest.err'
19628   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19629   (eval $ac_try) 2>&5
19630   ac_status=$?
19631   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19632   (exit $ac_status); }; } &&
19633          { ac_try='test -s conftest$ac_exeext'
19634   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19635   (eval $ac_try) 2>&5
19636   ac_status=$?
19637   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19638   (exit $ac_status); }; }; then
19639   ac_cv_lib_m_sqrtl=yes
19640 else
19641   echo "$as_me: failed program was:" >&5
19642 sed 's/^/| /' conftest.$ac_ext >&5
19643
19644 ac_cv_lib_m_sqrtl=no
19645 fi
19646 rm -f conftest.err conftest.$ac_objext \
19647       conftest$ac_exeext conftest.$ac_ext
19648 LIBS=$ac_check_lib_save_LIBS
19649 fi
19650 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrtl" >&5
19651 echo "${ECHO_T}$ac_cv_lib_m_sqrtl" >&6
19652 if test $ac_cv_lib_m_sqrtl = yes; then
19653
19654 cat >>confdefs.h <<\_ACEOF
19655 #define HAVE_SQRTL 1
19656 _ACEOF
19657
19658 fi
19659
19660 echo "$as_me:$LINENO: checking for csqrtf in -lm" >&5
19661 echo $ECHO_N "checking for csqrtf in -lm... $ECHO_C" >&6
19662 if test "${ac_cv_lib_m_csqrtf+set}" = set; then
19663   echo $ECHO_N "(cached) $ECHO_C" >&6
19664 else
19665   ac_check_lib_save_LIBS=$LIBS
19666 LIBS="-lm  $LIBS"
19667 if test x$gcc_no_link = xyes; then
19668   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19669 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19670    { (exit 1); exit 1; }; }
19671 fi
19672 cat >conftest.$ac_ext <<_ACEOF
19673 /* confdefs.h.  */
19674 _ACEOF
19675 cat confdefs.h >>conftest.$ac_ext
19676 cat >>conftest.$ac_ext <<_ACEOF
19677 /* end confdefs.h.  */
19678
19679 /* Override any gcc2 internal prototype to avoid an error.  */
19680 #ifdef __cplusplus
19681 extern "C"
19682 #endif
19683 /* We use char because int might match the return type of a gcc2
19684    builtin and then its argument prototype would still apply.  */
19685 char csqrtf ();
19686 int
19687 main ()
19688 {
19689 csqrtf ();
19690   ;
19691   return 0;
19692 }
19693 _ACEOF
19694 rm -f conftest.$ac_objext conftest$ac_exeext
19695 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19696   (eval $ac_link) 2>conftest.er1
19697   ac_status=$?
19698   grep -v '^ *+' conftest.er1 >conftest.err
19699   rm -f conftest.er1
19700   cat conftest.err >&5
19701   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19702   (exit $ac_status); } &&
19703          { ac_try='test -z "$ac_c_werror_flag"
19704                          || test ! -s conftest.err'
19705   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19706   (eval $ac_try) 2>&5
19707   ac_status=$?
19708   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19709   (exit $ac_status); }; } &&
19710          { ac_try='test -s conftest$ac_exeext'
19711   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19712   (eval $ac_try) 2>&5
19713   ac_status=$?
19714   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19715   (exit $ac_status); }; }; then
19716   ac_cv_lib_m_csqrtf=yes
19717 else
19718   echo "$as_me: failed program was:" >&5
19719 sed 's/^/| /' conftest.$ac_ext >&5
19720
19721 ac_cv_lib_m_csqrtf=no
19722 fi
19723 rm -f conftest.err conftest.$ac_objext \
19724       conftest$ac_exeext conftest.$ac_ext
19725 LIBS=$ac_check_lib_save_LIBS
19726 fi
19727 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrtf" >&5
19728 echo "${ECHO_T}$ac_cv_lib_m_csqrtf" >&6
19729 if test $ac_cv_lib_m_csqrtf = yes; then
19730
19731 cat >>confdefs.h <<\_ACEOF
19732 #define HAVE_CSQRTF 1
19733 _ACEOF
19734
19735 fi
19736
19737 echo "$as_me:$LINENO: checking for csqrt in -lm" >&5
19738 echo $ECHO_N "checking for csqrt in -lm... $ECHO_C" >&6
19739 if test "${ac_cv_lib_m_csqrt+set}" = set; then
19740   echo $ECHO_N "(cached) $ECHO_C" >&6
19741 else
19742   ac_check_lib_save_LIBS=$LIBS
19743 LIBS="-lm  $LIBS"
19744 if test x$gcc_no_link = xyes; then
19745   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19746 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19747    { (exit 1); exit 1; }; }
19748 fi
19749 cat >conftest.$ac_ext <<_ACEOF
19750 /* confdefs.h.  */
19751 _ACEOF
19752 cat confdefs.h >>conftest.$ac_ext
19753 cat >>conftest.$ac_ext <<_ACEOF
19754 /* end confdefs.h.  */
19755
19756 /* Override any gcc2 internal prototype to avoid an error.  */
19757 #ifdef __cplusplus
19758 extern "C"
19759 #endif
19760 /* We use char because int might match the return type of a gcc2
19761    builtin and then its argument prototype would still apply.  */
19762 char csqrt ();
19763 int
19764 main ()
19765 {
19766 csqrt ();
19767   ;
19768   return 0;
19769 }
19770 _ACEOF
19771 rm -f conftest.$ac_objext conftest$ac_exeext
19772 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19773   (eval $ac_link) 2>conftest.er1
19774   ac_status=$?
19775   grep -v '^ *+' conftest.er1 >conftest.err
19776   rm -f conftest.er1
19777   cat conftest.err >&5
19778   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19779   (exit $ac_status); } &&
19780          { ac_try='test -z "$ac_c_werror_flag"
19781                          || test ! -s conftest.err'
19782   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19783   (eval $ac_try) 2>&5
19784   ac_status=$?
19785   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19786   (exit $ac_status); }; } &&
19787          { ac_try='test -s conftest$ac_exeext'
19788   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19789   (eval $ac_try) 2>&5
19790   ac_status=$?
19791   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19792   (exit $ac_status); }; }; then
19793   ac_cv_lib_m_csqrt=yes
19794 else
19795   echo "$as_me: failed program was:" >&5
19796 sed 's/^/| /' conftest.$ac_ext >&5
19797
19798 ac_cv_lib_m_csqrt=no
19799 fi
19800 rm -f conftest.err conftest.$ac_objext \
19801       conftest$ac_exeext conftest.$ac_ext
19802 LIBS=$ac_check_lib_save_LIBS
19803 fi
19804 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrt" >&5
19805 echo "${ECHO_T}$ac_cv_lib_m_csqrt" >&6
19806 if test $ac_cv_lib_m_csqrt = yes; then
19807
19808 cat >>confdefs.h <<\_ACEOF
19809 #define HAVE_CSQRT 1
19810 _ACEOF
19811
19812 fi
19813
19814 echo "$as_me:$LINENO: checking for csqrtl in -lm" >&5
19815 echo $ECHO_N "checking for csqrtl in -lm... $ECHO_C" >&6
19816 if test "${ac_cv_lib_m_csqrtl+set}" = set; then
19817   echo $ECHO_N "(cached) $ECHO_C" >&6
19818 else
19819   ac_check_lib_save_LIBS=$LIBS
19820 LIBS="-lm  $LIBS"
19821 if test x$gcc_no_link = xyes; then
19822   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19823 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19824    { (exit 1); exit 1; }; }
19825 fi
19826 cat >conftest.$ac_ext <<_ACEOF
19827 /* confdefs.h.  */
19828 _ACEOF
19829 cat confdefs.h >>conftest.$ac_ext
19830 cat >>conftest.$ac_ext <<_ACEOF
19831 /* end confdefs.h.  */
19832
19833 /* Override any gcc2 internal prototype to avoid an error.  */
19834 #ifdef __cplusplus
19835 extern "C"
19836 #endif
19837 /* We use char because int might match the return type of a gcc2
19838    builtin and then its argument prototype would still apply.  */
19839 char csqrtl ();
19840 int
19841 main ()
19842 {
19843 csqrtl ();
19844   ;
19845   return 0;
19846 }
19847 _ACEOF
19848 rm -f conftest.$ac_objext conftest$ac_exeext
19849 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19850   (eval $ac_link) 2>conftest.er1
19851   ac_status=$?
19852   grep -v '^ *+' conftest.er1 >conftest.err
19853   rm -f conftest.er1
19854   cat conftest.err >&5
19855   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19856   (exit $ac_status); } &&
19857          { ac_try='test -z "$ac_c_werror_flag"
19858                          || test ! -s conftest.err'
19859   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19860   (eval $ac_try) 2>&5
19861   ac_status=$?
19862   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19863   (exit $ac_status); }; } &&
19864          { ac_try='test -s conftest$ac_exeext'
19865   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19866   (eval $ac_try) 2>&5
19867   ac_status=$?
19868   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19869   (exit $ac_status); }; }; then
19870   ac_cv_lib_m_csqrtl=yes
19871 else
19872   echo "$as_me: failed program was:" >&5
19873 sed 's/^/| /' conftest.$ac_ext >&5
19874
19875 ac_cv_lib_m_csqrtl=no
19876 fi
19877 rm -f conftest.err conftest.$ac_objext \
19878       conftest$ac_exeext conftest.$ac_ext
19879 LIBS=$ac_check_lib_save_LIBS
19880 fi
19881 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrtl" >&5
19882 echo "${ECHO_T}$ac_cv_lib_m_csqrtl" >&6
19883 if test $ac_cv_lib_m_csqrtl = yes; then
19884
19885 cat >>confdefs.h <<\_ACEOF
19886 #define HAVE_CSQRTL 1
19887 _ACEOF
19888
19889 fi
19890
19891 echo "$as_me:$LINENO: checking for tanf in -lm" >&5
19892 echo $ECHO_N "checking for tanf in -lm... $ECHO_C" >&6
19893 if test "${ac_cv_lib_m_tanf+set}" = set; then
19894   echo $ECHO_N "(cached) $ECHO_C" >&6
19895 else
19896   ac_check_lib_save_LIBS=$LIBS
19897 LIBS="-lm  $LIBS"
19898 if test x$gcc_no_link = xyes; then
19899   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19900 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19901    { (exit 1); exit 1; }; }
19902 fi
19903 cat >conftest.$ac_ext <<_ACEOF
19904 /* confdefs.h.  */
19905 _ACEOF
19906 cat confdefs.h >>conftest.$ac_ext
19907 cat >>conftest.$ac_ext <<_ACEOF
19908 /* end confdefs.h.  */
19909
19910 /* Override any gcc2 internal prototype to avoid an error.  */
19911 #ifdef __cplusplus
19912 extern "C"
19913 #endif
19914 /* We use char because int might match the return type of a gcc2
19915    builtin and then its argument prototype would still apply.  */
19916 char tanf ();
19917 int
19918 main ()
19919 {
19920 tanf ();
19921   ;
19922   return 0;
19923 }
19924 _ACEOF
19925 rm -f conftest.$ac_objext conftest$ac_exeext
19926 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19927   (eval $ac_link) 2>conftest.er1
19928   ac_status=$?
19929   grep -v '^ *+' conftest.er1 >conftest.err
19930   rm -f conftest.er1
19931   cat conftest.err >&5
19932   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19933   (exit $ac_status); } &&
19934          { ac_try='test -z "$ac_c_werror_flag"
19935                          || test ! -s conftest.err'
19936   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19937   (eval $ac_try) 2>&5
19938   ac_status=$?
19939   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19940   (exit $ac_status); }; } &&
19941          { ac_try='test -s conftest$ac_exeext'
19942   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19943   (eval $ac_try) 2>&5
19944   ac_status=$?
19945   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19946   (exit $ac_status); }; }; then
19947   ac_cv_lib_m_tanf=yes
19948 else
19949   echo "$as_me: failed program was:" >&5
19950 sed 's/^/| /' conftest.$ac_ext >&5
19951
19952 ac_cv_lib_m_tanf=no
19953 fi
19954 rm -f conftest.err conftest.$ac_objext \
19955       conftest$ac_exeext conftest.$ac_ext
19956 LIBS=$ac_check_lib_save_LIBS
19957 fi
19958 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanf" >&5
19959 echo "${ECHO_T}$ac_cv_lib_m_tanf" >&6
19960 if test $ac_cv_lib_m_tanf = yes; then
19961
19962 cat >>confdefs.h <<\_ACEOF
19963 #define HAVE_TANF 1
19964 _ACEOF
19965
19966 fi
19967
19968 echo "$as_me:$LINENO: checking for tan in -lm" >&5
19969 echo $ECHO_N "checking for tan in -lm... $ECHO_C" >&6
19970 if test "${ac_cv_lib_m_tan+set}" = set; then
19971   echo $ECHO_N "(cached) $ECHO_C" >&6
19972 else
19973   ac_check_lib_save_LIBS=$LIBS
19974 LIBS="-lm  $LIBS"
19975 if test x$gcc_no_link = xyes; then
19976   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19977 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19978    { (exit 1); exit 1; }; }
19979 fi
19980 cat >conftest.$ac_ext <<_ACEOF
19981 /* confdefs.h.  */
19982 _ACEOF
19983 cat confdefs.h >>conftest.$ac_ext
19984 cat >>conftest.$ac_ext <<_ACEOF
19985 /* end confdefs.h.  */
19986
19987 /* Override any gcc2 internal prototype to avoid an error.  */
19988 #ifdef __cplusplus
19989 extern "C"
19990 #endif
19991 /* We use char because int might match the return type of a gcc2
19992    builtin and then its argument prototype would still apply.  */
19993 char tan ();
19994 int
19995 main ()
19996 {
19997 tan ();
19998   ;
19999   return 0;
20000 }
20001 _ACEOF
20002 rm -f conftest.$ac_objext conftest$ac_exeext
20003 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20004   (eval $ac_link) 2>conftest.er1
20005   ac_status=$?
20006   grep -v '^ *+' conftest.er1 >conftest.err
20007   rm -f conftest.er1
20008   cat conftest.err >&5
20009   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20010   (exit $ac_status); } &&
20011          { ac_try='test -z "$ac_c_werror_flag"
20012                          || test ! -s conftest.err'
20013   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20014   (eval $ac_try) 2>&5
20015   ac_status=$?
20016   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20017   (exit $ac_status); }; } &&
20018          { ac_try='test -s conftest$ac_exeext'
20019   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20020   (eval $ac_try) 2>&5
20021   ac_status=$?
20022   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20023   (exit $ac_status); }; }; then
20024   ac_cv_lib_m_tan=yes
20025 else
20026   echo "$as_me: failed program was:" >&5
20027 sed 's/^/| /' conftest.$ac_ext >&5
20028
20029 ac_cv_lib_m_tan=no
20030 fi
20031 rm -f conftest.err conftest.$ac_objext \
20032       conftest$ac_exeext conftest.$ac_ext
20033 LIBS=$ac_check_lib_save_LIBS
20034 fi
20035 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tan" >&5
20036 echo "${ECHO_T}$ac_cv_lib_m_tan" >&6
20037 if test $ac_cv_lib_m_tan = yes; then
20038
20039 cat >>confdefs.h <<\_ACEOF
20040 #define HAVE_TAN 1
20041 _ACEOF
20042
20043 fi
20044
20045 echo "$as_me:$LINENO: checking for tanl in -lm" >&5
20046 echo $ECHO_N "checking for tanl in -lm... $ECHO_C" >&6
20047 if test "${ac_cv_lib_m_tanl+set}" = set; then
20048   echo $ECHO_N "(cached) $ECHO_C" >&6
20049 else
20050   ac_check_lib_save_LIBS=$LIBS
20051 LIBS="-lm  $LIBS"
20052 if test x$gcc_no_link = xyes; then
20053   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20054 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20055    { (exit 1); exit 1; }; }
20056 fi
20057 cat >conftest.$ac_ext <<_ACEOF
20058 /* confdefs.h.  */
20059 _ACEOF
20060 cat confdefs.h >>conftest.$ac_ext
20061 cat >>conftest.$ac_ext <<_ACEOF
20062 /* end confdefs.h.  */
20063
20064 /* Override any gcc2 internal prototype to avoid an error.  */
20065 #ifdef __cplusplus
20066 extern "C"
20067 #endif
20068 /* We use char because int might match the return type of a gcc2
20069    builtin and then its argument prototype would still apply.  */
20070 char tanl ();
20071 int
20072 main ()
20073 {
20074 tanl ();
20075   ;
20076   return 0;
20077 }
20078 _ACEOF
20079 rm -f conftest.$ac_objext conftest$ac_exeext
20080 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20081   (eval $ac_link) 2>conftest.er1
20082   ac_status=$?
20083   grep -v '^ *+' conftest.er1 >conftest.err
20084   rm -f conftest.er1
20085   cat conftest.err >&5
20086   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20087   (exit $ac_status); } &&
20088          { ac_try='test -z "$ac_c_werror_flag"
20089                          || test ! -s conftest.err'
20090   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20091   (eval $ac_try) 2>&5
20092   ac_status=$?
20093   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20094   (exit $ac_status); }; } &&
20095          { ac_try='test -s conftest$ac_exeext'
20096   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20097   (eval $ac_try) 2>&5
20098   ac_status=$?
20099   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20100   (exit $ac_status); }; }; then
20101   ac_cv_lib_m_tanl=yes
20102 else
20103   echo "$as_me: failed program was:" >&5
20104 sed 's/^/| /' conftest.$ac_ext >&5
20105
20106 ac_cv_lib_m_tanl=no
20107 fi
20108 rm -f conftest.err conftest.$ac_objext \
20109       conftest$ac_exeext conftest.$ac_ext
20110 LIBS=$ac_check_lib_save_LIBS
20111 fi
20112 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanl" >&5
20113 echo "${ECHO_T}$ac_cv_lib_m_tanl" >&6
20114 if test $ac_cv_lib_m_tanl = yes; then
20115
20116 cat >>confdefs.h <<\_ACEOF
20117 #define HAVE_TANL 1
20118 _ACEOF
20119
20120 fi
20121
20122 echo "$as_me:$LINENO: checking for ctanf in -lm" >&5
20123 echo $ECHO_N "checking for ctanf in -lm... $ECHO_C" >&6
20124 if test "${ac_cv_lib_m_ctanf+set}" = set; then
20125   echo $ECHO_N "(cached) $ECHO_C" >&6
20126 else
20127   ac_check_lib_save_LIBS=$LIBS
20128 LIBS="-lm  $LIBS"
20129 if test x$gcc_no_link = xyes; then
20130   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20131 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20132    { (exit 1); exit 1; }; }
20133 fi
20134 cat >conftest.$ac_ext <<_ACEOF
20135 /* confdefs.h.  */
20136 _ACEOF
20137 cat confdefs.h >>conftest.$ac_ext
20138 cat >>conftest.$ac_ext <<_ACEOF
20139 /* end confdefs.h.  */
20140
20141 /* Override any gcc2 internal prototype to avoid an error.  */
20142 #ifdef __cplusplus
20143 extern "C"
20144 #endif
20145 /* We use char because int might match the return type of a gcc2
20146    builtin and then its argument prototype would still apply.  */
20147 char ctanf ();
20148 int
20149 main ()
20150 {
20151 ctanf ();
20152   ;
20153   return 0;
20154 }
20155 _ACEOF
20156 rm -f conftest.$ac_objext conftest$ac_exeext
20157 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20158   (eval $ac_link) 2>conftest.er1
20159   ac_status=$?
20160   grep -v '^ *+' conftest.er1 >conftest.err
20161   rm -f conftest.er1
20162   cat conftest.err >&5
20163   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20164   (exit $ac_status); } &&
20165          { ac_try='test -z "$ac_c_werror_flag"
20166                          || test ! -s conftest.err'
20167   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20168   (eval $ac_try) 2>&5
20169   ac_status=$?
20170   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20171   (exit $ac_status); }; } &&
20172          { ac_try='test -s conftest$ac_exeext'
20173   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20174   (eval $ac_try) 2>&5
20175   ac_status=$?
20176   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20177   (exit $ac_status); }; }; then
20178   ac_cv_lib_m_ctanf=yes
20179 else
20180   echo "$as_me: failed program was:" >&5
20181 sed 's/^/| /' conftest.$ac_ext >&5
20182
20183 ac_cv_lib_m_ctanf=no
20184 fi
20185 rm -f conftest.err conftest.$ac_objext \
20186       conftest$ac_exeext conftest.$ac_ext
20187 LIBS=$ac_check_lib_save_LIBS
20188 fi
20189 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanf" >&5
20190 echo "${ECHO_T}$ac_cv_lib_m_ctanf" >&6
20191 if test $ac_cv_lib_m_ctanf = yes; then
20192
20193 cat >>confdefs.h <<\_ACEOF
20194 #define HAVE_CTANF 1
20195 _ACEOF
20196
20197 fi
20198
20199 echo "$as_me:$LINENO: checking for ctan in -lm" >&5
20200 echo $ECHO_N "checking for ctan in -lm... $ECHO_C" >&6
20201 if test "${ac_cv_lib_m_ctan+set}" = set; then
20202   echo $ECHO_N "(cached) $ECHO_C" >&6
20203 else
20204   ac_check_lib_save_LIBS=$LIBS
20205 LIBS="-lm  $LIBS"
20206 if test x$gcc_no_link = xyes; then
20207   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20208 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20209    { (exit 1); exit 1; }; }
20210 fi
20211 cat >conftest.$ac_ext <<_ACEOF
20212 /* confdefs.h.  */
20213 _ACEOF
20214 cat confdefs.h >>conftest.$ac_ext
20215 cat >>conftest.$ac_ext <<_ACEOF
20216 /* end confdefs.h.  */
20217
20218 /* Override any gcc2 internal prototype to avoid an error.  */
20219 #ifdef __cplusplus
20220 extern "C"
20221 #endif
20222 /* We use char because int might match the return type of a gcc2
20223    builtin and then its argument prototype would still apply.  */
20224 char ctan ();
20225 int
20226 main ()
20227 {
20228 ctan ();
20229   ;
20230   return 0;
20231 }
20232 _ACEOF
20233 rm -f conftest.$ac_objext conftest$ac_exeext
20234 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20235   (eval $ac_link) 2>conftest.er1
20236   ac_status=$?
20237   grep -v '^ *+' conftest.er1 >conftest.err
20238   rm -f conftest.er1
20239   cat conftest.err >&5
20240   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20241   (exit $ac_status); } &&
20242          { ac_try='test -z "$ac_c_werror_flag"
20243                          || test ! -s conftest.err'
20244   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20245   (eval $ac_try) 2>&5
20246   ac_status=$?
20247   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20248   (exit $ac_status); }; } &&
20249          { ac_try='test -s conftest$ac_exeext'
20250   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20251   (eval $ac_try) 2>&5
20252   ac_status=$?
20253   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20254   (exit $ac_status); }; }; then
20255   ac_cv_lib_m_ctan=yes
20256 else
20257   echo "$as_me: failed program was:" >&5
20258 sed 's/^/| /' conftest.$ac_ext >&5
20259
20260 ac_cv_lib_m_ctan=no
20261 fi
20262 rm -f conftest.err conftest.$ac_objext \
20263       conftest$ac_exeext conftest.$ac_ext
20264 LIBS=$ac_check_lib_save_LIBS
20265 fi
20266 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctan" >&5
20267 echo "${ECHO_T}$ac_cv_lib_m_ctan" >&6
20268 if test $ac_cv_lib_m_ctan = yes; then
20269
20270 cat >>confdefs.h <<\_ACEOF
20271 #define HAVE_CTAN 1
20272 _ACEOF
20273
20274 fi
20275
20276 echo "$as_me:$LINENO: checking for ctanl in -lm" >&5
20277 echo $ECHO_N "checking for ctanl in -lm... $ECHO_C" >&6
20278 if test "${ac_cv_lib_m_ctanl+set}" = set; then
20279   echo $ECHO_N "(cached) $ECHO_C" >&6
20280 else
20281   ac_check_lib_save_LIBS=$LIBS
20282 LIBS="-lm  $LIBS"
20283 if test x$gcc_no_link = xyes; then
20284   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20285 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20286    { (exit 1); exit 1; }; }
20287 fi
20288 cat >conftest.$ac_ext <<_ACEOF
20289 /* confdefs.h.  */
20290 _ACEOF
20291 cat confdefs.h >>conftest.$ac_ext
20292 cat >>conftest.$ac_ext <<_ACEOF
20293 /* end confdefs.h.  */
20294
20295 /* Override any gcc2 internal prototype to avoid an error.  */
20296 #ifdef __cplusplus
20297 extern "C"
20298 #endif
20299 /* We use char because int might match the return type of a gcc2
20300    builtin and then its argument prototype would still apply.  */
20301 char ctanl ();
20302 int
20303 main ()
20304 {
20305 ctanl ();
20306   ;
20307   return 0;
20308 }
20309 _ACEOF
20310 rm -f conftest.$ac_objext conftest$ac_exeext
20311 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20312   (eval $ac_link) 2>conftest.er1
20313   ac_status=$?
20314   grep -v '^ *+' conftest.er1 >conftest.err
20315   rm -f conftest.er1
20316   cat conftest.err >&5
20317   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20318   (exit $ac_status); } &&
20319          { ac_try='test -z "$ac_c_werror_flag"
20320                          || test ! -s conftest.err'
20321   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20322   (eval $ac_try) 2>&5
20323   ac_status=$?
20324   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20325   (exit $ac_status); }; } &&
20326          { ac_try='test -s conftest$ac_exeext'
20327   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20328   (eval $ac_try) 2>&5
20329   ac_status=$?
20330   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20331   (exit $ac_status); }; }; then
20332   ac_cv_lib_m_ctanl=yes
20333 else
20334   echo "$as_me: failed program was:" >&5
20335 sed 's/^/| /' conftest.$ac_ext >&5
20336
20337 ac_cv_lib_m_ctanl=no
20338 fi
20339 rm -f conftest.err conftest.$ac_objext \
20340       conftest$ac_exeext conftest.$ac_ext
20341 LIBS=$ac_check_lib_save_LIBS
20342 fi
20343 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanl" >&5
20344 echo "${ECHO_T}$ac_cv_lib_m_ctanl" >&6
20345 if test $ac_cv_lib_m_ctanl = yes; then
20346
20347 cat >>confdefs.h <<\_ACEOF
20348 #define HAVE_CTANL 1
20349 _ACEOF
20350
20351 fi
20352
20353 echo "$as_me:$LINENO: checking for tanhf in -lm" >&5
20354 echo $ECHO_N "checking for tanhf in -lm... $ECHO_C" >&6
20355 if test "${ac_cv_lib_m_tanhf+set}" = set; then
20356   echo $ECHO_N "(cached) $ECHO_C" >&6
20357 else
20358   ac_check_lib_save_LIBS=$LIBS
20359 LIBS="-lm  $LIBS"
20360 if test x$gcc_no_link = xyes; then
20361   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20362 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20363    { (exit 1); exit 1; }; }
20364 fi
20365 cat >conftest.$ac_ext <<_ACEOF
20366 /* confdefs.h.  */
20367 _ACEOF
20368 cat confdefs.h >>conftest.$ac_ext
20369 cat >>conftest.$ac_ext <<_ACEOF
20370 /* end confdefs.h.  */
20371
20372 /* Override any gcc2 internal prototype to avoid an error.  */
20373 #ifdef __cplusplus
20374 extern "C"
20375 #endif
20376 /* We use char because int might match the return type of a gcc2
20377    builtin and then its argument prototype would still apply.  */
20378 char tanhf ();
20379 int
20380 main ()
20381 {
20382 tanhf ();
20383   ;
20384   return 0;
20385 }
20386 _ACEOF
20387 rm -f conftest.$ac_objext conftest$ac_exeext
20388 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20389   (eval $ac_link) 2>conftest.er1
20390   ac_status=$?
20391   grep -v '^ *+' conftest.er1 >conftest.err
20392   rm -f conftest.er1
20393   cat conftest.err >&5
20394   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20395   (exit $ac_status); } &&
20396          { ac_try='test -z "$ac_c_werror_flag"
20397                          || test ! -s conftest.err'
20398   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20399   (eval $ac_try) 2>&5
20400   ac_status=$?
20401   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20402   (exit $ac_status); }; } &&
20403          { ac_try='test -s conftest$ac_exeext'
20404   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20405   (eval $ac_try) 2>&5
20406   ac_status=$?
20407   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20408   (exit $ac_status); }; }; then
20409   ac_cv_lib_m_tanhf=yes
20410 else
20411   echo "$as_me: failed program was:" >&5
20412 sed 's/^/| /' conftest.$ac_ext >&5
20413
20414 ac_cv_lib_m_tanhf=no
20415 fi
20416 rm -f conftest.err conftest.$ac_objext \
20417       conftest$ac_exeext conftest.$ac_ext
20418 LIBS=$ac_check_lib_save_LIBS
20419 fi
20420 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanhf" >&5
20421 echo "${ECHO_T}$ac_cv_lib_m_tanhf" >&6
20422 if test $ac_cv_lib_m_tanhf = yes; then
20423
20424 cat >>confdefs.h <<\_ACEOF
20425 #define HAVE_TANHF 1
20426 _ACEOF
20427
20428 fi
20429
20430 echo "$as_me:$LINENO: checking for tanh in -lm" >&5
20431 echo $ECHO_N "checking for tanh in -lm... $ECHO_C" >&6
20432 if test "${ac_cv_lib_m_tanh+set}" = set; then
20433   echo $ECHO_N "(cached) $ECHO_C" >&6
20434 else
20435   ac_check_lib_save_LIBS=$LIBS
20436 LIBS="-lm  $LIBS"
20437 if test x$gcc_no_link = xyes; then
20438   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20439 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20440    { (exit 1); exit 1; }; }
20441 fi
20442 cat >conftest.$ac_ext <<_ACEOF
20443 /* confdefs.h.  */
20444 _ACEOF
20445 cat confdefs.h >>conftest.$ac_ext
20446 cat >>conftest.$ac_ext <<_ACEOF
20447 /* end confdefs.h.  */
20448
20449 /* Override any gcc2 internal prototype to avoid an error.  */
20450 #ifdef __cplusplus
20451 extern "C"
20452 #endif
20453 /* We use char because int might match the return type of a gcc2
20454    builtin and then its argument prototype would still apply.  */
20455 char tanh ();
20456 int
20457 main ()
20458 {
20459 tanh ();
20460   ;
20461   return 0;
20462 }
20463 _ACEOF
20464 rm -f conftest.$ac_objext conftest$ac_exeext
20465 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20466   (eval $ac_link) 2>conftest.er1
20467   ac_status=$?
20468   grep -v '^ *+' conftest.er1 >conftest.err
20469   rm -f conftest.er1
20470   cat conftest.err >&5
20471   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20472   (exit $ac_status); } &&
20473          { ac_try='test -z "$ac_c_werror_flag"
20474                          || test ! -s conftest.err'
20475   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20476   (eval $ac_try) 2>&5
20477   ac_status=$?
20478   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20479   (exit $ac_status); }; } &&
20480          { ac_try='test -s conftest$ac_exeext'
20481   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20482   (eval $ac_try) 2>&5
20483   ac_status=$?
20484   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20485   (exit $ac_status); }; }; then
20486   ac_cv_lib_m_tanh=yes
20487 else
20488   echo "$as_me: failed program was:" >&5
20489 sed 's/^/| /' conftest.$ac_ext >&5
20490
20491 ac_cv_lib_m_tanh=no
20492 fi
20493 rm -f conftest.err conftest.$ac_objext \
20494       conftest$ac_exeext conftest.$ac_ext
20495 LIBS=$ac_check_lib_save_LIBS
20496 fi
20497 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanh" >&5
20498 echo "${ECHO_T}$ac_cv_lib_m_tanh" >&6
20499 if test $ac_cv_lib_m_tanh = yes; then
20500
20501 cat >>confdefs.h <<\_ACEOF
20502 #define HAVE_TANH 1
20503 _ACEOF
20504
20505 fi
20506
20507 echo "$as_me:$LINENO: checking for tanhl in -lm" >&5
20508 echo $ECHO_N "checking for tanhl in -lm... $ECHO_C" >&6
20509 if test "${ac_cv_lib_m_tanhl+set}" = set; then
20510   echo $ECHO_N "(cached) $ECHO_C" >&6
20511 else
20512   ac_check_lib_save_LIBS=$LIBS
20513 LIBS="-lm  $LIBS"
20514 if test x$gcc_no_link = xyes; then
20515   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20516 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20517    { (exit 1); exit 1; }; }
20518 fi
20519 cat >conftest.$ac_ext <<_ACEOF
20520 /* confdefs.h.  */
20521 _ACEOF
20522 cat confdefs.h >>conftest.$ac_ext
20523 cat >>conftest.$ac_ext <<_ACEOF
20524 /* end confdefs.h.  */
20525
20526 /* Override any gcc2 internal prototype to avoid an error.  */
20527 #ifdef __cplusplus
20528 extern "C"
20529 #endif
20530 /* We use char because int might match the return type of a gcc2
20531    builtin and then its argument prototype would still apply.  */
20532 char tanhl ();
20533 int
20534 main ()
20535 {
20536 tanhl ();
20537   ;
20538   return 0;
20539 }
20540 _ACEOF
20541 rm -f conftest.$ac_objext conftest$ac_exeext
20542 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20543   (eval $ac_link) 2>conftest.er1
20544   ac_status=$?
20545   grep -v '^ *+' conftest.er1 >conftest.err
20546   rm -f conftest.er1
20547   cat conftest.err >&5
20548   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20549   (exit $ac_status); } &&
20550          { ac_try='test -z "$ac_c_werror_flag"
20551                          || test ! -s conftest.err'
20552   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20553   (eval $ac_try) 2>&5
20554   ac_status=$?
20555   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20556   (exit $ac_status); }; } &&
20557          { ac_try='test -s conftest$ac_exeext'
20558   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20559   (eval $ac_try) 2>&5
20560   ac_status=$?
20561   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20562   (exit $ac_status); }; }; then
20563   ac_cv_lib_m_tanhl=yes
20564 else
20565   echo "$as_me: failed program was:" >&5
20566 sed 's/^/| /' conftest.$ac_ext >&5
20567
20568 ac_cv_lib_m_tanhl=no
20569 fi
20570 rm -f conftest.err conftest.$ac_objext \
20571       conftest$ac_exeext conftest.$ac_ext
20572 LIBS=$ac_check_lib_save_LIBS
20573 fi
20574 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanhl" >&5
20575 echo "${ECHO_T}$ac_cv_lib_m_tanhl" >&6
20576 if test $ac_cv_lib_m_tanhl = yes; then
20577
20578 cat >>confdefs.h <<\_ACEOF
20579 #define HAVE_TANHL 1
20580 _ACEOF
20581
20582 fi
20583
20584 echo "$as_me:$LINENO: checking for ctanhf in -lm" >&5
20585 echo $ECHO_N "checking for ctanhf in -lm... $ECHO_C" >&6
20586 if test "${ac_cv_lib_m_ctanhf+set}" = set; then
20587   echo $ECHO_N "(cached) $ECHO_C" >&6
20588 else
20589   ac_check_lib_save_LIBS=$LIBS
20590 LIBS="-lm  $LIBS"
20591 if test x$gcc_no_link = xyes; then
20592   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20593 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20594    { (exit 1); exit 1; }; }
20595 fi
20596 cat >conftest.$ac_ext <<_ACEOF
20597 /* confdefs.h.  */
20598 _ACEOF
20599 cat confdefs.h >>conftest.$ac_ext
20600 cat >>conftest.$ac_ext <<_ACEOF
20601 /* end confdefs.h.  */
20602
20603 /* Override any gcc2 internal prototype to avoid an error.  */
20604 #ifdef __cplusplus
20605 extern "C"
20606 #endif
20607 /* We use char because int might match the return type of a gcc2
20608    builtin and then its argument prototype would still apply.  */
20609 char ctanhf ();
20610 int
20611 main ()
20612 {
20613 ctanhf ();
20614   ;
20615   return 0;
20616 }
20617 _ACEOF
20618 rm -f conftest.$ac_objext conftest$ac_exeext
20619 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20620   (eval $ac_link) 2>conftest.er1
20621   ac_status=$?
20622   grep -v '^ *+' conftest.er1 >conftest.err
20623   rm -f conftest.er1
20624   cat conftest.err >&5
20625   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20626   (exit $ac_status); } &&
20627          { ac_try='test -z "$ac_c_werror_flag"
20628                          || test ! -s conftest.err'
20629   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20630   (eval $ac_try) 2>&5
20631   ac_status=$?
20632   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20633   (exit $ac_status); }; } &&
20634          { ac_try='test -s conftest$ac_exeext'
20635   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20636   (eval $ac_try) 2>&5
20637   ac_status=$?
20638   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20639   (exit $ac_status); }; }; then
20640   ac_cv_lib_m_ctanhf=yes
20641 else
20642   echo "$as_me: failed program was:" >&5
20643 sed 's/^/| /' conftest.$ac_ext >&5
20644
20645 ac_cv_lib_m_ctanhf=no
20646 fi
20647 rm -f conftest.err conftest.$ac_objext \
20648       conftest$ac_exeext conftest.$ac_ext
20649 LIBS=$ac_check_lib_save_LIBS
20650 fi
20651 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanhf" >&5
20652 echo "${ECHO_T}$ac_cv_lib_m_ctanhf" >&6
20653 if test $ac_cv_lib_m_ctanhf = yes; then
20654
20655 cat >>confdefs.h <<\_ACEOF
20656 #define HAVE_CTANHF 1
20657 _ACEOF
20658
20659 fi
20660
20661 echo "$as_me:$LINENO: checking for ctanh in -lm" >&5
20662 echo $ECHO_N "checking for ctanh in -lm... $ECHO_C" >&6
20663 if test "${ac_cv_lib_m_ctanh+set}" = set; then
20664   echo $ECHO_N "(cached) $ECHO_C" >&6
20665 else
20666   ac_check_lib_save_LIBS=$LIBS
20667 LIBS="-lm  $LIBS"
20668 if test x$gcc_no_link = xyes; then
20669   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20670 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20671    { (exit 1); exit 1; }; }
20672 fi
20673 cat >conftest.$ac_ext <<_ACEOF
20674 /* confdefs.h.  */
20675 _ACEOF
20676 cat confdefs.h >>conftest.$ac_ext
20677 cat >>conftest.$ac_ext <<_ACEOF
20678 /* end confdefs.h.  */
20679
20680 /* Override any gcc2 internal prototype to avoid an error.  */
20681 #ifdef __cplusplus
20682 extern "C"
20683 #endif
20684 /* We use char because int might match the return type of a gcc2
20685    builtin and then its argument prototype would still apply.  */
20686 char ctanh ();
20687 int
20688 main ()
20689 {
20690 ctanh ();
20691   ;
20692   return 0;
20693 }
20694 _ACEOF
20695 rm -f conftest.$ac_objext conftest$ac_exeext
20696 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20697   (eval $ac_link) 2>conftest.er1
20698   ac_status=$?
20699   grep -v '^ *+' conftest.er1 >conftest.err
20700   rm -f conftest.er1
20701   cat conftest.err >&5
20702   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20703   (exit $ac_status); } &&
20704          { ac_try='test -z "$ac_c_werror_flag"
20705                          || test ! -s conftest.err'
20706   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20707   (eval $ac_try) 2>&5
20708   ac_status=$?
20709   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20710   (exit $ac_status); }; } &&
20711          { ac_try='test -s conftest$ac_exeext'
20712   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20713   (eval $ac_try) 2>&5
20714   ac_status=$?
20715   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20716   (exit $ac_status); }; }; then
20717   ac_cv_lib_m_ctanh=yes
20718 else
20719   echo "$as_me: failed program was:" >&5
20720 sed 's/^/| /' conftest.$ac_ext >&5
20721
20722 ac_cv_lib_m_ctanh=no
20723 fi
20724 rm -f conftest.err conftest.$ac_objext \
20725       conftest$ac_exeext conftest.$ac_ext
20726 LIBS=$ac_check_lib_save_LIBS
20727 fi
20728 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanh" >&5
20729 echo "${ECHO_T}$ac_cv_lib_m_ctanh" >&6
20730 if test $ac_cv_lib_m_ctanh = yes; then
20731
20732 cat >>confdefs.h <<\_ACEOF
20733 #define HAVE_CTANH 1
20734 _ACEOF
20735
20736 fi
20737
20738 echo "$as_me:$LINENO: checking for ctanhl in -lm" >&5
20739 echo $ECHO_N "checking for ctanhl in -lm... $ECHO_C" >&6
20740 if test "${ac_cv_lib_m_ctanhl+set}" = set; then
20741   echo $ECHO_N "(cached) $ECHO_C" >&6
20742 else
20743   ac_check_lib_save_LIBS=$LIBS
20744 LIBS="-lm  $LIBS"
20745 if test x$gcc_no_link = xyes; then
20746   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20747 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20748    { (exit 1); exit 1; }; }
20749 fi
20750 cat >conftest.$ac_ext <<_ACEOF
20751 /* confdefs.h.  */
20752 _ACEOF
20753 cat confdefs.h >>conftest.$ac_ext
20754 cat >>conftest.$ac_ext <<_ACEOF
20755 /* end confdefs.h.  */
20756
20757 /* Override any gcc2 internal prototype to avoid an error.  */
20758 #ifdef __cplusplus
20759 extern "C"
20760 #endif
20761 /* We use char because int might match the return type of a gcc2
20762    builtin and then its argument prototype would still apply.  */
20763 char ctanhl ();
20764 int
20765 main ()
20766 {
20767 ctanhl ();
20768   ;
20769   return 0;
20770 }
20771 _ACEOF
20772 rm -f conftest.$ac_objext conftest$ac_exeext
20773 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20774   (eval $ac_link) 2>conftest.er1
20775   ac_status=$?
20776   grep -v '^ *+' conftest.er1 >conftest.err
20777   rm -f conftest.er1
20778   cat conftest.err >&5
20779   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20780   (exit $ac_status); } &&
20781          { ac_try='test -z "$ac_c_werror_flag"
20782                          || test ! -s conftest.err'
20783   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20784   (eval $ac_try) 2>&5
20785   ac_status=$?
20786   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20787   (exit $ac_status); }; } &&
20788          { ac_try='test -s conftest$ac_exeext'
20789   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20790   (eval $ac_try) 2>&5
20791   ac_status=$?
20792   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20793   (exit $ac_status); }; }; then
20794   ac_cv_lib_m_ctanhl=yes
20795 else
20796   echo "$as_me: failed program was:" >&5
20797 sed 's/^/| /' conftest.$ac_ext >&5
20798
20799 ac_cv_lib_m_ctanhl=no
20800 fi
20801 rm -f conftest.err conftest.$ac_objext \
20802       conftest$ac_exeext conftest.$ac_ext
20803 LIBS=$ac_check_lib_save_LIBS
20804 fi
20805 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanhl" >&5
20806 echo "${ECHO_T}$ac_cv_lib_m_ctanhl" >&6
20807 if test $ac_cv_lib_m_ctanhl = yes; then
20808
20809 cat >>confdefs.h <<\_ACEOF
20810 #define HAVE_CTANHL 1
20811 _ACEOF
20812
20813 fi
20814
20815 echo "$as_me:$LINENO: checking for truncf in -lm" >&5
20816 echo $ECHO_N "checking for truncf in -lm... $ECHO_C" >&6
20817 if test "${ac_cv_lib_m_truncf+set}" = set; then
20818   echo $ECHO_N "(cached) $ECHO_C" >&6
20819 else
20820   ac_check_lib_save_LIBS=$LIBS
20821 LIBS="-lm  $LIBS"
20822 if test x$gcc_no_link = xyes; then
20823   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20824 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20825    { (exit 1); exit 1; }; }
20826 fi
20827 cat >conftest.$ac_ext <<_ACEOF
20828 /* confdefs.h.  */
20829 _ACEOF
20830 cat confdefs.h >>conftest.$ac_ext
20831 cat >>conftest.$ac_ext <<_ACEOF
20832 /* end confdefs.h.  */
20833
20834 /* Override any gcc2 internal prototype to avoid an error.  */
20835 #ifdef __cplusplus
20836 extern "C"
20837 #endif
20838 /* We use char because int might match the return type of a gcc2
20839    builtin and then its argument prototype would still apply.  */
20840 char truncf ();
20841 int
20842 main ()
20843 {
20844 truncf ();
20845   ;
20846   return 0;
20847 }
20848 _ACEOF
20849 rm -f conftest.$ac_objext conftest$ac_exeext
20850 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20851   (eval $ac_link) 2>conftest.er1
20852   ac_status=$?
20853   grep -v '^ *+' conftest.er1 >conftest.err
20854   rm -f conftest.er1
20855   cat conftest.err >&5
20856   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20857   (exit $ac_status); } &&
20858          { ac_try='test -z "$ac_c_werror_flag"
20859                          || test ! -s conftest.err'
20860   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20861   (eval $ac_try) 2>&5
20862   ac_status=$?
20863   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20864   (exit $ac_status); }; } &&
20865          { ac_try='test -s conftest$ac_exeext'
20866   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20867   (eval $ac_try) 2>&5
20868   ac_status=$?
20869   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20870   (exit $ac_status); }; }; then
20871   ac_cv_lib_m_truncf=yes
20872 else
20873   echo "$as_me: failed program was:" >&5
20874 sed 's/^/| /' conftest.$ac_ext >&5
20875
20876 ac_cv_lib_m_truncf=no
20877 fi
20878 rm -f conftest.err conftest.$ac_objext \
20879       conftest$ac_exeext conftest.$ac_ext
20880 LIBS=$ac_check_lib_save_LIBS
20881 fi
20882 echo "$as_me:$LINENO: result: $ac_cv_lib_m_truncf" >&5
20883 echo "${ECHO_T}$ac_cv_lib_m_truncf" >&6
20884 if test $ac_cv_lib_m_truncf = yes; then
20885
20886 cat >>confdefs.h <<\_ACEOF
20887 #define HAVE_TRUNCF 1
20888 _ACEOF
20889
20890 fi
20891
20892 echo "$as_me:$LINENO: checking for trunc in -lm" >&5
20893 echo $ECHO_N "checking for trunc in -lm... $ECHO_C" >&6
20894 if test "${ac_cv_lib_m_trunc+set}" = set; then
20895   echo $ECHO_N "(cached) $ECHO_C" >&6
20896 else
20897   ac_check_lib_save_LIBS=$LIBS
20898 LIBS="-lm  $LIBS"
20899 if test x$gcc_no_link = xyes; then
20900   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20901 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20902    { (exit 1); exit 1; }; }
20903 fi
20904 cat >conftest.$ac_ext <<_ACEOF
20905 /* confdefs.h.  */
20906 _ACEOF
20907 cat confdefs.h >>conftest.$ac_ext
20908 cat >>conftest.$ac_ext <<_ACEOF
20909 /* end confdefs.h.  */
20910
20911 /* Override any gcc2 internal prototype to avoid an error.  */
20912 #ifdef __cplusplus
20913 extern "C"
20914 #endif
20915 /* We use char because int might match the return type of a gcc2
20916    builtin and then its argument prototype would still apply.  */
20917 char trunc ();
20918 int
20919 main ()
20920 {
20921 trunc ();
20922   ;
20923   return 0;
20924 }
20925 _ACEOF
20926 rm -f conftest.$ac_objext conftest$ac_exeext
20927 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20928   (eval $ac_link) 2>conftest.er1
20929   ac_status=$?
20930   grep -v '^ *+' conftest.er1 >conftest.err
20931   rm -f conftest.er1
20932   cat conftest.err >&5
20933   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20934   (exit $ac_status); } &&
20935          { ac_try='test -z "$ac_c_werror_flag"
20936                          || test ! -s conftest.err'
20937   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20938   (eval $ac_try) 2>&5
20939   ac_status=$?
20940   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20941   (exit $ac_status); }; } &&
20942          { ac_try='test -s conftest$ac_exeext'
20943   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20944   (eval $ac_try) 2>&5
20945   ac_status=$?
20946   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20947   (exit $ac_status); }; }; then
20948   ac_cv_lib_m_trunc=yes
20949 else
20950   echo "$as_me: failed program was:" >&5
20951 sed 's/^/| /' conftest.$ac_ext >&5
20952
20953 ac_cv_lib_m_trunc=no
20954 fi
20955 rm -f conftest.err conftest.$ac_objext \
20956       conftest$ac_exeext conftest.$ac_ext
20957 LIBS=$ac_check_lib_save_LIBS
20958 fi
20959 echo "$as_me:$LINENO: result: $ac_cv_lib_m_trunc" >&5
20960 echo "${ECHO_T}$ac_cv_lib_m_trunc" >&6
20961 if test $ac_cv_lib_m_trunc = yes; then
20962
20963 cat >>confdefs.h <<\_ACEOF
20964 #define HAVE_TRUNC 1
20965 _ACEOF
20966
20967 fi
20968
20969 echo "$as_me:$LINENO: checking for truncl in -lm" >&5
20970 echo $ECHO_N "checking for truncl in -lm... $ECHO_C" >&6
20971 if test "${ac_cv_lib_m_truncl+set}" = set; then
20972   echo $ECHO_N "(cached) $ECHO_C" >&6
20973 else
20974   ac_check_lib_save_LIBS=$LIBS
20975 LIBS="-lm  $LIBS"
20976 if test x$gcc_no_link = xyes; then
20977   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20978 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20979    { (exit 1); exit 1; }; }
20980 fi
20981 cat >conftest.$ac_ext <<_ACEOF
20982 /* confdefs.h.  */
20983 _ACEOF
20984 cat confdefs.h >>conftest.$ac_ext
20985 cat >>conftest.$ac_ext <<_ACEOF
20986 /* end confdefs.h.  */
20987
20988 /* Override any gcc2 internal prototype to avoid an error.  */
20989 #ifdef __cplusplus
20990 extern "C"
20991 #endif
20992 /* We use char because int might match the return type of a gcc2
20993    builtin and then its argument prototype would still apply.  */
20994 char truncl ();
20995 int
20996 main ()
20997 {
20998 truncl ();
20999   ;
21000   return 0;
21001 }
21002 _ACEOF
21003 rm -f conftest.$ac_objext conftest$ac_exeext
21004 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21005   (eval $ac_link) 2>conftest.er1
21006   ac_status=$?
21007   grep -v '^ *+' conftest.er1 >conftest.err
21008   rm -f conftest.er1
21009   cat conftest.err >&5
21010   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21011   (exit $ac_status); } &&
21012          { ac_try='test -z "$ac_c_werror_flag"
21013                          || test ! -s conftest.err'
21014   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21015   (eval $ac_try) 2>&5
21016   ac_status=$?
21017   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21018   (exit $ac_status); }; } &&
21019          { ac_try='test -s conftest$ac_exeext'
21020   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21021   (eval $ac_try) 2>&5
21022   ac_status=$?
21023   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21024   (exit $ac_status); }; }; then
21025   ac_cv_lib_m_truncl=yes
21026 else
21027   echo "$as_me: failed program was:" >&5
21028 sed 's/^/| /' conftest.$ac_ext >&5
21029
21030 ac_cv_lib_m_truncl=no
21031 fi
21032 rm -f conftest.err conftest.$ac_objext \
21033       conftest$ac_exeext conftest.$ac_ext
21034 LIBS=$ac_check_lib_save_LIBS
21035 fi
21036 echo "$as_me:$LINENO: result: $ac_cv_lib_m_truncl" >&5
21037 echo "${ECHO_T}$ac_cv_lib_m_truncl" >&6
21038 if test $ac_cv_lib_m_truncl = yes; then
21039
21040 cat >>confdefs.h <<\_ACEOF
21041 #define HAVE_TRUNCL 1
21042 _ACEOF
21043
21044 fi
21045
21046 echo "$as_me:$LINENO: checking for erff in -lm" >&5
21047 echo $ECHO_N "checking for erff in -lm... $ECHO_C" >&6
21048 if test "${ac_cv_lib_m_erff+set}" = set; then
21049   echo $ECHO_N "(cached) $ECHO_C" >&6
21050 else
21051   ac_check_lib_save_LIBS=$LIBS
21052 LIBS="-lm  $LIBS"
21053 if test x$gcc_no_link = xyes; then
21054   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21055 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21056    { (exit 1); exit 1; }; }
21057 fi
21058 cat >conftest.$ac_ext <<_ACEOF
21059 /* confdefs.h.  */
21060 _ACEOF
21061 cat confdefs.h >>conftest.$ac_ext
21062 cat >>conftest.$ac_ext <<_ACEOF
21063 /* end confdefs.h.  */
21064
21065 /* Override any gcc2 internal prototype to avoid an error.  */
21066 #ifdef __cplusplus
21067 extern "C"
21068 #endif
21069 /* We use char because int might match the return type of a gcc2
21070    builtin and then its argument prototype would still apply.  */
21071 char erff ();
21072 int
21073 main ()
21074 {
21075 erff ();
21076   ;
21077   return 0;
21078 }
21079 _ACEOF
21080 rm -f conftest.$ac_objext conftest$ac_exeext
21081 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21082   (eval $ac_link) 2>conftest.er1
21083   ac_status=$?
21084   grep -v '^ *+' conftest.er1 >conftest.err
21085   rm -f conftest.er1
21086   cat conftest.err >&5
21087   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21088   (exit $ac_status); } &&
21089          { ac_try='test -z "$ac_c_werror_flag"
21090                          || test ! -s conftest.err'
21091   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21092   (eval $ac_try) 2>&5
21093   ac_status=$?
21094   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21095   (exit $ac_status); }; } &&
21096          { ac_try='test -s conftest$ac_exeext'
21097   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21098   (eval $ac_try) 2>&5
21099   ac_status=$?
21100   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21101   (exit $ac_status); }; }; then
21102   ac_cv_lib_m_erff=yes
21103 else
21104   echo "$as_me: failed program was:" >&5
21105 sed 's/^/| /' conftest.$ac_ext >&5
21106
21107 ac_cv_lib_m_erff=no
21108 fi
21109 rm -f conftest.err conftest.$ac_objext \
21110       conftest$ac_exeext conftest.$ac_ext
21111 LIBS=$ac_check_lib_save_LIBS
21112 fi
21113 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erff" >&5
21114 echo "${ECHO_T}$ac_cv_lib_m_erff" >&6
21115 if test $ac_cv_lib_m_erff = yes; then
21116
21117 cat >>confdefs.h <<\_ACEOF
21118 #define HAVE_ERFF 1
21119 _ACEOF
21120
21121 fi
21122
21123 echo "$as_me:$LINENO: checking for erf in -lm" >&5
21124 echo $ECHO_N "checking for erf in -lm... $ECHO_C" >&6
21125 if test "${ac_cv_lib_m_erf+set}" = set; then
21126   echo $ECHO_N "(cached) $ECHO_C" >&6
21127 else
21128   ac_check_lib_save_LIBS=$LIBS
21129 LIBS="-lm  $LIBS"
21130 if test x$gcc_no_link = xyes; then
21131   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21132 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21133    { (exit 1); exit 1; }; }
21134 fi
21135 cat >conftest.$ac_ext <<_ACEOF
21136 /* confdefs.h.  */
21137 _ACEOF
21138 cat confdefs.h >>conftest.$ac_ext
21139 cat >>conftest.$ac_ext <<_ACEOF
21140 /* end confdefs.h.  */
21141
21142 /* Override any gcc2 internal prototype to avoid an error.  */
21143 #ifdef __cplusplus
21144 extern "C"
21145 #endif
21146 /* We use char because int might match the return type of a gcc2
21147    builtin and then its argument prototype would still apply.  */
21148 char erf ();
21149 int
21150 main ()
21151 {
21152 erf ();
21153   ;
21154   return 0;
21155 }
21156 _ACEOF
21157 rm -f conftest.$ac_objext conftest$ac_exeext
21158 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21159   (eval $ac_link) 2>conftest.er1
21160   ac_status=$?
21161   grep -v '^ *+' conftest.er1 >conftest.err
21162   rm -f conftest.er1
21163   cat conftest.err >&5
21164   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21165   (exit $ac_status); } &&
21166          { ac_try='test -z "$ac_c_werror_flag"
21167                          || test ! -s conftest.err'
21168   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21169   (eval $ac_try) 2>&5
21170   ac_status=$?
21171   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21172   (exit $ac_status); }; } &&
21173          { ac_try='test -s conftest$ac_exeext'
21174   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21175   (eval $ac_try) 2>&5
21176   ac_status=$?
21177   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21178   (exit $ac_status); }; }; then
21179   ac_cv_lib_m_erf=yes
21180 else
21181   echo "$as_me: failed program was:" >&5
21182 sed 's/^/| /' conftest.$ac_ext >&5
21183
21184 ac_cv_lib_m_erf=no
21185 fi
21186 rm -f conftest.err conftest.$ac_objext \
21187       conftest$ac_exeext conftest.$ac_ext
21188 LIBS=$ac_check_lib_save_LIBS
21189 fi
21190 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erf" >&5
21191 echo "${ECHO_T}$ac_cv_lib_m_erf" >&6
21192 if test $ac_cv_lib_m_erf = yes; then
21193
21194 cat >>confdefs.h <<\_ACEOF
21195 #define HAVE_ERF 1
21196 _ACEOF
21197
21198 fi
21199
21200 echo "$as_me:$LINENO: checking for erfl in -lm" >&5
21201 echo $ECHO_N "checking for erfl in -lm... $ECHO_C" >&6
21202 if test "${ac_cv_lib_m_erfl+set}" = set; then
21203   echo $ECHO_N "(cached) $ECHO_C" >&6
21204 else
21205   ac_check_lib_save_LIBS=$LIBS
21206 LIBS="-lm  $LIBS"
21207 if test x$gcc_no_link = xyes; then
21208   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21209 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21210    { (exit 1); exit 1; }; }
21211 fi
21212 cat >conftest.$ac_ext <<_ACEOF
21213 /* confdefs.h.  */
21214 _ACEOF
21215 cat confdefs.h >>conftest.$ac_ext
21216 cat >>conftest.$ac_ext <<_ACEOF
21217 /* end confdefs.h.  */
21218
21219 /* Override any gcc2 internal prototype to avoid an error.  */
21220 #ifdef __cplusplus
21221 extern "C"
21222 #endif
21223 /* We use char because int might match the return type of a gcc2
21224    builtin and then its argument prototype would still apply.  */
21225 char erfl ();
21226 int
21227 main ()
21228 {
21229 erfl ();
21230   ;
21231   return 0;
21232 }
21233 _ACEOF
21234 rm -f conftest.$ac_objext conftest$ac_exeext
21235 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21236   (eval $ac_link) 2>conftest.er1
21237   ac_status=$?
21238   grep -v '^ *+' conftest.er1 >conftest.err
21239   rm -f conftest.er1
21240   cat conftest.err >&5
21241   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21242   (exit $ac_status); } &&
21243          { ac_try='test -z "$ac_c_werror_flag"
21244                          || test ! -s conftest.err'
21245   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21246   (eval $ac_try) 2>&5
21247   ac_status=$?
21248   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21249   (exit $ac_status); }; } &&
21250          { ac_try='test -s conftest$ac_exeext'
21251   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21252   (eval $ac_try) 2>&5
21253   ac_status=$?
21254   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21255   (exit $ac_status); }; }; then
21256   ac_cv_lib_m_erfl=yes
21257 else
21258   echo "$as_me: failed program was:" >&5
21259 sed 's/^/| /' conftest.$ac_ext >&5
21260
21261 ac_cv_lib_m_erfl=no
21262 fi
21263 rm -f conftest.err conftest.$ac_objext \
21264       conftest$ac_exeext conftest.$ac_ext
21265 LIBS=$ac_check_lib_save_LIBS
21266 fi
21267 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfl" >&5
21268 echo "${ECHO_T}$ac_cv_lib_m_erfl" >&6
21269 if test $ac_cv_lib_m_erfl = yes; then
21270
21271 cat >>confdefs.h <<\_ACEOF
21272 #define HAVE_ERFL 1
21273 _ACEOF
21274
21275 fi
21276
21277 echo "$as_me:$LINENO: checking for erfcf in -lm" >&5
21278 echo $ECHO_N "checking for erfcf in -lm... $ECHO_C" >&6
21279 if test "${ac_cv_lib_m_erfcf+set}" = set; then
21280   echo $ECHO_N "(cached) $ECHO_C" >&6
21281 else
21282   ac_check_lib_save_LIBS=$LIBS
21283 LIBS="-lm  $LIBS"
21284 if test x$gcc_no_link = xyes; then
21285   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21286 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21287    { (exit 1); exit 1; }; }
21288 fi
21289 cat >conftest.$ac_ext <<_ACEOF
21290 /* confdefs.h.  */
21291 _ACEOF
21292 cat confdefs.h >>conftest.$ac_ext
21293 cat >>conftest.$ac_ext <<_ACEOF
21294 /* end confdefs.h.  */
21295
21296 /* Override any gcc2 internal prototype to avoid an error.  */
21297 #ifdef __cplusplus
21298 extern "C"
21299 #endif
21300 /* We use char because int might match the return type of a gcc2
21301    builtin and then its argument prototype would still apply.  */
21302 char erfcf ();
21303 int
21304 main ()
21305 {
21306 erfcf ();
21307   ;
21308   return 0;
21309 }
21310 _ACEOF
21311 rm -f conftest.$ac_objext conftest$ac_exeext
21312 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21313   (eval $ac_link) 2>conftest.er1
21314   ac_status=$?
21315   grep -v '^ *+' conftest.er1 >conftest.err
21316   rm -f conftest.er1
21317   cat conftest.err >&5
21318   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21319   (exit $ac_status); } &&
21320          { ac_try='test -z "$ac_c_werror_flag"
21321                          || test ! -s conftest.err'
21322   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21323   (eval $ac_try) 2>&5
21324   ac_status=$?
21325   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21326   (exit $ac_status); }; } &&
21327          { ac_try='test -s conftest$ac_exeext'
21328   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21329   (eval $ac_try) 2>&5
21330   ac_status=$?
21331   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21332   (exit $ac_status); }; }; then
21333   ac_cv_lib_m_erfcf=yes
21334 else
21335   echo "$as_me: failed program was:" >&5
21336 sed 's/^/| /' conftest.$ac_ext >&5
21337
21338 ac_cv_lib_m_erfcf=no
21339 fi
21340 rm -f conftest.err conftest.$ac_objext \
21341       conftest$ac_exeext conftest.$ac_ext
21342 LIBS=$ac_check_lib_save_LIBS
21343 fi
21344 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfcf" >&5
21345 echo "${ECHO_T}$ac_cv_lib_m_erfcf" >&6
21346 if test $ac_cv_lib_m_erfcf = yes; then
21347
21348 cat >>confdefs.h <<\_ACEOF
21349 #define HAVE_ERFCF 1
21350 _ACEOF
21351
21352 fi
21353
21354 echo "$as_me:$LINENO: checking for erfc in -lm" >&5
21355 echo $ECHO_N "checking for erfc in -lm... $ECHO_C" >&6
21356 if test "${ac_cv_lib_m_erfc+set}" = set; then
21357   echo $ECHO_N "(cached) $ECHO_C" >&6
21358 else
21359   ac_check_lib_save_LIBS=$LIBS
21360 LIBS="-lm  $LIBS"
21361 if test x$gcc_no_link = xyes; then
21362   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21363 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21364    { (exit 1); exit 1; }; }
21365 fi
21366 cat >conftest.$ac_ext <<_ACEOF
21367 /* confdefs.h.  */
21368 _ACEOF
21369 cat confdefs.h >>conftest.$ac_ext
21370 cat >>conftest.$ac_ext <<_ACEOF
21371 /* end confdefs.h.  */
21372
21373 /* Override any gcc2 internal prototype to avoid an error.  */
21374 #ifdef __cplusplus
21375 extern "C"
21376 #endif
21377 /* We use char because int might match the return type of a gcc2
21378    builtin and then its argument prototype would still apply.  */
21379 char erfc ();
21380 int
21381 main ()
21382 {
21383 erfc ();
21384   ;
21385   return 0;
21386 }
21387 _ACEOF
21388 rm -f conftest.$ac_objext conftest$ac_exeext
21389 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21390   (eval $ac_link) 2>conftest.er1
21391   ac_status=$?
21392   grep -v '^ *+' conftest.er1 >conftest.err
21393   rm -f conftest.er1
21394   cat conftest.err >&5
21395   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21396   (exit $ac_status); } &&
21397          { ac_try='test -z "$ac_c_werror_flag"
21398                          || test ! -s conftest.err'
21399   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21400   (eval $ac_try) 2>&5
21401   ac_status=$?
21402   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21403   (exit $ac_status); }; } &&
21404          { ac_try='test -s conftest$ac_exeext'
21405   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21406   (eval $ac_try) 2>&5
21407   ac_status=$?
21408   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21409   (exit $ac_status); }; }; then
21410   ac_cv_lib_m_erfc=yes
21411 else
21412   echo "$as_me: failed program was:" >&5
21413 sed 's/^/| /' conftest.$ac_ext >&5
21414
21415 ac_cv_lib_m_erfc=no
21416 fi
21417 rm -f conftest.err conftest.$ac_objext \
21418       conftest$ac_exeext conftest.$ac_ext
21419 LIBS=$ac_check_lib_save_LIBS
21420 fi
21421 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfc" >&5
21422 echo "${ECHO_T}$ac_cv_lib_m_erfc" >&6
21423 if test $ac_cv_lib_m_erfc = yes; then
21424
21425 cat >>confdefs.h <<\_ACEOF
21426 #define HAVE_ERFC 1
21427 _ACEOF
21428
21429 fi
21430
21431 echo "$as_me:$LINENO: checking for erfcl in -lm" >&5
21432 echo $ECHO_N "checking for erfcl in -lm... $ECHO_C" >&6
21433 if test "${ac_cv_lib_m_erfcl+set}" = set; then
21434   echo $ECHO_N "(cached) $ECHO_C" >&6
21435 else
21436   ac_check_lib_save_LIBS=$LIBS
21437 LIBS="-lm  $LIBS"
21438 if test x$gcc_no_link = xyes; then
21439   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21440 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21441    { (exit 1); exit 1; }; }
21442 fi
21443 cat >conftest.$ac_ext <<_ACEOF
21444 /* confdefs.h.  */
21445 _ACEOF
21446 cat confdefs.h >>conftest.$ac_ext
21447 cat >>conftest.$ac_ext <<_ACEOF
21448 /* end confdefs.h.  */
21449
21450 /* Override any gcc2 internal prototype to avoid an error.  */
21451 #ifdef __cplusplus
21452 extern "C"
21453 #endif
21454 /* We use char because int might match the return type of a gcc2
21455    builtin and then its argument prototype would still apply.  */
21456 char erfcl ();
21457 int
21458 main ()
21459 {
21460 erfcl ();
21461   ;
21462   return 0;
21463 }
21464 _ACEOF
21465 rm -f conftest.$ac_objext conftest$ac_exeext
21466 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21467   (eval $ac_link) 2>conftest.er1
21468   ac_status=$?
21469   grep -v '^ *+' conftest.er1 >conftest.err
21470   rm -f conftest.er1
21471   cat conftest.err >&5
21472   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21473   (exit $ac_status); } &&
21474          { ac_try='test -z "$ac_c_werror_flag"
21475                          || test ! -s conftest.err'
21476   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21477   (eval $ac_try) 2>&5
21478   ac_status=$?
21479   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21480   (exit $ac_status); }; } &&
21481          { ac_try='test -s conftest$ac_exeext'
21482   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21483   (eval $ac_try) 2>&5
21484   ac_status=$?
21485   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21486   (exit $ac_status); }; }; then
21487   ac_cv_lib_m_erfcl=yes
21488 else
21489   echo "$as_me: failed program was:" >&5
21490 sed 's/^/| /' conftest.$ac_ext >&5
21491
21492 ac_cv_lib_m_erfcl=no
21493 fi
21494 rm -f conftest.err conftest.$ac_objext \
21495       conftest$ac_exeext conftest.$ac_ext
21496 LIBS=$ac_check_lib_save_LIBS
21497 fi
21498 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfcl" >&5
21499 echo "${ECHO_T}$ac_cv_lib_m_erfcl" >&6
21500 if test $ac_cv_lib_m_erfcl = yes; then
21501
21502 cat >>confdefs.h <<\_ACEOF
21503 #define HAVE_ERFCL 1
21504 _ACEOF
21505
21506 fi
21507
21508 echo "$as_me:$LINENO: checking for j0f in -lm" >&5
21509 echo $ECHO_N "checking for j0f in -lm... $ECHO_C" >&6
21510 if test "${ac_cv_lib_m_j0f+set}" = set; then
21511   echo $ECHO_N "(cached) $ECHO_C" >&6
21512 else
21513   ac_check_lib_save_LIBS=$LIBS
21514 LIBS="-lm  $LIBS"
21515 if test x$gcc_no_link = xyes; then
21516   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21517 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21518    { (exit 1); exit 1; }; }
21519 fi
21520 cat >conftest.$ac_ext <<_ACEOF
21521 /* confdefs.h.  */
21522 _ACEOF
21523 cat confdefs.h >>conftest.$ac_ext
21524 cat >>conftest.$ac_ext <<_ACEOF
21525 /* end confdefs.h.  */
21526
21527 /* Override any gcc2 internal prototype to avoid an error.  */
21528 #ifdef __cplusplus
21529 extern "C"
21530 #endif
21531 /* We use char because int might match the return type of a gcc2
21532    builtin and then its argument prototype would still apply.  */
21533 char j0f ();
21534 int
21535 main ()
21536 {
21537 j0f ();
21538   ;
21539   return 0;
21540 }
21541 _ACEOF
21542 rm -f conftest.$ac_objext conftest$ac_exeext
21543 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21544   (eval $ac_link) 2>conftest.er1
21545   ac_status=$?
21546   grep -v '^ *+' conftest.er1 >conftest.err
21547   rm -f conftest.er1
21548   cat conftest.err >&5
21549   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21550   (exit $ac_status); } &&
21551          { ac_try='test -z "$ac_c_werror_flag"
21552                          || test ! -s conftest.err'
21553   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21554   (eval $ac_try) 2>&5
21555   ac_status=$?
21556   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21557   (exit $ac_status); }; } &&
21558          { ac_try='test -s conftest$ac_exeext'
21559   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21560   (eval $ac_try) 2>&5
21561   ac_status=$?
21562   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21563   (exit $ac_status); }; }; then
21564   ac_cv_lib_m_j0f=yes
21565 else
21566   echo "$as_me: failed program was:" >&5
21567 sed 's/^/| /' conftest.$ac_ext >&5
21568
21569 ac_cv_lib_m_j0f=no
21570 fi
21571 rm -f conftest.err conftest.$ac_objext \
21572       conftest$ac_exeext conftest.$ac_ext
21573 LIBS=$ac_check_lib_save_LIBS
21574 fi
21575 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0f" >&5
21576 echo "${ECHO_T}$ac_cv_lib_m_j0f" >&6
21577 if test $ac_cv_lib_m_j0f = yes; then
21578
21579 cat >>confdefs.h <<\_ACEOF
21580 #define HAVE_J0F 1
21581 _ACEOF
21582
21583 fi
21584
21585 echo "$as_me:$LINENO: checking for j0 in -lm" >&5
21586 echo $ECHO_N "checking for j0 in -lm... $ECHO_C" >&6
21587 if test "${ac_cv_lib_m_j0+set}" = set; then
21588   echo $ECHO_N "(cached) $ECHO_C" >&6
21589 else
21590   ac_check_lib_save_LIBS=$LIBS
21591 LIBS="-lm  $LIBS"
21592 if test x$gcc_no_link = xyes; then
21593   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21594 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21595    { (exit 1); exit 1; }; }
21596 fi
21597 cat >conftest.$ac_ext <<_ACEOF
21598 /* confdefs.h.  */
21599 _ACEOF
21600 cat confdefs.h >>conftest.$ac_ext
21601 cat >>conftest.$ac_ext <<_ACEOF
21602 /* end confdefs.h.  */
21603
21604 /* Override any gcc2 internal prototype to avoid an error.  */
21605 #ifdef __cplusplus
21606 extern "C"
21607 #endif
21608 /* We use char because int might match the return type of a gcc2
21609    builtin and then its argument prototype would still apply.  */
21610 char j0 ();
21611 int
21612 main ()
21613 {
21614 j0 ();
21615   ;
21616   return 0;
21617 }
21618 _ACEOF
21619 rm -f conftest.$ac_objext conftest$ac_exeext
21620 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21621   (eval $ac_link) 2>conftest.er1
21622   ac_status=$?
21623   grep -v '^ *+' conftest.er1 >conftest.err
21624   rm -f conftest.er1
21625   cat conftest.err >&5
21626   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21627   (exit $ac_status); } &&
21628          { ac_try='test -z "$ac_c_werror_flag"
21629                          || test ! -s conftest.err'
21630   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21631   (eval $ac_try) 2>&5
21632   ac_status=$?
21633   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21634   (exit $ac_status); }; } &&
21635          { ac_try='test -s conftest$ac_exeext'
21636   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21637   (eval $ac_try) 2>&5
21638   ac_status=$?
21639   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21640   (exit $ac_status); }; }; then
21641   ac_cv_lib_m_j0=yes
21642 else
21643   echo "$as_me: failed program was:" >&5
21644 sed 's/^/| /' conftest.$ac_ext >&5
21645
21646 ac_cv_lib_m_j0=no
21647 fi
21648 rm -f conftest.err conftest.$ac_objext \
21649       conftest$ac_exeext conftest.$ac_ext
21650 LIBS=$ac_check_lib_save_LIBS
21651 fi
21652 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0" >&5
21653 echo "${ECHO_T}$ac_cv_lib_m_j0" >&6
21654 if test $ac_cv_lib_m_j0 = yes; then
21655
21656 cat >>confdefs.h <<\_ACEOF
21657 #define HAVE_J0 1
21658 _ACEOF
21659
21660 fi
21661
21662 echo "$as_me:$LINENO: checking for j0l in -lm" >&5
21663 echo $ECHO_N "checking for j0l in -lm... $ECHO_C" >&6
21664 if test "${ac_cv_lib_m_j0l+set}" = set; then
21665   echo $ECHO_N "(cached) $ECHO_C" >&6
21666 else
21667   ac_check_lib_save_LIBS=$LIBS
21668 LIBS="-lm  $LIBS"
21669 if test x$gcc_no_link = xyes; then
21670   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21671 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21672    { (exit 1); exit 1; }; }
21673 fi
21674 cat >conftest.$ac_ext <<_ACEOF
21675 /* confdefs.h.  */
21676 _ACEOF
21677 cat confdefs.h >>conftest.$ac_ext
21678 cat >>conftest.$ac_ext <<_ACEOF
21679 /* end confdefs.h.  */
21680
21681 /* Override any gcc2 internal prototype to avoid an error.  */
21682 #ifdef __cplusplus
21683 extern "C"
21684 #endif
21685 /* We use char because int might match the return type of a gcc2
21686    builtin and then its argument prototype would still apply.  */
21687 char j0l ();
21688 int
21689 main ()
21690 {
21691 j0l ();
21692   ;
21693   return 0;
21694 }
21695 _ACEOF
21696 rm -f conftest.$ac_objext conftest$ac_exeext
21697 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21698   (eval $ac_link) 2>conftest.er1
21699   ac_status=$?
21700   grep -v '^ *+' conftest.er1 >conftest.err
21701   rm -f conftest.er1
21702   cat conftest.err >&5
21703   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21704   (exit $ac_status); } &&
21705          { ac_try='test -z "$ac_c_werror_flag"
21706                          || test ! -s conftest.err'
21707   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21708   (eval $ac_try) 2>&5
21709   ac_status=$?
21710   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21711   (exit $ac_status); }; } &&
21712          { ac_try='test -s conftest$ac_exeext'
21713   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21714   (eval $ac_try) 2>&5
21715   ac_status=$?
21716   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21717   (exit $ac_status); }; }; then
21718   ac_cv_lib_m_j0l=yes
21719 else
21720   echo "$as_me: failed program was:" >&5
21721 sed 's/^/| /' conftest.$ac_ext >&5
21722
21723 ac_cv_lib_m_j0l=no
21724 fi
21725 rm -f conftest.err conftest.$ac_objext \
21726       conftest$ac_exeext conftest.$ac_ext
21727 LIBS=$ac_check_lib_save_LIBS
21728 fi
21729 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0l" >&5
21730 echo "${ECHO_T}$ac_cv_lib_m_j0l" >&6
21731 if test $ac_cv_lib_m_j0l = yes; then
21732
21733 cat >>confdefs.h <<\_ACEOF
21734 #define HAVE_J0L 1
21735 _ACEOF
21736
21737 fi
21738
21739 echo "$as_me:$LINENO: checking for j1f in -lm" >&5
21740 echo $ECHO_N "checking for j1f in -lm... $ECHO_C" >&6
21741 if test "${ac_cv_lib_m_j1f+set}" = set; then
21742   echo $ECHO_N "(cached) $ECHO_C" >&6
21743 else
21744   ac_check_lib_save_LIBS=$LIBS
21745 LIBS="-lm  $LIBS"
21746 if test x$gcc_no_link = xyes; then
21747   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21748 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21749    { (exit 1); exit 1; }; }
21750 fi
21751 cat >conftest.$ac_ext <<_ACEOF
21752 /* confdefs.h.  */
21753 _ACEOF
21754 cat confdefs.h >>conftest.$ac_ext
21755 cat >>conftest.$ac_ext <<_ACEOF
21756 /* end confdefs.h.  */
21757
21758 /* Override any gcc2 internal prototype to avoid an error.  */
21759 #ifdef __cplusplus
21760 extern "C"
21761 #endif
21762 /* We use char because int might match the return type of a gcc2
21763    builtin and then its argument prototype would still apply.  */
21764 char j1f ();
21765 int
21766 main ()
21767 {
21768 j1f ();
21769   ;
21770   return 0;
21771 }
21772 _ACEOF
21773 rm -f conftest.$ac_objext conftest$ac_exeext
21774 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21775   (eval $ac_link) 2>conftest.er1
21776   ac_status=$?
21777   grep -v '^ *+' conftest.er1 >conftest.err
21778   rm -f conftest.er1
21779   cat conftest.err >&5
21780   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21781   (exit $ac_status); } &&
21782          { ac_try='test -z "$ac_c_werror_flag"
21783                          || test ! -s conftest.err'
21784   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21785   (eval $ac_try) 2>&5
21786   ac_status=$?
21787   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21788   (exit $ac_status); }; } &&
21789          { ac_try='test -s conftest$ac_exeext'
21790   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21791   (eval $ac_try) 2>&5
21792   ac_status=$?
21793   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21794   (exit $ac_status); }; }; then
21795   ac_cv_lib_m_j1f=yes
21796 else
21797   echo "$as_me: failed program was:" >&5
21798 sed 's/^/| /' conftest.$ac_ext >&5
21799
21800 ac_cv_lib_m_j1f=no
21801 fi
21802 rm -f conftest.err conftest.$ac_objext \
21803       conftest$ac_exeext conftest.$ac_ext
21804 LIBS=$ac_check_lib_save_LIBS
21805 fi
21806 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1f" >&5
21807 echo "${ECHO_T}$ac_cv_lib_m_j1f" >&6
21808 if test $ac_cv_lib_m_j1f = yes; then
21809
21810 cat >>confdefs.h <<\_ACEOF
21811 #define HAVE_J1F 1
21812 _ACEOF
21813
21814 fi
21815
21816 echo "$as_me:$LINENO: checking for j1 in -lm" >&5
21817 echo $ECHO_N "checking for j1 in -lm... $ECHO_C" >&6
21818 if test "${ac_cv_lib_m_j1+set}" = set; then
21819   echo $ECHO_N "(cached) $ECHO_C" >&6
21820 else
21821   ac_check_lib_save_LIBS=$LIBS
21822 LIBS="-lm  $LIBS"
21823 if test x$gcc_no_link = xyes; then
21824   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21825 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21826    { (exit 1); exit 1; }; }
21827 fi
21828 cat >conftest.$ac_ext <<_ACEOF
21829 /* confdefs.h.  */
21830 _ACEOF
21831 cat confdefs.h >>conftest.$ac_ext
21832 cat >>conftest.$ac_ext <<_ACEOF
21833 /* end confdefs.h.  */
21834
21835 /* Override any gcc2 internal prototype to avoid an error.  */
21836 #ifdef __cplusplus
21837 extern "C"
21838 #endif
21839 /* We use char because int might match the return type of a gcc2
21840    builtin and then its argument prototype would still apply.  */
21841 char j1 ();
21842 int
21843 main ()
21844 {
21845 j1 ();
21846   ;
21847   return 0;
21848 }
21849 _ACEOF
21850 rm -f conftest.$ac_objext conftest$ac_exeext
21851 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21852   (eval $ac_link) 2>conftest.er1
21853   ac_status=$?
21854   grep -v '^ *+' conftest.er1 >conftest.err
21855   rm -f conftest.er1
21856   cat conftest.err >&5
21857   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21858   (exit $ac_status); } &&
21859          { ac_try='test -z "$ac_c_werror_flag"
21860                          || test ! -s conftest.err'
21861   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21862   (eval $ac_try) 2>&5
21863   ac_status=$?
21864   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21865   (exit $ac_status); }; } &&
21866          { ac_try='test -s conftest$ac_exeext'
21867   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21868   (eval $ac_try) 2>&5
21869   ac_status=$?
21870   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21871   (exit $ac_status); }; }; then
21872   ac_cv_lib_m_j1=yes
21873 else
21874   echo "$as_me: failed program was:" >&5
21875 sed 's/^/| /' conftest.$ac_ext >&5
21876
21877 ac_cv_lib_m_j1=no
21878 fi
21879 rm -f conftest.err conftest.$ac_objext \
21880       conftest$ac_exeext conftest.$ac_ext
21881 LIBS=$ac_check_lib_save_LIBS
21882 fi
21883 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1" >&5
21884 echo "${ECHO_T}$ac_cv_lib_m_j1" >&6
21885 if test $ac_cv_lib_m_j1 = yes; then
21886
21887 cat >>confdefs.h <<\_ACEOF
21888 #define HAVE_J1 1
21889 _ACEOF
21890
21891 fi
21892
21893 echo "$as_me:$LINENO: checking for j1l in -lm" >&5
21894 echo $ECHO_N "checking for j1l in -lm... $ECHO_C" >&6
21895 if test "${ac_cv_lib_m_j1l+set}" = set; then
21896   echo $ECHO_N "(cached) $ECHO_C" >&6
21897 else
21898   ac_check_lib_save_LIBS=$LIBS
21899 LIBS="-lm  $LIBS"
21900 if test x$gcc_no_link = xyes; then
21901   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21902 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21903    { (exit 1); exit 1; }; }
21904 fi
21905 cat >conftest.$ac_ext <<_ACEOF
21906 /* confdefs.h.  */
21907 _ACEOF
21908 cat confdefs.h >>conftest.$ac_ext
21909 cat >>conftest.$ac_ext <<_ACEOF
21910 /* end confdefs.h.  */
21911
21912 /* Override any gcc2 internal prototype to avoid an error.  */
21913 #ifdef __cplusplus
21914 extern "C"
21915 #endif
21916 /* We use char because int might match the return type of a gcc2
21917    builtin and then its argument prototype would still apply.  */
21918 char j1l ();
21919 int
21920 main ()
21921 {
21922 j1l ();
21923   ;
21924   return 0;
21925 }
21926 _ACEOF
21927 rm -f conftest.$ac_objext conftest$ac_exeext
21928 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21929   (eval $ac_link) 2>conftest.er1
21930   ac_status=$?
21931   grep -v '^ *+' conftest.er1 >conftest.err
21932   rm -f conftest.er1
21933   cat conftest.err >&5
21934   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21935   (exit $ac_status); } &&
21936          { ac_try='test -z "$ac_c_werror_flag"
21937                          || test ! -s conftest.err'
21938   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21939   (eval $ac_try) 2>&5
21940   ac_status=$?
21941   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21942   (exit $ac_status); }; } &&
21943          { ac_try='test -s conftest$ac_exeext'
21944   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21945   (eval $ac_try) 2>&5
21946   ac_status=$?
21947   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21948   (exit $ac_status); }; }; then
21949   ac_cv_lib_m_j1l=yes
21950 else
21951   echo "$as_me: failed program was:" >&5
21952 sed 's/^/| /' conftest.$ac_ext >&5
21953
21954 ac_cv_lib_m_j1l=no
21955 fi
21956 rm -f conftest.err conftest.$ac_objext \
21957       conftest$ac_exeext conftest.$ac_ext
21958 LIBS=$ac_check_lib_save_LIBS
21959 fi
21960 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1l" >&5
21961 echo "${ECHO_T}$ac_cv_lib_m_j1l" >&6
21962 if test $ac_cv_lib_m_j1l = yes; then
21963
21964 cat >>confdefs.h <<\_ACEOF
21965 #define HAVE_J1L 1
21966 _ACEOF
21967
21968 fi
21969
21970 echo "$as_me:$LINENO: checking for jnf in -lm" >&5
21971 echo $ECHO_N "checking for jnf in -lm... $ECHO_C" >&6
21972 if test "${ac_cv_lib_m_jnf+set}" = set; then
21973   echo $ECHO_N "(cached) $ECHO_C" >&6
21974 else
21975   ac_check_lib_save_LIBS=$LIBS
21976 LIBS="-lm  $LIBS"
21977 if test x$gcc_no_link = xyes; then
21978   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21979 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21980    { (exit 1); exit 1; }; }
21981 fi
21982 cat >conftest.$ac_ext <<_ACEOF
21983 /* confdefs.h.  */
21984 _ACEOF
21985 cat confdefs.h >>conftest.$ac_ext
21986 cat >>conftest.$ac_ext <<_ACEOF
21987 /* end confdefs.h.  */
21988
21989 /* Override any gcc2 internal prototype to avoid an error.  */
21990 #ifdef __cplusplus
21991 extern "C"
21992 #endif
21993 /* We use char because int might match the return type of a gcc2
21994    builtin and then its argument prototype would still apply.  */
21995 char jnf ();
21996 int
21997 main ()
21998 {
21999 jnf ();
22000   ;
22001   return 0;
22002 }
22003 _ACEOF
22004 rm -f conftest.$ac_objext conftest$ac_exeext
22005 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22006   (eval $ac_link) 2>conftest.er1
22007   ac_status=$?
22008   grep -v '^ *+' conftest.er1 >conftest.err
22009   rm -f conftest.er1
22010   cat conftest.err >&5
22011   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22012   (exit $ac_status); } &&
22013          { ac_try='test -z "$ac_c_werror_flag"
22014                          || test ! -s conftest.err'
22015   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22016   (eval $ac_try) 2>&5
22017   ac_status=$?
22018   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22019   (exit $ac_status); }; } &&
22020          { ac_try='test -s conftest$ac_exeext'
22021   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22022   (eval $ac_try) 2>&5
22023   ac_status=$?
22024   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22025   (exit $ac_status); }; }; then
22026   ac_cv_lib_m_jnf=yes
22027 else
22028   echo "$as_me: failed program was:" >&5
22029 sed 's/^/| /' conftest.$ac_ext >&5
22030
22031 ac_cv_lib_m_jnf=no
22032 fi
22033 rm -f conftest.err conftest.$ac_objext \
22034       conftest$ac_exeext conftest.$ac_ext
22035 LIBS=$ac_check_lib_save_LIBS
22036 fi
22037 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jnf" >&5
22038 echo "${ECHO_T}$ac_cv_lib_m_jnf" >&6
22039 if test $ac_cv_lib_m_jnf = yes; then
22040
22041 cat >>confdefs.h <<\_ACEOF
22042 #define HAVE_JNF 1
22043 _ACEOF
22044
22045 fi
22046
22047 echo "$as_me:$LINENO: checking for jn in -lm" >&5
22048 echo $ECHO_N "checking for jn in -lm... $ECHO_C" >&6
22049 if test "${ac_cv_lib_m_jn+set}" = set; then
22050   echo $ECHO_N "(cached) $ECHO_C" >&6
22051 else
22052   ac_check_lib_save_LIBS=$LIBS
22053 LIBS="-lm  $LIBS"
22054 if test x$gcc_no_link = xyes; then
22055   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22056 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22057    { (exit 1); exit 1; }; }
22058 fi
22059 cat >conftest.$ac_ext <<_ACEOF
22060 /* confdefs.h.  */
22061 _ACEOF
22062 cat confdefs.h >>conftest.$ac_ext
22063 cat >>conftest.$ac_ext <<_ACEOF
22064 /* end confdefs.h.  */
22065
22066 /* Override any gcc2 internal prototype to avoid an error.  */
22067 #ifdef __cplusplus
22068 extern "C"
22069 #endif
22070 /* We use char because int might match the return type of a gcc2
22071    builtin and then its argument prototype would still apply.  */
22072 char jn ();
22073 int
22074 main ()
22075 {
22076 jn ();
22077   ;
22078   return 0;
22079 }
22080 _ACEOF
22081 rm -f conftest.$ac_objext conftest$ac_exeext
22082 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22083   (eval $ac_link) 2>conftest.er1
22084   ac_status=$?
22085   grep -v '^ *+' conftest.er1 >conftest.err
22086   rm -f conftest.er1
22087   cat conftest.err >&5
22088   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22089   (exit $ac_status); } &&
22090          { ac_try='test -z "$ac_c_werror_flag"
22091                          || test ! -s conftest.err'
22092   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22093   (eval $ac_try) 2>&5
22094   ac_status=$?
22095   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22096   (exit $ac_status); }; } &&
22097          { ac_try='test -s conftest$ac_exeext'
22098   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22099   (eval $ac_try) 2>&5
22100   ac_status=$?
22101   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22102   (exit $ac_status); }; }; then
22103   ac_cv_lib_m_jn=yes
22104 else
22105   echo "$as_me: failed program was:" >&5
22106 sed 's/^/| /' conftest.$ac_ext >&5
22107
22108 ac_cv_lib_m_jn=no
22109 fi
22110 rm -f conftest.err conftest.$ac_objext \
22111       conftest$ac_exeext conftest.$ac_ext
22112 LIBS=$ac_check_lib_save_LIBS
22113 fi
22114 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jn" >&5
22115 echo "${ECHO_T}$ac_cv_lib_m_jn" >&6
22116 if test $ac_cv_lib_m_jn = yes; then
22117
22118 cat >>confdefs.h <<\_ACEOF
22119 #define HAVE_JN 1
22120 _ACEOF
22121
22122 fi
22123
22124 echo "$as_me:$LINENO: checking for jnl in -lm" >&5
22125 echo $ECHO_N "checking for jnl in -lm... $ECHO_C" >&6
22126 if test "${ac_cv_lib_m_jnl+set}" = set; then
22127   echo $ECHO_N "(cached) $ECHO_C" >&6
22128 else
22129   ac_check_lib_save_LIBS=$LIBS
22130 LIBS="-lm  $LIBS"
22131 if test x$gcc_no_link = xyes; then
22132   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22133 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22134    { (exit 1); exit 1; }; }
22135 fi
22136 cat >conftest.$ac_ext <<_ACEOF
22137 /* confdefs.h.  */
22138 _ACEOF
22139 cat confdefs.h >>conftest.$ac_ext
22140 cat >>conftest.$ac_ext <<_ACEOF
22141 /* end confdefs.h.  */
22142
22143 /* Override any gcc2 internal prototype to avoid an error.  */
22144 #ifdef __cplusplus
22145 extern "C"
22146 #endif
22147 /* We use char because int might match the return type of a gcc2
22148    builtin and then its argument prototype would still apply.  */
22149 char jnl ();
22150 int
22151 main ()
22152 {
22153 jnl ();
22154   ;
22155   return 0;
22156 }
22157 _ACEOF
22158 rm -f conftest.$ac_objext conftest$ac_exeext
22159 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22160   (eval $ac_link) 2>conftest.er1
22161   ac_status=$?
22162   grep -v '^ *+' conftest.er1 >conftest.err
22163   rm -f conftest.er1
22164   cat conftest.err >&5
22165   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22166   (exit $ac_status); } &&
22167          { ac_try='test -z "$ac_c_werror_flag"
22168                          || test ! -s conftest.err'
22169   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22170   (eval $ac_try) 2>&5
22171   ac_status=$?
22172   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22173   (exit $ac_status); }; } &&
22174          { ac_try='test -s conftest$ac_exeext'
22175   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22176   (eval $ac_try) 2>&5
22177   ac_status=$?
22178   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22179   (exit $ac_status); }; }; then
22180   ac_cv_lib_m_jnl=yes
22181 else
22182   echo "$as_me: failed program was:" >&5
22183 sed 's/^/| /' conftest.$ac_ext >&5
22184
22185 ac_cv_lib_m_jnl=no
22186 fi
22187 rm -f conftest.err conftest.$ac_objext \
22188       conftest$ac_exeext conftest.$ac_ext
22189 LIBS=$ac_check_lib_save_LIBS
22190 fi
22191 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jnl" >&5
22192 echo "${ECHO_T}$ac_cv_lib_m_jnl" >&6
22193 if test $ac_cv_lib_m_jnl = yes; then
22194
22195 cat >>confdefs.h <<\_ACEOF
22196 #define HAVE_JNL 1
22197 _ACEOF
22198
22199 fi
22200
22201 echo "$as_me:$LINENO: checking for y0f in -lm" >&5
22202 echo $ECHO_N "checking for y0f in -lm... $ECHO_C" >&6
22203 if test "${ac_cv_lib_m_y0f+set}" = set; then
22204   echo $ECHO_N "(cached) $ECHO_C" >&6
22205 else
22206   ac_check_lib_save_LIBS=$LIBS
22207 LIBS="-lm  $LIBS"
22208 if test x$gcc_no_link = xyes; then
22209   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22210 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22211    { (exit 1); exit 1; }; }
22212 fi
22213 cat >conftest.$ac_ext <<_ACEOF
22214 /* confdefs.h.  */
22215 _ACEOF
22216 cat confdefs.h >>conftest.$ac_ext
22217 cat >>conftest.$ac_ext <<_ACEOF
22218 /* end confdefs.h.  */
22219
22220 /* Override any gcc2 internal prototype to avoid an error.  */
22221 #ifdef __cplusplus
22222 extern "C"
22223 #endif
22224 /* We use char because int might match the return type of a gcc2
22225    builtin and then its argument prototype would still apply.  */
22226 char y0f ();
22227 int
22228 main ()
22229 {
22230 y0f ();
22231   ;
22232   return 0;
22233 }
22234 _ACEOF
22235 rm -f conftest.$ac_objext conftest$ac_exeext
22236 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22237   (eval $ac_link) 2>conftest.er1
22238   ac_status=$?
22239   grep -v '^ *+' conftest.er1 >conftest.err
22240   rm -f conftest.er1
22241   cat conftest.err >&5
22242   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22243   (exit $ac_status); } &&
22244          { ac_try='test -z "$ac_c_werror_flag"
22245                          || test ! -s conftest.err'
22246   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22247   (eval $ac_try) 2>&5
22248   ac_status=$?
22249   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22250   (exit $ac_status); }; } &&
22251          { ac_try='test -s conftest$ac_exeext'
22252   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22253   (eval $ac_try) 2>&5
22254   ac_status=$?
22255   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22256   (exit $ac_status); }; }; then
22257   ac_cv_lib_m_y0f=yes
22258 else
22259   echo "$as_me: failed program was:" >&5
22260 sed 's/^/| /' conftest.$ac_ext >&5
22261
22262 ac_cv_lib_m_y0f=no
22263 fi
22264 rm -f conftest.err conftest.$ac_objext \
22265       conftest$ac_exeext conftest.$ac_ext
22266 LIBS=$ac_check_lib_save_LIBS
22267 fi
22268 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0f" >&5
22269 echo "${ECHO_T}$ac_cv_lib_m_y0f" >&6
22270 if test $ac_cv_lib_m_y0f = yes; then
22271
22272 cat >>confdefs.h <<\_ACEOF
22273 #define HAVE_Y0F 1
22274 _ACEOF
22275
22276 fi
22277
22278 echo "$as_me:$LINENO: checking for y0 in -lm" >&5
22279 echo $ECHO_N "checking for y0 in -lm... $ECHO_C" >&6
22280 if test "${ac_cv_lib_m_y0+set}" = set; then
22281   echo $ECHO_N "(cached) $ECHO_C" >&6
22282 else
22283   ac_check_lib_save_LIBS=$LIBS
22284 LIBS="-lm  $LIBS"
22285 if test x$gcc_no_link = xyes; then
22286   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22287 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22288    { (exit 1); exit 1; }; }
22289 fi
22290 cat >conftest.$ac_ext <<_ACEOF
22291 /* confdefs.h.  */
22292 _ACEOF
22293 cat confdefs.h >>conftest.$ac_ext
22294 cat >>conftest.$ac_ext <<_ACEOF
22295 /* end confdefs.h.  */
22296
22297 /* Override any gcc2 internal prototype to avoid an error.  */
22298 #ifdef __cplusplus
22299 extern "C"
22300 #endif
22301 /* We use char because int might match the return type of a gcc2
22302    builtin and then its argument prototype would still apply.  */
22303 char y0 ();
22304 int
22305 main ()
22306 {
22307 y0 ();
22308   ;
22309   return 0;
22310 }
22311 _ACEOF
22312 rm -f conftest.$ac_objext conftest$ac_exeext
22313 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22314   (eval $ac_link) 2>conftest.er1
22315   ac_status=$?
22316   grep -v '^ *+' conftest.er1 >conftest.err
22317   rm -f conftest.er1
22318   cat conftest.err >&5
22319   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22320   (exit $ac_status); } &&
22321          { ac_try='test -z "$ac_c_werror_flag"
22322                          || test ! -s conftest.err'
22323   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22324   (eval $ac_try) 2>&5
22325   ac_status=$?
22326   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22327   (exit $ac_status); }; } &&
22328          { ac_try='test -s conftest$ac_exeext'
22329   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22330   (eval $ac_try) 2>&5
22331   ac_status=$?
22332   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22333   (exit $ac_status); }; }; then
22334   ac_cv_lib_m_y0=yes
22335 else
22336   echo "$as_me: failed program was:" >&5
22337 sed 's/^/| /' conftest.$ac_ext >&5
22338
22339 ac_cv_lib_m_y0=no
22340 fi
22341 rm -f conftest.err conftest.$ac_objext \
22342       conftest$ac_exeext conftest.$ac_ext
22343 LIBS=$ac_check_lib_save_LIBS
22344 fi
22345 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0" >&5
22346 echo "${ECHO_T}$ac_cv_lib_m_y0" >&6
22347 if test $ac_cv_lib_m_y0 = yes; then
22348
22349 cat >>confdefs.h <<\_ACEOF
22350 #define HAVE_Y0 1
22351 _ACEOF
22352
22353 fi
22354
22355 echo "$as_me:$LINENO: checking for y0l in -lm" >&5
22356 echo $ECHO_N "checking for y0l in -lm... $ECHO_C" >&6
22357 if test "${ac_cv_lib_m_y0l+set}" = set; then
22358   echo $ECHO_N "(cached) $ECHO_C" >&6
22359 else
22360   ac_check_lib_save_LIBS=$LIBS
22361 LIBS="-lm  $LIBS"
22362 if test x$gcc_no_link = xyes; then
22363   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22364 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22365    { (exit 1); exit 1; }; }
22366 fi
22367 cat >conftest.$ac_ext <<_ACEOF
22368 /* confdefs.h.  */
22369 _ACEOF
22370 cat confdefs.h >>conftest.$ac_ext
22371 cat >>conftest.$ac_ext <<_ACEOF
22372 /* end confdefs.h.  */
22373
22374 /* Override any gcc2 internal prototype to avoid an error.  */
22375 #ifdef __cplusplus
22376 extern "C"
22377 #endif
22378 /* We use char because int might match the return type of a gcc2
22379    builtin and then its argument prototype would still apply.  */
22380 char y0l ();
22381 int
22382 main ()
22383 {
22384 y0l ();
22385   ;
22386   return 0;
22387 }
22388 _ACEOF
22389 rm -f conftest.$ac_objext conftest$ac_exeext
22390 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22391   (eval $ac_link) 2>conftest.er1
22392   ac_status=$?
22393   grep -v '^ *+' conftest.er1 >conftest.err
22394   rm -f conftest.er1
22395   cat conftest.err >&5
22396   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22397   (exit $ac_status); } &&
22398          { ac_try='test -z "$ac_c_werror_flag"
22399                          || test ! -s conftest.err'
22400   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22401   (eval $ac_try) 2>&5
22402   ac_status=$?
22403   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22404   (exit $ac_status); }; } &&
22405          { ac_try='test -s conftest$ac_exeext'
22406   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22407   (eval $ac_try) 2>&5
22408   ac_status=$?
22409   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22410   (exit $ac_status); }; }; then
22411   ac_cv_lib_m_y0l=yes
22412 else
22413   echo "$as_me: failed program was:" >&5
22414 sed 's/^/| /' conftest.$ac_ext >&5
22415
22416 ac_cv_lib_m_y0l=no
22417 fi
22418 rm -f conftest.err conftest.$ac_objext \
22419       conftest$ac_exeext conftest.$ac_ext
22420 LIBS=$ac_check_lib_save_LIBS
22421 fi
22422 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0l" >&5
22423 echo "${ECHO_T}$ac_cv_lib_m_y0l" >&6
22424 if test $ac_cv_lib_m_y0l = yes; then
22425
22426 cat >>confdefs.h <<\_ACEOF
22427 #define HAVE_Y0L 1
22428 _ACEOF
22429
22430 fi
22431
22432 echo "$as_me:$LINENO: checking for y1f in -lm" >&5
22433 echo $ECHO_N "checking for y1f in -lm... $ECHO_C" >&6
22434 if test "${ac_cv_lib_m_y1f+set}" = set; then
22435   echo $ECHO_N "(cached) $ECHO_C" >&6
22436 else
22437   ac_check_lib_save_LIBS=$LIBS
22438 LIBS="-lm  $LIBS"
22439 if test x$gcc_no_link = xyes; then
22440   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22441 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22442    { (exit 1); exit 1; }; }
22443 fi
22444 cat >conftest.$ac_ext <<_ACEOF
22445 /* confdefs.h.  */
22446 _ACEOF
22447 cat confdefs.h >>conftest.$ac_ext
22448 cat >>conftest.$ac_ext <<_ACEOF
22449 /* end confdefs.h.  */
22450
22451 /* Override any gcc2 internal prototype to avoid an error.  */
22452 #ifdef __cplusplus
22453 extern "C"
22454 #endif
22455 /* We use char because int might match the return type of a gcc2
22456    builtin and then its argument prototype would still apply.  */
22457 char y1f ();
22458 int
22459 main ()
22460 {
22461 y1f ();
22462   ;
22463   return 0;
22464 }
22465 _ACEOF
22466 rm -f conftest.$ac_objext conftest$ac_exeext
22467 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22468   (eval $ac_link) 2>conftest.er1
22469   ac_status=$?
22470   grep -v '^ *+' conftest.er1 >conftest.err
22471   rm -f conftest.er1
22472   cat conftest.err >&5
22473   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22474   (exit $ac_status); } &&
22475          { ac_try='test -z "$ac_c_werror_flag"
22476                          || test ! -s conftest.err'
22477   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22478   (eval $ac_try) 2>&5
22479   ac_status=$?
22480   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22481   (exit $ac_status); }; } &&
22482          { ac_try='test -s conftest$ac_exeext'
22483   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22484   (eval $ac_try) 2>&5
22485   ac_status=$?
22486   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22487   (exit $ac_status); }; }; then
22488   ac_cv_lib_m_y1f=yes
22489 else
22490   echo "$as_me: failed program was:" >&5
22491 sed 's/^/| /' conftest.$ac_ext >&5
22492
22493 ac_cv_lib_m_y1f=no
22494 fi
22495 rm -f conftest.err conftest.$ac_objext \
22496       conftest$ac_exeext conftest.$ac_ext
22497 LIBS=$ac_check_lib_save_LIBS
22498 fi
22499 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1f" >&5
22500 echo "${ECHO_T}$ac_cv_lib_m_y1f" >&6
22501 if test $ac_cv_lib_m_y1f = yes; then
22502
22503 cat >>confdefs.h <<\_ACEOF
22504 #define HAVE_Y1F 1
22505 _ACEOF
22506
22507 fi
22508
22509 echo "$as_me:$LINENO: checking for y1 in -lm" >&5
22510 echo $ECHO_N "checking for y1 in -lm... $ECHO_C" >&6
22511 if test "${ac_cv_lib_m_y1+set}" = set; then
22512   echo $ECHO_N "(cached) $ECHO_C" >&6
22513 else
22514   ac_check_lib_save_LIBS=$LIBS
22515 LIBS="-lm  $LIBS"
22516 if test x$gcc_no_link = xyes; then
22517   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22518 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22519    { (exit 1); exit 1; }; }
22520 fi
22521 cat >conftest.$ac_ext <<_ACEOF
22522 /* confdefs.h.  */
22523 _ACEOF
22524 cat confdefs.h >>conftest.$ac_ext
22525 cat >>conftest.$ac_ext <<_ACEOF
22526 /* end confdefs.h.  */
22527
22528 /* Override any gcc2 internal prototype to avoid an error.  */
22529 #ifdef __cplusplus
22530 extern "C"
22531 #endif
22532 /* We use char because int might match the return type of a gcc2
22533    builtin and then its argument prototype would still apply.  */
22534 char y1 ();
22535 int
22536 main ()
22537 {
22538 y1 ();
22539   ;
22540   return 0;
22541 }
22542 _ACEOF
22543 rm -f conftest.$ac_objext conftest$ac_exeext
22544 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22545   (eval $ac_link) 2>conftest.er1
22546   ac_status=$?
22547   grep -v '^ *+' conftest.er1 >conftest.err
22548   rm -f conftest.er1
22549   cat conftest.err >&5
22550   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22551   (exit $ac_status); } &&
22552          { ac_try='test -z "$ac_c_werror_flag"
22553                          || test ! -s conftest.err'
22554   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22555   (eval $ac_try) 2>&5
22556   ac_status=$?
22557   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22558   (exit $ac_status); }; } &&
22559          { ac_try='test -s conftest$ac_exeext'
22560   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22561   (eval $ac_try) 2>&5
22562   ac_status=$?
22563   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22564   (exit $ac_status); }; }; then
22565   ac_cv_lib_m_y1=yes
22566 else
22567   echo "$as_me: failed program was:" >&5
22568 sed 's/^/| /' conftest.$ac_ext >&5
22569
22570 ac_cv_lib_m_y1=no
22571 fi
22572 rm -f conftest.err conftest.$ac_objext \
22573       conftest$ac_exeext conftest.$ac_ext
22574 LIBS=$ac_check_lib_save_LIBS
22575 fi
22576 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1" >&5
22577 echo "${ECHO_T}$ac_cv_lib_m_y1" >&6
22578 if test $ac_cv_lib_m_y1 = yes; then
22579
22580 cat >>confdefs.h <<\_ACEOF
22581 #define HAVE_Y1 1
22582 _ACEOF
22583
22584 fi
22585
22586 echo "$as_me:$LINENO: checking for y1l in -lm" >&5
22587 echo $ECHO_N "checking for y1l in -lm... $ECHO_C" >&6
22588 if test "${ac_cv_lib_m_y1l+set}" = set; then
22589   echo $ECHO_N "(cached) $ECHO_C" >&6
22590 else
22591   ac_check_lib_save_LIBS=$LIBS
22592 LIBS="-lm  $LIBS"
22593 if test x$gcc_no_link = xyes; then
22594   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22595 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22596    { (exit 1); exit 1; }; }
22597 fi
22598 cat >conftest.$ac_ext <<_ACEOF
22599 /* confdefs.h.  */
22600 _ACEOF
22601 cat confdefs.h >>conftest.$ac_ext
22602 cat >>conftest.$ac_ext <<_ACEOF
22603 /* end confdefs.h.  */
22604
22605 /* Override any gcc2 internal prototype to avoid an error.  */
22606 #ifdef __cplusplus
22607 extern "C"
22608 #endif
22609 /* We use char because int might match the return type of a gcc2
22610    builtin and then its argument prototype would still apply.  */
22611 char y1l ();
22612 int
22613 main ()
22614 {
22615 y1l ();
22616   ;
22617   return 0;
22618 }
22619 _ACEOF
22620 rm -f conftest.$ac_objext conftest$ac_exeext
22621 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22622   (eval $ac_link) 2>conftest.er1
22623   ac_status=$?
22624   grep -v '^ *+' conftest.er1 >conftest.err
22625   rm -f conftest.er1
22626   cat conftest.err >&5
22627   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22628   (exit $ac_status); } &&
22629          { ac_try='test -z "$ac_c_werror_flag"
22630                          || test ! -s conftest.err'
22631   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22632   (eval $ac_try) 2>&5
22633   ac_status=$?
22634   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22635   (exit $ac_status); }; } &&
22636          { ac_try='test -s conftest$ac_exeext'
22637   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22638   (eval $ac_try) 2>&5
22639   ac_status=$?
22640   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22641   (exit $ac_status); }; }; then
22642   ac_cv_lib_m_y1l=yes
22643 else
22644   echo "$as_me: failed program was:" >&5
22645 sed 's/^/| /' conftest.$ac_ext >&5
22646
22647 ac_cv_lib_m_y1l=no
22648 fi
22649 rm -f conftest.err conftest.$ac_objext \
22650       conftest$ac_exeext conftest.$ac_ext
22651 LIBS=$ac_check_lib_save_LIBS
22652 fi
22653 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1l" >&5
22654 echo "${ECHO_T}$ac_cv_lib_m_y1l" >&6
22655 if test $ac_cv_lib_m_y1l = yes; then
22656
22657 cat >>confdefs.h <<\_ACEOF
22658 #define HAVE_Y1L 1
22659 _ACEOF
22660
22661 fi
22662
22663 echo "$as_me:$LINENO: checking for ynf in -lm" >&5
22664 echo $ECHO_N "checking for ynf in -lm... $ECHO_C" >&6
22665 if test "${ac_cv_lib_m_ynf+set}" = set; then
22666   echo $ECHO_N "(cached) $ECHO_C" >&6
22667 else
22668   ac_check_lib_save_LIBS=$LIBS
22669 LIBS="-lm  $LIBS"
22670 if test x$gcc_no_link = xyes; then
22671   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22672 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22673    { (exit 1); exit 1; }; }
22674 fi
22675 cat >conftest.$ac_ext <<_ACEOF
22676 /* confdefs.h.  */
22677 _ACEOF
22678 cat confdefs.h >>conftest.$ac_ext
22679 cat >>conftest.$ac_ext <<_ACEOF
22680 /* end confdefs.h.  */
22681
22682 /* Override any gcc2 internal prototype to avoid an error.  */
22683 #ifdef __cplusplus
22684 extern "C"
22685 #endif
22686 /* We use char because int might match the return type of a gcc2
22687    builtin and then its argument prototype would still apply.  */
22688 char ynf ();
22689 int
22690 main ()
22691 {
22692 ynf ();
22693   ;
22694   return 0;
22695 }
22696 _ACEOF
22697 rm -f conftest.$ac_objext conftest$ac_exeext
22698 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22699   (eval $ac_link) 2>conftest.er1
22700   ac_status=$?
22701   grep -v '^ *+' conftest.er1 >conftest.err
22702   rm -f conftest.er1
22703   cat conftest.err >&5
22704   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22705   (exit $ac_status); } &&
22706          { ac_try='test -z "$ac_c_werror_flag"
22707                          || test ! -s conftest.err'
22708   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22709   (eval $ac_try) 2>&5
22710   ac_status=$?
22711   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22712   (exit $ac_status); }; } &&
22713          { ac_try='test -s conftest$ac_exeext'
22714   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22715   (eval $ac_try) 2>&5
22716   ac_status=$?
22717   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22718   (exit $ac_status); }; }; then
22719   ac_cv_lib_m_ynf=yes
22720 else
22721   echo "$as_me: failed program was:" >&5
22722 sed 's/^/| /' conftest.$ac_ext >&5
22723
22724 ac_cv_lib_m_ynf=no
22725 fi
22726 rm -f conftest.err conftest.$ac_objext \
22727       conftest$ac_exeext conftest.$ac_ext
22728 LIBS=$ac_check_lib_save_LIBS
22729 fi
22730 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ynf" >&5
22731 echo "${ECHO_T}$ac_cv_lib_m_ynf" >&6
22732 if test $ac_cv_lib_m_ynf = yes; then
22733
22734 cat >>confdefs.h <<\_ACEOF
22735 #define HAVE_YNF 1
22736 _ACEOF
22737
22738 fi
22739
22740 echo "$as_me:$LINENO: checking for yn in -lm" >&5
22741 echo $ECHO_N "checking for yn in -lm... $ECHO_C" >&6
22742 if test "${ac_cv_lib_m_yn+set}" = set; then
22743   echo $ECHO_N "(cached) $ECHO_C" >&6
22744 else
22745   ac_check_lib_save_LIBS=$LIBS
22746 LIBS="-lm  $LIBS"
22747 if test x$gcc_no_link = xyes; then
22748   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22749 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22750    { (exit 1); exit 1; }; }
22751 fi
22752 cat >conftest.$ac_ext <<_ACEOF
22753 /* confdefs.h.  */
22754 _ACEOF
22755 cat confdefs.h >>conftest.$ac_ext
22756 cat >>conftest.$ac_ext <<_ACEOF
22757 /* end confdefs.h.  */
22758
22759 /* Override any gcc2 internal prototype to avoid an error.  */
22760 #ifdef __cplusplus
22761 extern "C"
22762 #endif
22763 /* We use char because int might match the return type of a gcc2
22764    builtin and then its argument prototype would still apply.  */
22765 char yn ();
22766 int
22767 main ()
22768 {
22769 yn ();
22770   ;
22771   return 0;
22772 }
22773 _ACEOF
22774 rm -f conftest.$ac_objext conftest$ac_exeext
22775 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22776   (eval $ac_link) 2>conftest.er1
22777   ac_status=$?
22778   grep -v '^ *+' conftest.er1 >conftest.err
22779   rm -f conftest.er1
22780   cat conftest.err >&5
22781   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22782   (exit $ac_status); } &&
22783          { ac_try='test -z "$ac_c_werror_flag"
22784                          || test ! -s conftest.err'
22785   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22786   (eval $ac_try) 2>&5
22787   ac_status=$?
22788   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22789   (exit $ac_status); }; } &&
22790          { ac_try='test -s conftest$ac_exeext'
22791   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22792   (eval $ac_try) 2>&5
22793   ac_status=$?
22794   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22795   (exit $ac_status); }; }; then
22796   ac_cv_lib_m_yn=yes
22797 else
22798   echo "$as_me: failed program was:" >&5
22799 sed 's/^/| /' conftest.$ac_ext >&5
22800
22801 ac_cv_lib_m_yn=no
22802 fi
22803 rm -f conftest.err conftest.$ac_objext \
22804       conftest$ac_exeext conftest.$ac_ext
22805 LIBS=$ac_check_lib_save_LIBS
22806 fi
22807 echo "$as_me:$LINENO: result: $ac_cv_lib_m_yn" >&5
22808 echo "${ECHO_T}$ac_cv_lib_m_yn" >&6
22809 if test $ac_cv_lib_m_yn = yes; then
22810
22811 cat >>confdefs.h <<\_ACEOF
22812 #define HAVE_YN 1
22813 _ACEOF
22814
22815 fi
22816
22817 echo "$as_me:$LINENO: checking for ynl in -lm" >&5
22818 echo $ECHO_N "checking for ynl in -lm... $ECHO_C" >&6
22819 if test "${ac_cv_lib_m_ynl+set}" = set; then
22820   echo $ECHO_N "(cached) $ECHO_C" >&6
22821 else
22822   ac_check_lib_save_LIBS=$LIBS
22823 LIBS="-lm  $LIBS"
22824 if test x$gcc_no_link = xyes; then
22825   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22826 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22827    { (exit 1); exit 1; }; }
22828 fi
22829 cat >conftest.$ac_ext <<_ACEOF
22830 /* confdefs.h.  */
22831 _ACEOF
22832 cat confdefs.h >>conftest.$ac_ext
22833 cat >>conftest.$ac_ext <<_ACEOF
22834 /* end confdefs.h.  */
22835
22836 /* Override any gcc2 internal prototype to avoid an error.  */
22837 #ifdef __cplusplus
22838 extern "C"
22839 #endif
22840 /* We use char because int might match the return type of a gcc2
22841    builtin and then its argument prototype would still apply.  */
22842 char ynl ();
22843 int
22844 main ()
22845 {
22846 ynl ();
22847   ;
22848   return 0;
22849 }
22850 _ACEOF
22851 rm -f conftest.$ac_objext conftest$ac_exeext
22852 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22853   (eval $ac_link) 2>conftest.er1
22854   ac_status=$?
22855   grep -v '^ *+' conftest.er1 >conftest.err
22856   rm -f conftest.er1
22857   cat conftest.err >&5
22858   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22859   (exit $ac_status); } &&
22860          { ac_try='test -z "$ac_c_werror_flag"
22861                          || test ! -s conftest.err'
22862   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22863   (eval $ac_try) 2>&5
22864   ac_status=$?
22865   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22866   (exit $ac_status); }; } &&
22867          { ac_try='test -s conftest$ac_exeext'
22868   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22869   (eval $ac_try) 2>&5
22870   ac_status=$?
22871   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22872   (exit $ac_status); }; }; then
22873   ac_cv_lib_m_ynl=yes
22874 else
22875   echo "$as_me: failed program was:" >&5
22876 sed 's/^/| /' conftest.$ac_ext >&5
22877
22878 ac_cv_lib_m_ynl=no
22879 fi
22880 rm -f conftest.err conftest.$ac_objext \
22881       conftest$ac_exeext conftest.$ac_ext
22882 LIBS=$ac_check_lib_save_LIBS
22883 fi
22884 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ynl" >&5
22885 echo "${ECHO_T}$ac_cv_lib_m_ynl" >&6
22886 if test $ac_cv_lib_m_ynl = yes; then
22887
22888 cat >>confdefs.h <<\_ACEOF
22889 #define HAVE_YNL 1
22890 _ACEOF
22891
22892 fi
22893
22894
22895 # On AIX, clog is present in libm as __clog
22896 echo "$as_me:$LINENO: checking for __clog in -lm" >&5
22897 echo $ECHO_N "checking for __clog in -lm... $ECHO_C" >&6
22898 if test "${ac_cv_lib_m___clog+set}" = set; then
22899   echo $ECHO_N "(cached) $ECHO_C" >&6
22900 else
22901   ac_check_lib_save_LIBS=$LIBS
22902 LIBS="-lm  $LIBS"
22903 if test x$gcc_no_link = xyes; then
22904   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22905 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22906    { (exit 1); exit 1; }; }
22907 fi
22908 cat >conftest.$ac_ext <<_ACEOF
22909 /* confdefs.h.  */
22910 _ACEOF
22911 cat confdefs.h >>conftest.$ac_ext
22912 cat >>conftest.$ac_ext <<_ACEOF
22913 /* end confdefs.h.  */
22914
22915 /* Override any gcc2 internal prototype to avoid an error.  */
22916 #ifdef __cplusplus
22917 extern "C"
22918 #endif
22919 /* We use char because int might match the return type of a gcc2
22920    builtin and then its argument prototype would still apply.  */
22921 char __clog ();
22922 int
22923 main ()
22924 {
22925 __clog ();
22926   ;
22927   return 0;
22928 }
22929 _ACEOF
22930 rm -f conftest.$ac_objext conftest$ac_exeext
22931 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22932   (eval $ac_link) 2>conftest.er1
22933   ac_status=$?
22934   grep -v '^ *+' conftest.er1 >conftest.err
22935   rm -f conftest.er1
22936   cat conftest.err >&5
22937   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22938   (exit $ac_status); } &&
22939          { ac_try='test -z "$ac_c_werror_flag"
22940                          || test ! -s conftest.err'
22941   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22942   (eval $ac_try) 2>&5
22943   ac_status=$?
22944   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22945   (exit $ac_status); }; } &&
22946          { ac_try='test -s conftest$ac_exeext'
22947   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22948   (eval $ac_try) 2>&5
22949   ac_status=$?
22950   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22951   (exit $ac_status); }; }; then
22952   ac_cv_lib_m___clog=yes
22953 else
22954   echo "$as_me: failed program was:" >&5
22955 sed 's/^/| /' conftest.$ac_ext >&5
22956
22957 ac_cv_lib_m___clog=no
22958 fi
22959 rm -f conftest.err conftest.$ac_objext \
22960       conftest$ac_exeext conftest.$ac_ext
22961 LIBS=$ac_check_lib_save_LIBS
22962 fi
22963 echo "$as_me:$LINENO: result: $ac_cv_lib_m___clog" >&5
22964 echo "${ECHO_T}$ac_cv_lib_m___clog" >&6
22965 if test $ac_cv_lib_m___clog = yes; then
22966
22967 cat >>confdefs.h <<\_ACEOF
22968 #define HAVE_CLOG 1
22969 _ACEOF
22970
22971 fi
22972
22973
22974 # Check for a isfinite macro that works on long doubles.
22975
22976   echo "$as_me:$LINENO: checking whether isfinite is broken" >&5
22977 echo $ECHO_N "checking whether isfinite is broken... $ECHO_C" >&6
22978 if test "${have_broken_isfinite+set}" = set; then
22979   echo $ECHO_N "(cached) $ECHO_C" >&6
22980 else
22981
22982   libgfor_check_for_broken_isfinite_save_LIBS=$LIBS
22983   LIBS="$LIBS -lm"
22984   if test "$cross_compiling" = yes; then
22985
22986 case "${target}" in
22987   hppa*-*-hpux*) have_broken_isfinite=yes ;;
22988   *) have_broken_isfinite=no ;;
22989 esac
22990 else
22991   cat >conftest.$ac_ext <<_ACEOF
22992 /* confdefs.h.  */
22993 _ACEOF
22994 cat confdefs.h >>conftest.$ac_ext
22995 cat >>conftest.$ac_ext <<_ACEOF
22996 /* end confdefs.h.  */
22997
22998 #ifdef HAVE_MATH_H
22999 #include <math.h>
23000 #endif
23001 #include <float.h>
23002 int main ()
23003 {
23004 #ifdef isfinite
23005 #ifdef LDBL_MAX
23006   if (!isfinite(LDBL_MAX)) return 1;
23007 #endif
23008 #ifdef DBL_MAX
23009   if (!isfinite(DBL_MAX)) return 1;
23010 #endif
23011 #endif
23012 return 0;
23013 }
23014 _ACEOF
23015 rm -f conftest$ac_exeext
23016 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23017   (eval $ac_link) 2>&5
23018   ac_status=$?
23019   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23020   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
23021   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23022   (eval $ac_try) 2>&5
23023   ac_status=$?
23024   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23025   (exit $ac_status); }; }; then
23026   have_broken_isfinite=no
23027 else
23028   echo "$as_me: program exited with status $ac_status" >&5
23029 echo "$as_me: failed program was:" >&5
23030 sed 's/^/| /' conftest.$ac_ext >&5
23031
23032 ( exit $ac_status )
23033 have_broken_isfinite=yes
23034 fi
23035 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23036 fi
23037   LIBS=$libgfor_check_for_broken_isfinite_save_LIBS
23038 fi
23039 echo "$as_me:$LINENO: result: $have_broken_isfinite" >&5
23040 echo "${ECHO_T}$have_broken_isfinite" >&6
23041 if test x"$have_broken_isfinite" = xyes; then
23042
23043 cat >>confdefs.h <<\_ACEOF
23044 #define HAVE_BROKEN_ISFINITE 1
23045 _ACEOF
23046
23047 fi
23048
23049 # Check for a isnan macro that works on long doubles.
23050
23051   echo "$as_me:$LINENO: checking whether isnan is broken" >&5
23052 echo $ECHO_N "checking whether isnan is broken... $ECHO_C" >&6
23053 if test "${have_broken_isnan+set}" = set; then
23054   echo $ECHO_N "(cached) $ECHO_C" >&6
23055 else
23056
23057   libgfor_check_for_broken_isnan_save_LIBS=$LIBS
23058   LIBS="$LIBS -lm"
23059   if test "$cross_compiling" = yes; then
23060
23061 case "${target}" in
23062   hppa*-*-hpux*) have_broken_isnan=yes ;;
23063   *) have_broken_isnan=no ;;
23064 esac
23065 else
23066   cat >conftest.$ac_ext <<_ACEOF
23067 /* confdefs.h.  */
23068 _ACEOF
23069 cat confdefs.h >>conftest.$ac_ext
23070 cat >>conftest.$ac_ext <<_ACEOF
23071 /* end confdefs.h.  */
23072
23073 #ifdef HAVE_MATH_H
23074 #include <math.h>
23075 #endif
23076 #include <float.h>
23077 int main ()
23078 {
23079 #ifdef isnan
23080 #ifdef LDBL_MAX
23081   {
23082     long double x;
23083     x = __builtin_nanl ("");
23084     if (!isnan(x)) return 1;
23085     if (isnan(LDBL_MAX)) return 1;
23086 #ifdef NAN
23087     x = (long double) NAN;
23088     if (!isnan(x)) return 1;
23089 #endif
23090   }
23091 #endif
23092 #ifdef DBL_MAX
23093   {
23094     double y;
23095     y = __builtin_nan ("");
23096     if (!isnan(y)) return 1;
23097     if (isnan(DBL_MAX)) return 1;
23098 #ifdef NAN
23099     y = (double) NAN;
23100     if (!isnan(y)) return 1;
23101 #endif
23102   }
23103 #endif
23104 #endif
23105 return 0;
23106 }
23107 _ACEOF
23108 rm -f conftest$ac_exeext
23109 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23110   (eval $ac_link) 2>&5
23111   ac_status=$?
23112   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23113   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
23114   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23115   (eval $ac_try) 2>&5
23116   ac_status=$?
23117   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23118   (exit $ac_status); }; }; then
23119   have_broken_isnan=no
23120 else
23121   echo "$as_me: program exited with status $ac_status" >&5
23122 echo "$as_me: failed program was:" >&5
23123 sed 's/^/| /' conftest.$ac_ext >&5
23124
23125 ( exit $ac_status )
23126 have_broken_isnan=yes
23127 fi
23128 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23129 fi
23130   LIBS=$libgfor_check_for_broken_isnan_save_LIBS
23131 fi
23132 echo "$as_me:$LINENO: result: $have_broken_isnan" >&5
23133 echo "${ECHO_T}$have_broken_isnan" >&6
23134 if test x"$have_broken_isnan" = xyes; then
23135
23136 cat >>confdefs.h <<\_ACEOF
23137 #define HAVE_BROKEN_ISNAN 1
23138 _ACEOF
23139
23140 fi
23141
23142 # Check for a fpclassify macro that works on long doubles.
23143
23144   echo "$as_me:$LINENO: checking whether fpclassify is broken" >&5
23145 echo $ECHO_N "checking whether fpclassify is broken... $ECHO_C" >&6
23146 if test "${have_broken_fpclassify+set}" = set; then
23147   echo $ECHO_N "(cached) $ECHO_C" >&6
23148 else
23149
23150   libgfor_check_for_broken_fpclassify_save_LIBS=$LIBS
23151   LIBS="$LIBS -lm"
23152   if test "$cross_compiling" = yes; then
23153
23154 case "${target}" in
23155   hppa*-*-hpux*) have_broken_fpclassify=yes ;;
23156   *) have_broken_fpclassify=no ;;
23157 esac
23158 else
23159   cat >conftest.$ac_ext <<_ACEOF
23160 /* confdefs.h.  */
23161 _ACEOF
23162 cat confdefs.h >>conftest.$ac_ext
23163 cat >>conftest.$ac_ext <<_ACEOF
23164 /* end confdefs.h.  */
23165
23166 #ifdef HAVE_MATH_H
23167 #include <math.h>
23168 #endif
23169 #include <float.h>
23170 int main ()
23171 {
23172 #ifdef fpclassify
23173 #ifdef LDBL_MAX
23174         if (fpclassify(LDBL_MAX) == FP_NAN
23175             || fpclassify(LDBL_MAX) == FP_INFINITE) return 1;
23176 #endif
23177 #ifdef DBL_MAX
23178         if (fpclassify(DBL_MAX) == FP_NAN
23179             || fpclassify(DBL_MAX) == FP_INFINITE) return 1;
23180 #endif
23181 #endif
23182 return 0;
23183 }
23184 _ACEOF
23185 rm -f conftest$ac_exeext
23186 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23187   (eval $ac_link) 2>&5
23188   ac_status=$?
23189   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23190   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
23191   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23192   (eval $ac_try) 2>&5
23193   ac_status=$?
23194   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23195   (exit $ac_status); }; }; then
23196   have_broken_fpclassify=no
23197 else
23198   echo "$as_me: program exited with status $ac_status" >&5
23199 echo "$as_me: failed program was:" >&5
23200 sed 's/^/| /' conftest.$ac_ext >&5
23201
23202 ( exit $ac_status )
23203 have_broken_fpclassify=yes
23204 fi
23205 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23206 fi
23207   LIBS=$libgfor_check_for_broken_fpclassify_save_LIBS
23208 fi
23209 echo "$as_me:$LINENO: result: $have_broken_fpclassify" >&5
23210 echo "${ECHO_T}$have_broken_fpclassify" >&6
23211 if test x"$have_broken_fpclassify" = xyes; then
23212
23213 cat >>confdefs.h <<\_ACEOF
23214 #define HAVE_BROKEN_FPCLASSIFY 1
23215 _ACEOF
23216
23217 fi
23218
23219 # Check whether the system has a working stat()
23220
23221   echo "$as_me:$LINENO: checking whether the target stat is reliable" >&5
23222 echo $ECHO_N "checking whether the target stat is reliable... $ECHO_C" >&6
23223 if test "${have_working_stat+set}" = set; then
23224   echo $ECHO_N "(cached) $ECHO_C" >&6
23225 else
23226
23227   if test "$cross_compiling" = yes; then
23228
23229 case "${target}" in
23230   *mingw*) have_working_stat=no ;;
23231   *) have_working_stat=yes;;
23232 esac
23233 else
23234   cat >conftest.$ac_ext <<_ACEOF
23235 /* confdefs.h.  */
23236 _ACEOF
23237 cat confdefs.h >>conftest.$ac_ext
23238 cat >>conftest.$ac_ext <<_ACEOF
23239 /* end confdefs.h.  */
23240
23241 #include <stdio.h>
23242 #include <sys/types.h>
23243 #include <sys/stat.h>
23244 #include <unistd.h>
23245
23246 int main ()
23247 {
23248   FILE *f, *g;
23249   struct stat st1, st2;
23250
23251   f = fopen ("foo", "w");
23252   g = fopen ("bar", "w");
23253   if (stat ("foo", &st1) != 0 || stat ("bar", &st2))
23254     return 1;
23255   if (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino)
23256     return 1;
23257   fclose(f);
23258   fclose(g);
23259   return 0;
23260 }
23261 _ACEOF
23262 rm -f conftest$ac_exeext
23263 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23264   (eval $ac_link) 2>&5
23265   ac_status=$?
23266   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23267   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
23268   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23269   (eval $ac_try) 2>&5
23270   ac_status=$?
23271   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23272   (exit $ac_status); }; }; then
23273   have_working_stat=yes
23274 else
23275   echo "$as_me: program exited with status $ac_status" >&5
23276 echo "$as_me: failed program was:" >&5
23277 sed 's/^/| /' conftest.$ac_ext >&5
23278
23279 ( exit $ac_status )
23280 have_working_stat=no
23281 fi
23282 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23283 fi
23284 fi
23285 echo "$as_me:$LINENO: result: $have_working_stat" >&5
23286 echo "${ECHO_T}$have_working_stat" >&6
23287 if test x"$have_working_stat" = xyes; then
23288
23289 cat >>confdefs.h <<\_ACEOF
23290 #define HAVE_WORKING_STAT 1
23291 _ACEOF
23292
23293 fi
23294
23295 # Fallback in case isfinite is not available.
23296 echo "$as_me:$LINENO: checking for finite in -lm" >&5
23297 echo $ECHO_N "checking for finite in -lm... $ECHO_C" >&6
23298 if test "${ac_cv_lib_m_finite+set}" = set; then
23299   echo $ECHO_N "(cached) $ECHO_C" >&6
23300 else
23301   ac_check_lib_save_LIBS=$LIBS
23302 LIBS="-lm  $LIBS"
23303 if test x$gcc_no_link = xyes; then
23304   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23305 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23306    { (exit 1); exit 1; }; }
23307 fi
23308 cat >conftest.$ac_ext <<_ACEOF
23309 /* confdefs.h.  */
23310 _ACEOF
23311 cat confdefs.h >>conftest.$ac_ext
23312 cat >>conftest.$ac_ext <<_ACEOF
23313 /* end confdefs.h.  */
23314
23315 /* Override any gcc2 internal prototype to avoid an error.  */
23316 #ifdef __cplusplus
23317 extern "C"
23318 #endif
23319 /* We use char because int might match the return type of a gcc2
23320    builtin and then its argument prototype would still apply.  */
23321 char finite ();
23322 int
23323 main ()
23324 {
23325 finite ();
23326   ;
23327   return 0;
23328 }
23329 _ACEOF
23330 rm -f conftest.$ac_objext conftest$ac_exeext
23331 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23332   (eval $ac_link) 2>conftest.er1
23333   ac_status=$?
23334   grep -v '^ *+' conftest.er1 >conftest.err
23335   rm -f conftest.er1
23336   cat conftest.err >&5
23337   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23338   (exit $ac_status); } &&
23339          { ac_try='test -z "$ac_c_werror_flag"
23340                          || test ! -s conftest.err'
23341   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23342   (eval $ac_try) 2>&5
23343   ac_status=$?
23344   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23345   (exit $ac_status); }; } &&
23346          { ac_try='test -s conftest$ac_exeext'
23347   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23348   (eval $ac_try) 2>&5
23349   ac_status=$?
23350   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23351   (exit $ac_status); }; }; then
23352   ac_cv_lib_m_finite=yes
23353 else
23354   echo "$as_me: failed program was:" >&5
23355 sed 's/^/| /' conftest.$ac_ext >&5
23356
23357 ac_cv_lib_m_finite=no
23358 fi
23359 rm -f conftest.err conftest.$ac_objext \
23360       conftest$ac_exeext conftest.$ac_ext
23361 LIBS=$ac_check_lib_save_LIBS
23362 fi
23363 echo "$as_me:$LINENO: result: $ac_cv_lib_m_finite" >&5
23364 echo "${ECHO_T}$ac_cv_lib_m_finite" >&6
23365 if test $ac_cv_lib_m_finite = yes; then
23366
23367 cat >>confdefs.h <<\_ACEOF
23368 #define HAVE_FINITE 1
23369 _ACEOF
23370
23371 fi
23372
23373
23374 # Check for GNU libc feenableexcept
23375 echo "$as_me:$LINENO: checking for feenableexcept in -lm" >&5
23376 echo $ECHO_N "checking for feenableexcept in -lm... $ECHO_C" >&6
23377 if test "${ac_cv_lib_m_feenableexcept+set}" = set; then
23378   echo $ECHO_N "(cached) $ECHO_C" >&6
23379 else
23380   ac_check_lib_save_LIBS=$LIBS
23381 LIBS="-lm  $LIBS"
23382 if test x$gcc_no_link = xyes; then
23383   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23384 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23385    { (exit 1); exit 1; }; }
23386 fi
23387 cat >conftest.$ac_ext <<_ACEOF
23388 /* confdefs.h.  */
23389 _ACEOF
23390 cat confdefs.h >>conftest.$ac_ext
23391 cat >>conftest.$ac_ext <<_ACEOF
23392 /* end confdefs.h.  */
23393
23394 /* Override any gcc2 internal prototype to avoid an error.  */
23395 #ifdef __cplusplus
23396 extern "C"
23397 #endif
23398 /* We use char because int might match the return type of a gcc2
23399    builtin and then its argument prototype would still apply.  */
23400 char feenableexcept ();
23401 int
23402 main ()
23403 {
23404 feenableexcept ();
23405   ;
23406   return 0;
23407 }
23408 _ACEOF
23409 rm -f conftest.$ac_objext conftest$ac_exeext
23410 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23411   (eval $ac_link) 2>conftest.er1
23412   ac_status=$?
23413   grep -v '^ *+' conftest.er1 >conftest.err
23414   rm -f conftest.er1
23415   cat conftest.err >&5
23416   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23417   (exit $ac_status); } &&
23418          { ac_try='test -z "$ac_c_werror_flag"
23419                          || test ! -s conftest.err'
23420   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23421   (eval $ac_try) 2>&5
23422   ac_status=$?
23423   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23424   (exit $ac_status); }; } &&
23425          { ac_try='test -s conftest$ac_exeext'
23426   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23427   (eval $ac_try) 2>&5
23428   ac_status=$?
23429   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23430   (exit $ac_status); }; }; then
23431   ac_cv_lib_m_feenableexcept=yes
23432 else
23433   echo "$as_me: failed program was:" >&5
23434 sed 's/^/| /' conftest.$ac_ext >&5
23435
23436 ac_cv_lib_m_feenableexcept=no
23437 fi
23438 rm -f conftest.err conftest.$ac_objext \
23439       conftest$ac_exeext conftest.$ac_ext
23440 LIBS=$ac_check_lib_save_LIBS
23441 fi
23442 echo "$as_me:$LINENO: result: $ac_cv_lib_m_feenableexcept" >&5
23443 echo "${ECHO_T}$ac_cv_lib_m_feenableexcept" >&6
23444 if test $ac_cv_lib_m_feenableexcept = yes; then
23445   have_feenableexcept=yes
23446 cat >>confdefs.h <<\_ACEOF
23447 #define HAVE_FEENABLEEXCEPT 1
23448 _ACEOF
23449
23450 fi
23451
23452
23453 # Check for SysV fpsetmask
23454
23455   echo "$as_me:$LINENO: checking whether fpsetmask is present" >&5
23456 echo $ECHO_N "checking whether fpsetmask is present... $ECHO_C" >&6
23457 if test "${have_fpsetmask+set}" = set; then
23458   echo $ECHO_N "(cached) $ECHO_C" >&6
23459 else
23460
23461     if test x$gcc_no_link = xyes; then
23462   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23463 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23464    { (exit 1); exit 1; }; }
23465 fi
23466 cat >conftest.$ac_ext <<_ACEOF
23467 /* confdefs.h.  */
23468 _ACEOF
23469 cat confdefs.h >>conftest.$ac_ext
23470 cat >>conftest.$ac_ext <<_ACEOF
23471 /* end confdefs.h.  */
23472
23473 #if HAVE_FLOATINGPOINT_H
23474 # include <floatingpoint.h>
23475 #endif /* HAVE_FLOATINGPOINT_H */
23476 #if HAVE_IEEEFP_H
23477 # include <ieeefp.h>
23478 #endif /* HAVE_IEEEFP_H */
23479 int
23480 main ()
23481 {
23482 fpsetmask(0);
23483   ;
23484   return 0;
23485 }
23486 _ACEOF
23487 rm -f conftest.$ac_objext conftest$ac_exeext
23488 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23489   (eval $ac_link) 2>conftest.er1
23490   ac_status=$?
23491   grep -v '^ *+' conftest.er1 >conftest.err
23492   rm -f conftest.er1
23493   cat conftest.err >&5
23494   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23495   (exit $ac_status); } &&
23496          { ac_try='test -z "$ac_c_werror_flag"
23497                          || test ! -s conftest.err'
23498   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23499   (eval $ac_try) 2>&5
23500   ac_status=$?
23501   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23502   (exit $ac_status); }; } &&
23503          { ac_try='test -s conftest$ac_exeext'
23504   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23505   (eval $ac_try) 2>&5
23506   ac_status=$?
23507   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23508   (exit $ac_status); }; }; then
23509   eval "have_fpsetmask=yes"
23510 else
23511   echo "$as_me: failed program was:" >&5
23512 sed 's/^/| /' conftest.$ac_ext >&5
23513
23514 eval "have_fpsetmask=no"
23515 fi
23516 rm -f conftest.err conftest.$ac_objext \
23517       conftest$ac_exeext conftest.$ac_ext
23518
23519 fi
23520 echo "$as_me:$LINENO: result: $have_fpsetmask" >&5
23521 echo "${ECHO_T}$have_fpsetmask" >&6
23522   if test x"$have_fpsetmask" = xyes; then
23523
23524 cat >>confdefs.h <<\_ACEOF
23525 #define HAVE_FPSETMASK 1
23526 _ACEOF
23527
23528   fi
23529
23530
23531 # Check for AIX fp_trap and fp_enable
23532 echo "$as_me:$LINENO: checking for fp_trap" >&5
23533 echo $ECHO_N "checking for fp_trap... $ECHO_C" >&6
23534 if test "${ac_cv_func_fp_trap+set}" = set; then
23535   echo $ECHO_N "(cached) $ECHO_C" >&6
23536 else
23537   if test x$gcc_no_link = xyes; then
23538   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23539 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23540    { (exit 1); exit 1; }; }
23541 fi
23542 cat >conftest.$ac_ext <<_ACEOF
23543 /* confdefs.h.  */
23544 _ACEOF
23545 cat confdefs.h >>conftest.$ac_ext
23546 cat >>conftest.$ac_ext <<_ACEOF
23547 /* end confdefs.h.  */
23548 /* Define fp_trap to an innocuous variant, in case <limits.h> declares fp_trap.
23549    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
23550 #define fp_trap innocuous_fp_trap
23551
23552 /* System header to define __stub macros and hopefully few prototypes,
23553     which can conflict with char fp_trap (); below.
23554     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
23555     <limits.h> exists even on freestanding compilers.  */
23556
23557 #ifdef __STDC__
23558 # include <limits.h>
23559 #else
23560 # include <assert.h>
23561 #endif
23562
23563 #undef fp_trap
23564
23565 /* Override any gcc2 internal prototype to avoid an error.  */
23566 #ifdef __cplusplus
23567 extern "C"
23568 {
23569 #endif
23570 /* We use char because int might match the return type of a gcc2
23571    builtin and then its argument prototype would still apply.  */
23572 char fp_trap ();
23573 /* The GNU C library defines this for functions which it implements
23574     to always fail with ENOSYS.  Some functions are actually named
23575     something starting with __ and the normal name is an alias.  */
23576 #if defined (__stub_fp_trap) || defined (__stub___fp_trap)
23577 choke me
23578 #else
23579 char (*f) () = fp_trap;
23580 #endif
23581 #ifdef __cplusplus
23582 }
23583 #endif
23584
23585 int
23586 main ()
23587 {
23588 return f != fp_trap;
23589   ;
23590   return 0;
23591 }
23592 _ACEOF
23593 rm -f conftest.$ac_objext conftest$ac_exeext
23594 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23595   (eval $ac_link) 2>conftest.er1
23596   ac_status=$?
23597   grep -v '^ *+' conftest.er1 >conftest.err
23598   rm -f conftest.er1
23599   cat conftest.err >&5
23600   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23601   (exit $ac_status); } &&
23602          { ac_try='test -z "$ac_c_werror_flag"
23603                          || test ! -s conftest.err'
23604   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23605   (eval $ac_try) 2>&5
23606   ac_status=$?
23607   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23608   (exit $ac_status); }; } &&
23609          { ac_try='test -s conftest$ac_exeext'
23610   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23611   (eval $ac_try) 2>&5
23612   ac_status=$?
23613   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23614   (exit $ac_status); }; }; then
23615   ac_cv_func_fp_trap=yes
23616 else
23617   echo "$as_me: failed program was:" >&5
23618 sed 's/^/| /' conftest.$ac_ext >&5
23619
23620 ac_cv_func_fp_trap=no
23621 fi
23622 rm -f conftest.err conftest.$ac_objext \
23623       conftest$ac_exeext conftest.$ac_ext
23624 fi
23625 echo "$as_me:$LINENO: result: $ac_cv_func_fp_trap" >&5
23626 echo "${ECHO_T}$ac_cv_func_fp_trap" >&6
23627 if test $ac_cv_func_fp_trap = yes; then
23628   have_fp_trap=yes
23629 cat >>confdefs.h <<\_ACEOF
23630 #define HAVE_FP_TRAP 1
23631 _ACEOF
23632
23633 fi
23634
23635 echo "$as_me:$LINENO: checking for fp_enable" >&5
23636 echo $ECHO_N "checking for fp_enable... $ECHO_C" >&6
23637 if test "${ac_cv_func_fp_enable+set}" = set; then
23638   echo $ECHO_N "(cached) $ECHO_C" >&6
23639 else
23640   if test x$gcc_no_link = xyes; then
23641   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23642 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23643    { (exit 1); exit 1; }; }
23644 fi
23645 cat >conftest.$ac_ext <<_ACEOF
23646 /* confdefs.h.  */
23647 _ACEOF
23648 cat confdefs.h >>conftest.$ac_ext
23649 cat >>conftest.$ac_ext <<_ACEOF
23650 /* end confdefs.h.  */
23651 /* Define fp_enable to an innocuous variant, in case <limits.h> declares fp_enable.
23652    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
23653 #define fp_enable innocuous_fp_enable
23654
23655 /* System header to define __stub macros and hopefully few prototypes,
23656     which can conflict with char fp_enable (); below.
23657     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
23658     <limits.h> exists even on freestanding compilers.  */
23659
23660 #ifdef __STDC__
23661 # include <limits.h>
23662 #else
23663 # include <assert.h>
23664 #endif
23665
23666 #undef fp_enable
23667
23668 /* Override any gcc2 internal prototype to avoid an error.  */
23669 #ifdef __cplusplus
23670 extern "C"
23671 {
23672 #endif
23673 /* We use char because int might match the return type of a gcc2
23674    builtin and then its argument prototype would still apply.  */
23675 char fp_enable ();
23676 /* The GNU C library defines this for functions which it implements
23677     to always fail with ENOSYS.  Some functions are actually named
23678     something starting with __ and the normal name is an alias.  */
23679 #if defined (__stub_fp_enable) || defined (__stub___fp_enable)
23680 choke me
23681 #else
23682 char (*f) () = fp_enable;
23683 #endif
23684 #ifdef __cplusplus
23685 }
23686 #endif
23687
23688 int
23689 main ()
23690 {
23691 return f != fp_enable;
23692   ;
23693   return 0;
23694 }
23695 _ACEOF
23696 rm -f conftest.$ac_objext conftest$ac_exeext
23697 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23698   (eval $ac_link) 2>conftest.er1
23699   ac_status=$?
23700   grep -v '^ *+' conftest.er1 >conftest.err
23701   rm -f conftest.er1
23702   cat conftest.err >&5
23703   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23704   (exit $ac_status); } &&
23705          { ac_try='test -z "$ac_c_werror_flag"
23706                          || test ! -s conftest.err'
23707   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23708   (eval $ac_try) 2>&5
23709   ac_status=$?
23710   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23711   (exit $ac_status); }; } &&
23712          { ac_try='test -s conftest$ac_exeext'
23713   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23714   (eval $ac_try) 2>&5
23715   ac_status=$?
23716   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23717   (exit $ac_status); }; }; then
23718   ac_cv_func_fp_enable=yes
23719 else
23720   echo "$as_me: failed program was:" >&5
23721 sed 's/^/| /' conftest.$ac_ext >&5
23722
23723 ac_cv_func_fp_enable=no
23724 fi
23725 rm -f conftest.err conftest.$ac_objext \
23726       conftest$ac_exeext conftest.$ac_ext
23727 fi
23728 echo "$as_me:$LINENO: result: $ac_cv_func_fp_enable" >&5
23729 echo "${ECHO_T}$ac_cv_func_fp_enable" >&6
23730 if test $ac_cv_func_fp_enable = yes; then
23731   have_fp_enable=yes
23732 cat >>confdefs.h <<\_ACEOF
23733 #define HAVE_FP_ENABLE 1
23734 _ACEOF
23735
23736 fi
23737
23738
23739 # Runs configure.host to set up necessary host-dependent shell variables.
23740 # We then display a message about it, and propagate them through the
23741 # build chain.
23742 . ${srcdir}/configure.host
23743 { echo "$as_me:$LINENO: FPU dependent file will be ${fpu_host}.h" >&5
23744 echo "$as_me: FPU dependent file will be ${fpu_host}.h" >&6;}
23745 FPU_HOST_HEADER=config/${fpu_host}.h
23746
23747
23748 # Attempt to assert that the target is of common type in case we don't
23749 # have C99 integer types at all.
23750
23751   echo "$as_me:$LINENO: checking whether the target is ILP32" >&5
23752 echo $ECHO_N "checking whether the target is ILP32... $ECHO_C" >&6
23753 if test "${target_ilp32+set}" = set; then
23754   echo $ECHO_N "(cached) $ECHO_C" >&6
23755 else
23756
23757   save_CFLAGS="$CFLAGS"
23758   CFLAGS="-O2"
23759   if test x$gcc_no_link = xyes; then
23760   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23761 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23762    { (exit 1); exit 1; }; }
23763 fi
23764 cat >conftest.$ac_ext <<_ACEOF
23765 /* confdefs.h.  */
23766 _ACEOF
23767 cat confdefs.h >>conftest.$ac_ext
23768 cat >>conftest.$ac_ext <<_ACEOF
23769 /* end confdefs.h.  */
23770
23771 int
23772 main ()
23773 {
23774
23775 if (sizeof(int) == 4 && sizeof(long) == 4 && sizeof(void *) == 4)
23776   ;
23777 else
23778   undefined_function ();
23779
23780   ;
23781   return 0;
23782 }
23783 _ACEOF
23784 rm -f conftest.$ac_objext conftest$ac_exeext
23785 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23786   (eval $ac_link) 2>conftest.er1
23787   ac_status=$?
23788   grep -v '^ *+' conftest.er1 >conftest.err
23789   rm -f conftest.er1
23790   cat conftest.err >&5
23791   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23792   (exit $ac_status); } &&
23793          { ac_try='test -z "$ac_c_werror_flag"
23794                          || test ! -s conftest.err'
23795   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23796   (eval $ac_try) 2>&5
23797   ac_status=$?
23798   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23799   (exit $ac_status); }; } &&
23800          { ac_try='test -s conftest$ac_exeext'
23801   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23802   (eval $ac_try) 2>&5
23803   ac_status=$?
23804   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23805   (exit $ac_status); }; }; then
23806   target_ilp32=yes
23807 else
23808   echo "$as_me: failed program was:" >&5
23809 sed 's/^/| /' conftest.$ac_ext >&5
23810
23811 target_ilp32=no
23812 fi
23813 rm -f conftest.err conftest.$ac_objext \
23814       conftest$ac_exeext conftest.$ac_ext
23815   CFLAGS="$save_CFLAGS"
23816 fi
23817 echo "$as_me:$LINENO: result: $target_ilp32" >&5
23818 echo "${ECHO_T}$target_ilp32" >&6
23819   if test $target_ilp32 = yes; then
23820
23821 cat >>confdefs.h <<\_ACEOF
23822 #define TARGET_ILP32 1
23823 _ACEOF
23824
23825   fi
23826
23827
23828 # Check out attribute support.
23829
23830   echo "$as_me:$LINENO: checking whether the target supports hidden visibility" >&5
23831 echo $ECHO_N "checking whether the target supports hidden visibility... $ECHO_C" >&6
23832 if test "${have_attribute_visibility+set}" = set; then
23833   echo $ECHO_N "(cached) $ECHO_C" >&6
23834 else
23835
23836   save_CFLAGS="$CFLAGS"
23837   CFLAGS="$CFLAGS -Werror"
23838   cat >conftest.$ac_ext <<_ACEOF
23839 /* confdefs.h.  */
23840 _ACEOF
23841 cat confdefs.h >>conftest.$ac_ext
23842 cat >>conftest.$ac_ext <<_ACEOF
23843 /* end confdefs.h.  */
23844 void __attribute__((visibility("hidden"))) foo(void) { }
23845 int
23846 main ()
23847 {
23848
23849   ;
23850   return 0;
23851 }
23852 _ACEOF
23853 rm -f conftest.$ac_objext
23854 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
23855   (eval $ac_compile) 2>conftest.er1
23856   ac_status=$?
23857   grep -v '^ *+' conftest.er1 >conftest.err
23858   rm -f conftest.er1
23859   cat conftest.err >&5
23860   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23861   (exit $ac_status); } &&
23862          { ac_try='test -z "$ac_c_werror_flag"
23863                          || test ! -s conftest.err'
23864   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23865   (eval $ac_try) 2>&5
23866   ac_status=$?
23867   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23868   (exit $ac_status); }; } &&
23869          { ac_try='test -s conftest.$ac_objext'
23870   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23871   (eval $ac_try) 2>&5
23872   ac_status=$?
23873   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23874   (exit $ac_status); }; }; then
23875   have_attribute_visibility=yes
23876 else
23877   echo "$as_me: failed program was:" >&5
23878 sed 's/^/| /' conftest.$ac_ext >&5
23879
23880 have_attribute_visibility=no
23881 fi
23882 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
23883   CFLAGS="$save_CFLAGS"
23884 fi
23885 echo "$as_me:$LINENO: result: $have_attribute_visibility" >&5
23886 echo "${ECHO_T}$have_attribute_visibility" >&6
23887   if test $have_attribute_visibility = yes; then
23888
23889 cat >>confdefs.h <<\_ACEOF
23890 #define HAVE_ATTRIBUTE_VISIBILITY 1
23891 _ACEOF
23892
23893   fi
23894
23895   echo "$as_me:$LINENO: checking whether the target supports dllexport" >&5
23896 echo $ECHO_N "checking whether the target supports dllexport... $ECHO_C" >&6
23897 if test "${have_attribute_dllexport+set}" = set; then
23898   echo $ECHO_N "(cached) $ECHO_C" >&6
23899 else
23900
23901   save_CFLAGS="$CFLAGS"
23902   CFLAGS="$CFLAGS -Werror"
23903   cat >conftest.$ac_ext <<_ACEOF
23904 /* confdefs.h.  */
23905 _ACEOF
23906 cat confdefs.h >>conftest.$ac_ext
23907 cat >>conftest.$ac_ext <<_ACEOF
23908 /* end confdefs.h.  */
23909 void __attribute__((dllexport)) foo(void) { }
23910 int
23911 main ()
23912 {
23913
23914   ;
23915   return 0;
23916 }
23917 _ACEOF
23918 rm -f conftest.$ac_objext
23919 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
23920   (eval $ac_compile) 2>conftest.er1
23921   ac_status=$?
23922   grep -v '^ *+' conftest.er1 >conftest.err
23923   rm -f conftest.er1
23924   cat conftest.err >&5
23925   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23926   (exit $ac_status); } &&
23927          { ac_try='test -z "$ac_c_werror_flag"
23928                          || test ! -s conftest.err'
23929   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23930   (eval $ac_try) 2>&5
23931   ac_status=$?
23932   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23933   (exit $ac_status); }; } &&
23934          { ac_try='test -s conftest.$ac_objext'
23935   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23936   (eval $ac_try) 2>&5
23937   ac_status=$?
23938   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23939   (exit $ac_status); }; }; then
23940   have_attribute_dllexport=yes
23941 else
23942   echo "$as_me: failed program was:" >&5
23943 sed 's/^/| /' conftest.$ac_ext >&5
23944
23945 have_attribute_dllexport=no
23946 fi
23947 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
23948   CFLAGS="$save_CFLAGS"
23949 fi
23950 echo "$as_me:$LINENO: result: $have_attribute_dllexport" >&5
23951 echo "${ECHO_T}$have_attribute_dllexport" >&6
23952   if test $have_attribute_dllexport = yes; then
23953
23954 cat >>confdefs.h <<\_ACEOF
23955 #define HAVE_ATTRIBUTE_DLLEXPORT 1
23956 _ACEOF
23957
23958   fi
23959
23960   echo "$as_me:$LINENO: checking whether the target supports symbol aliases" >&5
23961 echo $ECHO_N "checking whether the target supports symbol aliases... $ECHO_C" >&6
23962 if test "${have_attribute_alias+set}" = set; then
23963   echo $ECHO_N "(cached) $ECHO_C" >&6
23964 else
23965
23966   if test x$gcc_no_link = xyes; then
23967   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23968 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23969    { (exit 1); exit 1; }; }
23970 fi
23971 cat >conftest.$ac_ext <<_ACEOF
23972 /* confdefs.h.  */
23973 _ACEOF
23974 cat confdefs.h >>conftest.$ac_ext
23975 cat >>conftest.$ac_ext <<_ACEOF
23976 /* end confdefs.h.  */
23977
23978 void foo(void) { }
23979 extern void bar(void) __attribute__((alias("foo")));
23980 int
23981 main ()
23982 {
23983 bar();
23984   ;
23985   return 0;
23986 }
23987 _ACEOF
23988 rm -f conftest.$ac_objext conftest$ac_exeext
23989 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23990   (eval $ac_link) 2>conftest.er1
23991   ac_status=$?
23992   grep -v '^ *+' conftest.er1 >conftest.err
23993   rm -f conftest.er1
23994   cat conftest.err >&5
23995   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23996   (exit $ac_status); } &&
23997          { ac_try='test -z "$ac_c_werror_flag"
23998                          || test ! -s conftest.err'
23999   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24000   (eval $ac_try) 2>&5
24001   ac_status=$?
24002   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24003   (exit $ac_status); }; } &&
24004          { ac_try='test -s conftest$ac_exeext'
24005   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24006   (eval $ac_try) 2>&5
24007   ac_status=$?
24008   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24009   (exit $ac_status); }; }; then
24010   have_attribute_alias=yes
24011 else
24012   echo "$as_me: failed program was:" >&5
24013 sed 's/^/| /' conftest.$ac_ext >&5
24014
24015 have_attribute_alias=no
24016 fi
24017 rm -f conftest.err conftest.$ac_objext \
24018       conftest$ac_exeext conftest.$ac_ext
24019 fi
24020 echo "$as_me:$LINENO: result: $have_attribute_alias" >&5
24021 echo "${ECHO_T}$have_attribute_alias" >&6
24022   if test $have_attribute_alias = yes; then
24023
24024 cat >>confdefs.h <<\_ACEOF
24025 #define HAVE_ATTRIBUTE_ALIAS 1
24026 _ACEOF
24027
24028   fi
24029
24030 # Check out sync builtins support.
24031
24032   echo "$as_me:$LINENO: checking whether the target supports __sync_fetch_and_add" >&5
24033 echo $ECHO_N "checking whether the target supports __sync_fetch_and_add... $ECHO_C" >&6
24034 if test "${have_sync_fetch_and_add+set}" = set; then
24035   echo $ECHO_N "(cached) $ECHO_C" >&6
24036 else
24037
24038   if test x$gcc_no_link = xyes; then
24039   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
24040 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
24041    { (exit 1); exit 1; }; }
24042 fi
24043 cat >conftest.$ac_ext <<_ACEOF
24044 /* confdefs.h.  */
24045 _ACEOF
24046 cat confdefs.h >>conftest.$ac_ext
24047 cat >>conftest.$ac_ext <<_ACEOF
24048 /* end confdefs.h.  */
24049 int foovar = 0;
24050 int
24051 main ()
24052 {
24053
24054 if (foovar <= 0) return __sync_fetch_and_add (&foovar, 1);
24055 if (foovar > 10) return __sync_add_and_fetch (&foovar, -1);
24056   ;
24057   return 0;
24058 }
24059 _ACEOF
24060 rm -f conftest.$ac_objext conftest$ac_exeext
24061 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
24062   (eval $ac_link) 2>conftest.er1
24063   ac_status=$?
24064   grep -v '^ *+' conftest.er1 >conftest.err
24065   rm -f conftest.er1
24066   cat conftest.err >&5
24067   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24068   (exit $ac_status); } &&
24069          { ac_try='test -z "$ac_c_werror_flag"
24070                          || test ! -s conftest.err'
24071   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24072   (eval $ac_try) 2>&5
24073   ac_status=$?
24074   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24075   (exit $ac_status); }; } &&
24076          { ac_try='test -s conftest$ac_exeext'
24077   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24078   (eval $ac_try) 2>&5
24079   ac_status=$?
24080   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24081   (exit $ac_status); }; }; then
24082   have_sync_fetch_and_add=yes
24083 else
24084   echo "$as_me: failed program was:" >&5
24085 sed 's/^/| /' conftest.$ac_ext >&5
24086
24087 have_sync_fetch_and_add=no
24088 fi
24089 rm -f conftest.err conftest.$ac_objext \
24090       conftest$ac_exeext conftest.$ac_ext
24091 fi
24092 echo "$as_me:$LINENO: result: $have_sync_fetch_and_add" >&5
24093 echo "${ECHO_T}$have_sync_fetch_and_add" >&6
24094   if test $have_sync_fetch_and_add = yes; then
24095
24096 cat >>confdefs.h <<\_ACEOF
24097 #define HAVE_SYNC_FETCH_AND_ADD 1
24098 _ACEOF
24099
24100   fi
24101
24102 # Check out thread support.
24103
24104   echo "$as_me:$LINENO: checking configured target thread model" >&5
24105 echo $ECHO_N "checking configured target thread model... $ECHO_C" >&6
24106 if test "${target_thread_file+set}" = set; then
24107   echo $ECHO_N "(cached) $ECHO_C" >&6
24108 else
24109
24110 target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`
24111 fi
24112 echo "$as_me:$LINENO: result: $target_thread_file" >&5
24113 echo "${ECHO_T}$target_thread_file" >&6
24114
24115   if test $target_thread_file != single; then
24116
24117 cat >>confdefs.h <<\_ACEOF
24118 #define HAVE_GTHR_DEFAULT 1
24119 _ACEOF
24120
24121   fi
24122
24123 # Check out #pragma weak.
24124
24125   echo "$as_me:$LINENO: checking whether pragma weak works" >&5
24126 echo $ECHO_N "checking whether pragma weak works... $ECHO_C" >&6
24127 if test "${have_pragma_weak+set}" = set; then
24128   echo $ECHO_N "(cached) $ECHO_C" >&6
24129 else
24130
24131   gfor_save_CFLAGS="$CFLAGS"
24132   CFLAGS="$CFLAGS -Wunknown-pragmas"
24133   cat >conftest.$ac_ext <<_ACEOF
24134 /* confdefs.h.  */
24135 _ACEOF
24136 cat confdefs.h >>conftest.$ac_ext
24137 cat >>conftest.$ac_ext <<_ACEOF
24138 /* end confdefs.h.  */
24139 void foo (void);
24140 #pragma weak foo
24141 int
24142 main ()
24143 {
24144 if (foo) foo ();
24145   ;
24146   return 0;
24147 }
24148 _ACEOF
24149 rm -f conftest.$ac_objext
24150 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
24151   (eval $ac_compile) 2>conftest.er1
24152   ac_status=$?
24153   grep -v '^ *+' conftest.er1 >conftest.err
24154   rm -f conftest.er1
24155   cat conftest.err >&5
24156   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24157   (exit $ac_status); } &&
24158          { ac_try='test -z "$ac_c_werror_flag"
24159                          || test ! -s conftest.err'
24160   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24161   (eval $ac_try) 2>&5
24162   ac_status=$?
24163   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24164   (exit $ac_status); }; } &&
24165          { ac_try='test -s conftest.$ac_objext'
24166   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24167   (eval $ac_try) 2>&5
24168   ac_status=$?
24169   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24170   (exit $ac_status); }; }; then
24171   have_pragma_weak=yes
24172 else
24173   echo "$as_me: failed program was:" >&5
24174 sed 's/^/| /' conftest.$ac_ext >&5
24175
24176 have_pragma_weak=no
24177 fi
24178 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
24179 fi
24180 echo "$as_me:$LINENO: result: $have_pragma_weak" >&5
24181 echo "${ECHO_T}$have_pragma_weak" >&6
24182   if test $have_pragma_weak = yes; then
24183
24184 cat >>confdefs.h <<\_ACEOF
24185 #define SUPPORTS_WEAK 1
24186 _ACEOF
24187
24188   fi
24189   case "$host" in
24190     *-*-darwin* | *-*-hpux* | *-*-cygwin*)
24191
24192 cat >>confdefs.h <<\_ACEOF
24193 #define GTHREAD_USE_WEAK 0
24194 _ACEOF
24195
24196       ;;
24197   esac
24198
24199 # Various other checks on target
24200
24201   echo "$as_me:$LINENO: checking whether the target can unlink an open file" >&5
24202 echo $ECHO_N "checking whether the target can unlink an open file... $ECHO_C" >&6
24203 if test "${have_unlink_open_file+set}" = set; then
24204   echo $ECHO_N "(cached) $ECHO_C" >&6
24205 else
24206
24207   if test "$cross_compiling" = yes; then
24208
24209 case "${target}" in
24210   *mingw*) have_unlink_open_file=no ;;
24211   *) have_unlink_open_file=yes;;
24212 esac
24213 else
24214   cat >conftest.$ac_ext <<_ACEOF
24215 /* confdefs.h.  */
24216 _ACEOF
24217 cat confdefs.h >>conftest.$ac_ext
24218 cat >>conftest.$ac_ext <<_ACEOF
24219 /* end confdefs.h.  */
24220
24221 #include <errno.h>
24222 #include <fcntl.h>
24223 #include <unistd.h>
24224 #include <sys/stat.h>
24225
24226 int main ()
24227 {
24228   int fd;
24229
24230   fd = open ("testfile", O_RDWR | O_CREAT, S_IWRITE | S_IREAD);
24231   if (fd <= 0)
24232     return 0;
24233   if (unlink ("testfile") == -1)
24234     return 1;
24235   write (fd, "This is a test\n", 15);
24236   close (fd);
24237
24238   if (open ("testfile", O_RDONLY, S_IWRITE | S_IREAD) == -1 && errno == ENOENT)
24239     return 0;
24240   else
24241     return 1;
24242 }
24243 _ACEOF
24244 rm -f conftest$ac_exeext
24245 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
24246   (eval $ac_link) 2>&5
24247   ac_status=$?
24248   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24249   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
24250   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24251   (eval $ac_try) 2>&5
24252   ac_status=$?
24253   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24254   (exit $ac_status); }; }; then
24255   have_unlink_open_file=yes
24256 else
24257   echo "$as_me: program exited with status $ac_status" >&5
24258 echo "$as_me: failed program was:" >&5
24259 sed 's/^/| /' conftest.$ac_ext >&5
24260
24261 ( exit $ac_status )
24262 have_unlink_open_file=no
24263 fi
24264 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
24265 fi
24266 fi
24267 echo "$as_me:$LINENO: result: $have_unlink_open_file" >&5
24268 echo "${ECHO_T}$have_unlink_open_file" >&6
24269 if test x"$have_unlink_open_file" = xyes; then
24270
24271 cat >>confdefs.h <<\_ACEOF
24272 #define HAVE_UNLINK_OPEN_FILE 1
24273 _ACEOF
24274
24275 fi
24276
24277 # Check whether line terminator is LF or CRLF
24278
24279   echo "$as_me:$LINENO: checking whether the target has CRLF as line terminator" >&5
24280 echo $ECHO_N "checking whether the target has CRLF as line terminator... $ECHO_C" >&6
24281 if test "${have_crlf+set}" = set; then
24282   echo $ECHO_N "(cached) $ECHO_C" >&6
24283 else
24284
24285   if test "$cross_compiling" = yes; then
24286
24287 case "${target}" in
24288   *mingw*) have_crlf=yes ;;
24289   *) have_crlf=no;;
24290 esac
24291 else
24292   cat >conftest.$ac_ext <<_ACEOF
24293 /* confdefs.h.  */
24294 _ACEOF
24295 cat confdefs.h >>conftest.$ac_ext
24296 cat >>conftest.$ac_ext <<_ACEOF
24297 /* end confdefs.h.  */
24298
24299 /* This test program should exit with status 0 if system uses a CRLF as
24300    line terminator, and status 1 otherwise.
24301    Since it is used to check for mingw systems, and should return 0 in any
24302    other case, in case of a failure we will not use CRLF.  */
24303 #include <sys/stat.h>
24304 #include <stdlib.h>
24305 #include <fcntl.h>
24306 #include <stdio.h>
24307
24308 int main ()
24309 {
24310 #ifndef O_BINARY
24311   exit(1);
24312 #else
24313   int fd, bytes;
24314   char buff[5];
24315
24316   fd = open ("foo", O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
24317   if (fd < 0)
24318     exit(1);
24319   if (write (fd, "\n", 1) < 0)
24320     perror ("write");
24321
24322   close (fd);
24323
24324   if ((fd = open ("foo", O_RDONLY | O_BINARY, S_IRWXU)) < 0)
24325     exit(1);
24326   bytes = read (fd, buff, 5);
24327   if (bytes == 2 && buff[0] == '\r' && buff[1] == '\n')
24328     exit(0);
24329   else
24330     exit(1);
24331 #endif
24332 }
24333 _ACEOF
24334 rm -f conftest$ac_exeext
24335 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
24336   (eval $ac_link) 2>&5
24337   ac_status=$?
24338   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24339   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
24340   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24341   (eval $ac_try) 2>&5
24342   ac_status=$?
24343   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24344   (exit $ac_status); }; }; then
24345   have_crlf=yes
24346 else
24347   echo "$as_me: program exited with status $ac_status" >&5
24348 echo "$as_me: failed program was:" >&5
24349 sed 's/^/| /' conftest.$ac_ext >&5
24350
24351 ( exit $ac_status )
24352 have_crlf=no
24353 fi
24354 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
24355 fi
24356 fi
24357 echo "$as_me:$LINENO: result: $have_crlf" >&5
24358 echo "${ECHO_T}$have_crlf" >&6
24359 if test x"$have_crlf" = xyes; then
24360
24361 cat >>confdefs.h <<\_ACEOF
24362 #define HAVE_CRLF 1
24363 _ACEOF
24364
24365 fi
24366
24367 cat >confcache <<\_ACEOF
24368 # This file is a shell script that caches the results of configure
24369 # tests run on this system so they can be shared between configure
24370 # scripts and configure runs, see configure's option --config-cache.
24371 # It is not useful on other systems.  If it contains results you don't
24372 # want to keep, you may remove or edit it.
24373 #
24374 # config.status only pays attention to the cache file if you give it
24375 # the --recheck option to rerun configure.
24376 #
24377 # `ac_cv_env_foo' variables (set or unset) will be overridden when
24378 # loading this file, other *unset* `ac_cv_foo' will be assigned the
24379 # following values.
24380
24381 _ACEOF
24382
24383 # The following way of writing the cache mishandles newlines in values,
24384 # but we know of no workaround that is simple, portable, and efficient.
24385 # So, don't put newlines in cache variables' values.
24386 # Ultrix sh set writes to stderr and can't be redirected directly,
24387 # and sets the high bit in the cache file unless we assign to the vars.
24388 {
24389   (set) 2>&1 |
24390     case `(ac_space=' '; set | grep ac_space) 2>&1` in
24391     *ac_space=\ *)
24392       # `set' does not quote correctly, so add quotes (double-quote
24393       # substitution turns \\\\ into \\, and sed turns \\ into \).
24394       sed -n \
24395         "s/'/'\\\\''/g;
24396           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
24397       ;;
24398     *)
24399       # `set' quotes correctly as required by POSIX, so do not add quotes.
24400       sed -n \
24401         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
24402       ;;
24403     esac;
24404 } |
24405   sed '
24406      t clear
24407      : clear
24408      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
24409      t end
24410      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
24411      : end' >>confcache
24412 if diff $cache_file confcache >/dev/null 2>&1; then :; else
24413   if test -w $cache_file; then
24414     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
24415     cat confcache >$cache_file
24416   else
24417     echo "not updating unwritable cache $cache_file"
24418   fi
24419 fi
24420 rm -f confcache
24421
24422 if test ${multilib} = yes; then
24423   multilib_arg="--enable-multilib"
24424 else
24425   multilib_arg=
24426 fi
24427
24428 # Write our Makefile.
24429           ac_config_files="$ac_config_files Makefile"
24430
24431 cat >confcache <<\_ACEOF
24432 # This file is a shell script that caches the results of configure
24433 # tests run on this system so they can be shared between configure
24434 # scripts and configure runs, see configure's option --config-cache.
24435 # It is not useful on other systems.  If it contains results you don't
24436 # want to keep, you may remove or edit it.
24437 #
24438 # config.status only pays attention to the cache file if you give it
24439 # the --recheck option to rerun configure.
24440 #
24441 # `ac_cv_env_foo' variables (set or unset) will be overridden when
24442 # loading this file, other *unset* `ac_cv_foo' will be assigned the
24443 # following values.
24444
24445 _ACEOF
24446
24447 # The following way of writing the cache mishandles newlines in values,
24448 # but we know of no workaround that is simple, portable, and efficient.
24449 # So, don't put newlines in cache variables' values.
24450 # Ultrix sh set writes to stderr and can't be redirected directly,
24451 # and sets the high bit in the cache file unless we assign to the vars.
24452 {
24453   (set) 2>&1 |
24454     case `(ac_space=' '; set | grep ac_space) 2>&1` in
24455     *ac_space=\ *)
24456       # `set' does not quote correctly, so add quotes (double-quote
24457       # substitution turns \\\\ into \\, and sed turns \\ into \).
24458       sed -n \
24459         "s/'/'\\\\''/g;
24460           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
24461       ;;
24462     *)
24463       # `set' quotes correctly as required by POSIX, so do not add quotes.
24464       sed -n \
24465         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
24466       ;;
24467     esac;
24468 } |
24469   sed '
24470      t clear
24471      : clear
24472      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
24473      t end
24474      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
24475      : end' >>confcache
24476 if diff $cache_file confcache >/dev/null 2>&1; then :; else
24477   if test -w $cache_file; then
24478     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
24479     cat confcache >$cache_file
24480   else
24481     echo "not updating unwritable cache $cache_file"
24482   fi
24483 fi
24484 rm -f confcache
24485
24486 test "x$prefix" = xNONE && prefix=$ac_default_prefix
24487 # Let make expand exec_prefix.
24488 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
24489
24490 # VPATH may cause trouble with some makes, so we remove $(srcdir),
24491 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
24492 # trailing colons and then remove the whole line if VPATH becomes empty
24493 # (actually we leave an empty line to preserve line numbers).
24494 if test "x$srcdir" = x.; then
24495   ac_vpsub='/^[  ]*VPATH[        ]*=/{
24496 s/:*\$(srcdir):*/:/;
24497 s/:*\${srcdir}:*/:/;
24498 s/:*@srcdir@:*/:/;
24499 s/^\([^=]*=[     ]*\):*/\1/;
24500 s/:*$//;
24501 s/^[^=]*=[       ]*$//;
24502 }'
24503 fi
24504
24505 DEFS=-DHAVE_CONFIG_H
24506
24507 ac_libobjs=
24508 ac_ltlibobjs=
24509 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
24510   # 1. Remove the extension, and $U if already installed.
24511   ac_i=`echo "$ac_i" |
24512          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
24513   # 2. Add them.
24514   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
24515   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
24516 done
24517 LIBOBJS=$ac_libobjs
24518
24519 LTLIBOBJS=$ac_ltlibobjs
24520
24521
24522 if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then
24523   { { echo "$as_me:$LINENO: error: conditional \"MAINTAINER_MODE\" was never defined.
24524 Usually this means the macro was only invoked conditionally." >&5
24525 echo "$as_me: error: conditional \"MAINTAINER_MODE\" was never defined.
24526 Usually this means the macro was only invoked conditionally." >&2;}
24527    { (exit 1); exit 1; }; }
24528 fi
24529 if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
24530   { { echo "$as_me:$LINENO: error: conditional \"AMDEP\" was never defined.
24531 Usually this means the macro was only invoked conditionally." >&5
24532 echo "$as_me: error: conditional \"AMDEP\" was never defined.
24533 Usually this means the macro was only invoked conditionally." >&2;}
24534    { (exit 1); exit 1; }; }
24535 fi
24536 if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
24537   { { echo "$as_me:$LINENO: error: conditional \"am__fastdepCC\" was never defined.
24538 Usually this means the macro was only invoked conditionally." >&5
24539 echo "$as_me: error: conditional \"am__fastdepCC\" was never defined.
24540 Usually this means the macro was only invoked conditionally." >&2;}
24541    { (exit 1); exit 1; }; }
24542 fi
24543
24544 : ${CONFIG_STATUS=./config.status}
24545 ac_clean_files_save=$ac_clean_files
24546 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
24547 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
24548 echo "$as_me: creating $CONFIG_STATUS" >&6;}
24549 cat >$CONFIG_STATUS <<_ACEOF
24550 #! $SHELL
24551 # Generated by $as_me.
24552 # Run this file to recreate the current configuration.
24553 # Compiler output produced by configure, useful for debugging
24554 # configure, is in config.log if it exists.
24555
24556 debug=false
24557 ac_cs_recheck=false
24558 ac_cs_silent=false
24559 SHELL=\${CONFIG_SHELL-$SHELL}
24560 _ACEOF
24561
24562 cat >>$CONFIG_STATUS <<\_ACEOF
24563 ## --------------------- ##
24564 ## M4sh Initialization.  ##
24565 ## --------------------- ##
24566
24567 # Be Bourne compatible
24568 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
24569   emulate sh
24570   NULLCMD=:
24571   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
24572   # is contrary to our usage.  Disable this feature.
24573   alias -g '${1+"$@"}'='"$@"'
24574 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
24575   set -o posix
24576 fi
24577 DUALCASE=1; export DUALCASE # for MKS sh
24578
24579 # Support unset when possible.
24580 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
24581   as_unset=unset
24582 else
24583   as_unset=false
24584 fi
24585
24586
24587 # Work around bugs in pre-3.0 UWIN ksh.
24588 $as_unset ENV MAIL MAILPATH
24589 PS1='$ '
24590 PS2='> '
24591 PS4='+ '
24592
24593 # NLS nuisances.
24594 for as_var in \
24595   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
24596   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
24597   LC_TELEPHONE LC_TIME
24598 do
24599   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
24600     eval $as_var=C; export $as_var
24601   else
24602     $as_unset $as_var
24603   fi
24604 done
24605
24606 # Required to use basename.
24607 if expr a : '\(a\)' >/dev/null 2>&1; then
24608   as_expr=expr
24609 else
24610   as_expr=false
24611 fi
24612
24613 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
24614   as_basename=basename
24615 else
24616   as_basename=false
24617 fi
24618
24619
24620 # Name of the executable.
24621 as_me=`$as_basename "$0" ||
24622 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
24623          X"$0" : 'X\(//\)$' \| \
24624          X"$0" : 'X\(/\)$' \| \
24625          .     : '\(.\)' 2>/dev/null ||
24626 echo X/"$0" |
24627     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
24628           /^X\/\(\/\/\)$/{ s//\1/; q; }
24629           /^X\/\(\/\).*/{ s//\1/; q; }
24630           s/.*/./; q'`
24631
24632
24633 # PATH needs CR, and LINENO needs CR and PATH.
24634 # Avoid depending upon Character Ranges.
24635 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
24636 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
24637 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
24638 as_cr_digits='0123456789'
24639 as_cr_alnum=$as_cr_Letters$as_cr_digits
24640
24641 # The user is always right.
24642 if test "${PATH_SEPARATOR+set}" != set; then
24643   echo "#! /bin/sh" >conf$$.sh
24644   echo  "exit 0"   >>conf$$.sh
24645   chmod +x conf$$.sh
24646   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
24647     PATH_SEPARATOR=';'
24648   else
24649     PATH_SEPARATOR=:
24650   fi
24651   rm -f conf$$.sh
24652 fi
24653
24654
24655   as_lineno_1=$LINENO
24656   as_lineno_2=$LINENO
24657   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
24658   test "x$as_lineno_1" != "x$as_lineno_2" &&
24659   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
24660   # Find who we are.  Look in the path if we contain no path at all
24661   # relative or not.
24662   case $0 in
24663     *[\\/]* ) as_myself=$0 ;;
24664     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24665 for as_dir in $PATH
24666 do
24667   IFS=$as_save_IFS
24668   test -z "$as_dir" && as_dir=.
24669   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
24670 done
24671
24672        ;;
24673   esac
24674   # We did not find ourselves, most probably we were run as `sh COMMAND'
24675   # in which case we are not to be found in the path.
24676   if test "x$as_myself" = x; then
24677     as_myself=$0
24678   fi
24679   if test ! -f "$as_myself"; then
24680     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
24681 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
24682    { (exit 1); exit 1; }; }
24683   fi
24684   case $CONFIG_SHELL in
24685   '')
24686     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24687 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
24688 do
24689   IFS=$as_save_IFS
24690   test -z "$as_dir" && as_dir=.
24691   for as_base in sh bash ksh sh5; do
24692          case $as_dir in
24693          /*)
24694            if ("$as_dir/$as_base" -c '
24695   as_lineno_1=$LINENO
24696   as_lineno_2=$LINENO
24697   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
24698   test "x$as_lineno_1" != "x$as_lineno_2" &&
24699   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
24700              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
24701              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
24702              CONFIG_SHELL=$as_dir/$as_base
24703              export CONFIG_SHELL
24704              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
24705            fi;;
24706          esac
24707        done
24708 done
24709 ;;
24710   esac
24711
24712   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
24713   # uniformly replaced by the line number.  The first 'sed' inserts a
24714   # line-number line before each line; the second 'sed' does the real
24715   # work.  The second script uses 'N' to pair each line-number line
24716   # with the numbered line, and appends trailing '-' during
24717   # substitution so that $LINENO is not a special case at line end.
24718   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
24719   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
24720   sed '=' <$as_myself |
24721     sed '
24722       N
24723       s,$,-,
24724       : loop
24725       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
24726       t loop
24727       s,-$,,
24728       s,^['$as_cr_digits']*\n,,
24729     ' >$as_me.lineno &&
24730   chmod +x $as_me.lineno ||
24731     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
24732 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
24733    { (exit 1); exit 1; }; }
24734
24735   # Don't try to exec as it changes $[0], causing all sort of problems
24736   # (the dirname of $[0] is not the place where we might find the
24737   # original and so on.  Autoconf is especially sensible to this).
24738   . ./$as_me.lineno
24739   # Exit status is that of the last command.
24740   exit
24741 }
24742
24743
24744 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
24745   *c*,-n*) ECHO_N= ECHO_C='
24746 ' ECHO_T='      ' ;;
24747   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
24748   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
24749 esac
24750
24751 if expr a : '\(a\)' >/dev/null 2>&1; then
24752   as_expr=expr
24753 else
24754   as_expr=false
24755 fi
24756
24757 rm -f conf$$ conf$$.exe conf$$.file
24758 echo >conf$$.file
24759 if ln -s conf$$.file conf$$ 2>/dev/null; then
24760   # We could just check for DJGPP; but this test a) works b) is more generic
24761   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
24762   if test -f conf$$.exe; then
24763     # Don't use ln at all; we don't have any links
24764     as_ln_s='cp -p'
24765   else
24766     as_ln_s='ln -s'
24767   fi
24768 elif ln conf$$.file conf$$ 2>/dev/null; then
24769   as_ln_s=ln
24770 else
24771   as_ln_s='cp -p'
24772 fi
24773 rm -f conf$$ conf$$.exe conf$$.file
24774
24775 if mkdir -p . 2>/dev/null; then
24776   as_mkdir_p=:
24777 else
24778   test -d ./-p && rmdir ./-p
24779   as_mkdir_p=false
24780 fi
24781
24782 as_executable_p="test -f"
24783
24784 # Sed expression to map a string onto a valid CPP name.
24785 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
24786
24787 # Sed expression to map a string onto a valid variable name.
24788 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
24789
24790
24791 # IFS
24792 # We need space, tab and new line, in precisely that order.
24793 as_nl='
24794 '
24795 IFS="   $as_nl"
24796
24797 # CDPATH.
24798 $as_unset CDPATH
24799
24800 exec 6>&1
24801
24802 # Open the log real soon, to keep \$[0] and so on meaningful, and to
24803 # report actual input values of CONFIG_FILES etc. instead of their
24804 # values after options handling.  Logging --version etc. is OK.
24805 exec 5>>config.log
24806 {
24807   echo
24808   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
24809 ## Running $as_me. ##
24810 _ASBOX
24811 } >&5
24812 cat >&5 <<_CSEOF
24813
24814 This file was extended by GNU Fortran Runtime Library $as_me 0.3, which was
24815 generated by GNU Autoconf 2.59.  Invocation command line was
24816
24817   CONFIG_FILES    = $CONFIG_FILES
24818   CONFIG_HEADERS  = $CONFIG_HEADERS
24819   CONFIG_LINKS    = $CONFIG_LINKS
24820   CONFIG_COMMANDS = $CONFIG_COMMANDS
24821   $ $0 $@
24822
24823 _CSEOF
24824 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
24825 echo >&5
24826 _ACEOF
24827
24828 # Files that config.status was made for.
24829 if test -n "$ac_config_files"; then
24830   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
24831 fi
24832
24833 if test -n "$ac_config_headers"; then
24834   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
24835 fi
24836
24837 if test -n "$ac_config_links"; then
24838   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
24839 fi
24840
24841 if test -n "$ac_config_commands"; then
24842   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
24843 fi
24844
24845 cat >>$CONFIG_STATUS <<\_ACEOF
24846
24847 ac_cs_usage="\
24848 \`$as_me' instantiates files from templates according to the
24849 current configuration.
24850
24851 Usage: $0 [OPTIONS] [FILE]...
24852
24853   -h, --help       print this help, then exit
24854   -V, --version    print version number, then exit
24855   -q, --quiet      do not print progress messages
24856   -d, --debug      don't remove temporary files
24857       --recheck    update $as_me by reconfiguring in the same conditions
24858   --file=FILE[:TEMPLATE]
24859                    instantiate the configuration file FILE
24860   --header=FILE[:TEMPLATE]
24861                    instantiate the configuration header FILE
24862
24863 Configuration files:
24864 $config_files
24865
24866 Configuration headers:
24867 $config_headers
24868
24869 Configuration commands:
24870 $config_commands
24871
24872 Report bugs to <bug-autoconf@gnu.org>."
24873 _ACEOF
24874
24875 cat >>$CONFIG_STATUS <<_ACEOF
24876 ac_cs_version="\\
24877 GNU Fortran Runtime Library config.status 0.3
24878 configured by $0, generated by GNU Autoconf 2.59,
24879   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
24880
24881 Copyright (C) 2003 Free Software Foundation, Inc.
24882 This config.status script is free software; the Free Software Foundation
24883 gives unlimited permission to copy, distribute and modify it."
24884 srcdir=$srcdir
24885 INSTALL="$INSTALL"
24886 _ACEOF
24887
24888 cat >>$CONFIG_STATUS <<\_ACEOF
24889 # If no file are specified by the user, then we need to provide default
24890 # value.  By we need to know if files were specified by the user.
24891 ac_need_defaults=:
24892 while test $# != 0
24893 do
24894   case $1 in
24895   --*=*)
24896     ac_option=`expr "x$1" : 'x\([^=]*\)='`
24897     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
24898     ac_shift=:
24899     ;;
24900   -*)
24901     ac_option=$1
24902     ac_optarg=$2
24903     ac_shift=shift
24904     ;;
24905   *) # This is not an option, so the user has probably given explicit
24906      # arguments.
24907      ac_option=$1
24908      ac_need_defaults=false;;
24909   esac
24910
24911   case $ac_option in
24912   # Handling of the options.
24913 _ACEOF
24914 cat >>$CONFIG_STATUS <<\_ACEOF
24915   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
24916     ac_cs_recheck=: ;;
24917   --version | --vers* | -V )
24918     echo "$ac_cs_version"; exit 0 ;;
24919   --he | --h)
24920     # Conflict between --help and --header
24921     { { echo "$as_me:$LINENO: error: ambiguous option: $1
24922 Try \`$0 --help' for more information." >&5
24923 echo "$as_me: error: ambiguous option: $1
24924 Try \`$0 --help' for more information." >&2;}
24925    { (exit 1); exit 1; }; };;
24926   --help | --hel | -h )
24927     echo "$ac_cs_usage"; exit 0 ;;
24928   --debug | --d* | -d )
24929     debug=: ;;
24930   --file | --fil | --fi | --f )
24931     $ac_shift
24932     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
24933     ac_need_defaults=false;;
24934   --header | --heade | --head | --hea )
24935     $ac_shift
24936     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
24937     ac_need_defaults=false;;
24938   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
24939   | -silent | --silent | --silen | --sile | --sil | --si | --s)
24940     ac_cs_silent=: ;;
24941
24942   # This is an error.
24943   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
24944 Try \`$0 --help' for more information." >&5
24945 echo "$as_me: error: unrecognized option: $1
24946 Try \`$0 --help' for more information." >&2;}
24947    { (exit 1); exit 1; }; } ;;
24948
24949   *) ac_config_targets="$ac_config_targets $1" ;;
24950
24951   esac
24952   shift
24953 done
24954
24955 ac_configure_extra_args=
24956
24957 if $ac_cs_silent; then
24958   exec 6>/dev/null
24959   ac_configure_extra_args="$ac_configure_extra_args --silent"
24960 fi
24961
24962 _ACEOF
24963 cat >>$CONFIG_STATUS <<_ACEOF
24964 if \$ac_cs_recheck; then
24965   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
24966   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
24967 fi
24968
24969 _ACEOF
24970
24971 cat >>$CONFIG_STATUS <<_ACEOF
24972 #
24973 # INIT-COMMANDS section.
24974 #
24975
24976
24977 srcdir="$srcdir"
24978 host="$host"
24979 target="$target"
24980 with_multisubdir="$with_multisubdir"
24981 with_multisrctop="$with_multisrctop"
24982 with_target_subdir="$with_target_subdir"
24983 ac_configure_args="${multilib_arg} ${ac_configure_args}"
24984 multi_basedir="$multi_basedir"
24985 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
24986 CC="$CC"
24987 AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
24988
24989 GCC="$GCC"
24990 CC="$CC"
24991 acx_cv_header_stdint="$acx_cv_header_stdint"
24992 acx_cv_type_int8_t="$acx_cv_type_int8_t"
24993 acx_cv_type_int16_t="$acx_cv_type_int16_t"
24994 acx_cv_type_int32_t="$acx_cv_type_int32_t"
24995 acx_cv_type_int64_t="$acx_cv_type_int64_t"
24996 acx_cv_type_intptr_t="$acx_cv_type_intptr_t"
24997 ac_cv_type_uintmax_t="$ac_cv_type_uintmax_t"
24998 ac_cv_type_uintptr_t="$ac_cv_type_uintptr_t"
24999 ac_cv_type_uint64_t="$ac_cv_type_uint64_t"
25000 ac_cv_type_u_int64_t="$ac_cv_type_u_int64_t"
25001 ac_cv_type_u_int32_t="$ac_cv_type_u_int32_t"
25002 ac_cv_type_int_least32_t="$ac_cv_type_int_least32_t"
25003 ac_cv_type_int_fast32_t="$ac_cv_type_int_fast32_t"
25004 ac_cv_sizeof_void_p="$ac_cv_sizeof_void_p"
25005
25006
25007 _ACEOF
25008
25009
25010
25011 cat >>$CONFIG_STATUS <<\_ACEOF
25012 for ac_config_target in $ac_config_targets
25013 do
25014   case "$ac_config_target" in
25015   # Handling of arguments.
25016   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
25017   "default-1" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default-1" ;;
25018   "depfiles" ) CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
25019   "gstdint.h" ) CONFIG_COMMANDS="$CONFIG_COMMANDS gstdint.h" ;;
25020   "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
25021   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
25022 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
25023    { (exit 1); exit 1; }; };;
25024   esac
25025 done
25026
25027 # If the user did not use the arguments to specify the items to instantiate,
25028 # then the envvar interface is used.  Set only those that are not.
25029 # We use the long form for the default assignment because of an extremely
25030 # bizarre bug on SunOS 4.1.3.
25031 if $ac_need_defaults; then
25032   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
25033   test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
25034   test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
25035 fi
25036
25037 # Have a temporary directory for convenience.  Make it in the build tree
25038 # simply because there is no reason to put it here, and in addition,
25039 # creating and moving files from /tmp can sometimes cause problems.
25040 # Create a temporary directory, and hook for its removal unless debugging.
25041 $debug ||
25042 {
25043   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
25044   trap '{ (exit 1); exit 1; }' 1 2 13 15
25045 }
25046
25047 # Create a (secure) tmp directory for tmp files.
25048
25049 {
25050   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
25051   test -n "$tmp" && test -d "$tmp"
25052 }  ||
25053 {
25054   tmp=./confstat$$-$RANDOM
25055   (umask 077 && mkdir $tmp)
25056 } ||
25057 {
25058    echo "$me: cannot create a temporary directory in ." >&2
25059    { (exit 1); exit 1; }
25060 }
25061
25062 _ACEOF
25063
25064 cat >>$CONFIG_STATUS <<_ACEOF
25065
25066 #
25067 # CONFIG_FILES section.
25068 #
25069
25070 # No need to generate the scripts if there are no CONFIG_FILES.
25071 # This happens for instance when ./config.status config.h
25072 if test -n "\$CONFIG_FILES"; then
25073   # Protect against being on the right side of a sed subst in config.status.
25074   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
25075    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
25076 s,@SHELL@,$SHELL,;t t
25077 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
25078 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
25079 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
25080 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
25081 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
25082 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
25083 s,@exec_prefix@,$exec_prefix,;t t
25084 s,@prefix@,$prefix,;t t
25085 s,@program_transform_name@,$program_transform_name,;t t
25086 s,@bindir@,$bindir,;t t
25087 s,@sbindir@,$sbindir,;t t
25088 s,@libexecdir@,$libexecdir,;t t
25089 s,@datadir@,$datadir,;t t
25090 s,@sysconfdir@,$sysconfdir,;t t
25091 s,@sharedstatedir@,$sharedstatedir,;t t
25092 s,@localstatedir@,$localstatedir,;t t
25093 s,@libdir@,$libdir,;t t
25094 s,@includedir@,$includedir,;t t
25095 s,@oldincludedir@,$oldincludedir,;t t
25096 s,@infodir@,$infodir,;t t
25097 s,@mandir@,$mandir,;t t
25098 s,@build_alias@,$build_alias,;t t
25099 s,@host_alias@,$host_alias,;t t
25100 s,@target_alias@,$target_alias,;t t
25101 s,@DEFS@,$DEFS,;t t
25102 s,@ECHO_C@,$ECHO_C,;t t
25103 s,@ECHO_N@,$ECHO_N,;t t
25104 s,@ECHO_T@,$ECHO_T,;t t
25105 s,@LIBS@,$LIBS,;t t
25106 s,@build@,$build,;t t
25107 s,@build_cpu@,$build_cpu,;t t
25108 s,@build_vendor@,$build_vendor,;t t
25109 s,@build_os@,$build_os,;t t
25110 s,@build_libsubdir@,$build_libsubdir,;t t
25111 s,@build_subdir@,$build_subdir,;t t
25112 s,@host_subdir@,$host_subdir,;t t
25113 s,@target_subdir@,$target_subdir,;t t
25114 s,@host@,$host,;t t
25115 s,@host_cpu@,$host_cpu,;t t
25116 s,@host_vendor@,$host_vendor,;t t
25117 s,@host_os@,$host_os,;t t
25118 s,@target@,$target,;t t
25119 s,@target_cpu@,$target_cpu,;t t
25120 s,@target_vendor@,$target_vendor,;t t
25121 s,@target_os@,$target_os,;t t
25122 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
25123 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
25124 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
25125 s,@CYGPATH_W@,$CYGPATH_W,;t t
25126 s,@PACKAGE@,$PACKAGE,;t t
25127 s,@VERSION@,$VERSION,;t t
25128 s,@ACLOCAL@,$ACLOCAL,;t t
25129 s,@AUTOCONF@,$AUTOCONF,;t t
25130 s,@AUTOMAKE@,$AUTOMAKE,;t t
25131 s,@AUTOHEADER@,$AUTOHEADER,;t t
25132 s,@MAKEINFO@,$MAKEINFO,;t t
25133 s,@install_sh@,$install_sh,;t t
25134 s,@STRIP@,$STRIP,;t t
25135 s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t
25136 s,@INSTALL_STRIP_PROGRAM@,$INSTALL_STRIP_PROGRAM,;t t
25137 s,@mkdir_p@,$mkdir_p,;t t
25138 s,@AWK@,$AWK,;t t
25139 s,@SET_MAKE@,$SET_MAKE,;t t
25140 s,@am__leading_dot@,$am__leading_dot,;t t
25141 s,@AMTAR@,$AMTAR,;t t
25142 s,@am__tar@,$am__tar,;t t
25143 s,@am__untar@,$am__untar,;t t
25144 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
25145 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
25146 s,@MAINT@,$MAINT,;t t
25147 s,@multi_basedir@,$multi_basedir,;t t
25148 s,@toolexecdir@,$toolexecdir,;t t
25149 s,@toolexeclibdir@,$toolexeclibdir,;t t
25150 s,@CC@,$CC,;t t
25151 s,@ac_ct_CC@,$ac_ct_CC,;t t
25152 s,@EXEEXT@,$EXEEXT,;t t
25153 s,@OBJEXT@,$OBJEXT,;t t
25154 s,@DEPDIR@,$DEPDIR,;t t
25155 s,@am__include@,$am__include,;t t
25156 s,@am__quote@,$am__quote,;t t
25157 s,@AMDEP_TRUE@,$AMDEP_TRUE,;t t
25158 s,@AMDEP_FALSE@,$AMDEP_FALSE,;t t
25159 s,@AMDEPBACKSLASH@,$AMDEPBACKSLASH,;t t
25160 s,@CCDEPMODE@,$CCDEPMODE,;t t
25161 s,@am__fastdepCC_TRUE@,$am__fastdepCC_TRUE,;t t
25162 s,@am__fastdepCC_FALSE@,$am__fastdepCC_FALSE,;t t
25163 s,@AM_FCFLAGS@,$AM_FCFLAGS,;t t
25164 s,@AM_CFLAGS@,$AM_CFLAGS,;t t
25165 s,@AS@,$AS,;t t
25166 s,@ac_ct_AS@,$ac_ct_AS,;t t
25167 s,@AR@,$AR,;t t
25168 s,@ac_ct_AR@,$ac_ct_AR,;t t
25169 s,@RANLIB@,$RANLIB,;t t
25170 s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
25171 s,@LN_S@,$LN_S,;t t
25172 s,@LIBTOOL@,$LIBTOOL,;t t
25173 s,@enable_shared@,$enable_shared,;t t
25174 s,@enable_static@,$enable_static,;t t
25175 s,@FC@,$FC,;t t
25176 s,@FCFLAGS@,$FCFLAGS,;t t
25177 s,@LDFLAGS@,$LDFLAGS,;t t
25178 s,@ac_ct_FC@,$ac_ct_FC,;t t
25179 s,@extra_ldflags_libgfortran@,$extra_ldflags_libgfortran,;t t
25180 s,@CPP@,$CPP,;t t
25181 s,@CPPFLAGS@,$CPPFLAGS,;t t
25182 s,@EGREP@,$EGREP,;t t
25183 s,@FPU_HOST_HEADER@,$FPU_HOST_HEADER,;t t
25184 s,@LIBOBJS@,$LIBOBJS,;t t
25185 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
25186 CEOF
25187
25188 _ACEOF
25189
25190   cat >>$CONFIG_STATUS <<\_ACEOF
25191   # Split the substitutions into bite-sized pieces for seds with
25192   # small command number limits, like on Digital OSF/1 and HP-UX.
25193   ac_max_sed_lines=48
25194   ac_sed_frag=1 # Number of current file.
25195   ac_beg=1 # First line for current file.
25196   ac_end=$ac_max_sed_lines # Line after last line for current file.
25197   ac_more_lines=:
25198   ac_sed_cmds=
25199   while $ac_more_lines; do
25200     if test $ac_beg -gt 1; then
25201       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
25202     else
25203       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
25204     fi
25205     if test ! -s $tmp/subs.frag; then
25206       ac_more_lines=false
25207     else
25208       # The purpose of the label and of the branching condition is to
25209       # speed up the sed processing (if there are no `@' at all, there
25210       # is no need to browse any of the substitutions).
25211       # These are the two extra sed commands mentioned above.
25212       (echo ':t
25213   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
25214       if test -z "$ac_sed_cmds"; then
25215         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
25216       else
25217         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
25218       fi
25219       ac_sed_frag=`expr $ac_sed_frag + 1`
25220       ac_beg=$ac_end
25221       ac_end=`expr $ac_end + $ac_max_sed_lines`
25222     fi
25223   done
25224   if test -z "$ac_sed_cmds"; then
25225     ac_sed_cmds=cat
25226   fi
25227 fi # test -n "$CONFIG_FILES"
25228
25229 _ACEOF
25230 cat >>$CONFIG_STATUS <<\_ACEOF
25231 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
25232   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
25233   case $ac_file in
25234   - | *:- | *:-:* ) # input from stdin
25235         cat >$tmp/stdin
25236         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25237         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25238   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25239         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25240   * )   ac_file_in=$ac_file.in ;;
25241   esac
25242
25243   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
25244   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
25245 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25246          X"$ac_file" : 'X\(//\)[^/]' \| \
25247          X"$ac_file" : 'X\(//\)$' \| \
25248          X"$ac_file" : 'X\(/\)' \| \
25249          .     : '\(.\)' 2>/dev/null ||
25250 echo X"$ac_file" |
25251     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25252           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25253           /^X\(\/\/\)$/{ s//\1/; q; }
25254           /^X\(\/\).*/{ s//\1/; q; }
25255           s/.*/./; q'`
25256   { if $as_mkdir_p; then
25257     mkdir -p "$ac_dir"
25258   else
25259     as_dir="$ac_dir"
25260     as_dirs=
25261     while test ! -d "$as_dir"; do
25262       as_dirs="$as_dir $as_dirs"
25263       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25264 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25265          X"$as_dir" : 'X\(//\)[^/]' \| \
25266          X"$as_dir" : 'X\(//\)$' \| \
25267          X"$as_dir" : 'X\(/\)' \| \
25268          .     : '\(.\)' 2>/dev/null ||
25269 echo X"$as_dir" |
25270     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25271           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25272           /^X\(\/\/\)$/{ s//\1/; q; }
25273           /^X\(\/\).*/{ s//\1/; q; }
25274           s/.*/./; q'`
25275     done
25276     test ! -n "$as_dirs" || mkdir $as_dirs
25277   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
25278 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
25279    { (exit 1); exit 1; }; }; }
25280
25281   ac_builddir=.
25282
25283 if test "$ac_dir" != .; then
25284   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
25285   # A "../" for each directory in $ac_dir_suffix.
25286   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
25287 else
25288   ac_dir_suffix= ac_top_builddir=
25289 fi
25290
25291 case $srcdir in
25292   .)  # No --srcdir option.  We are building in place.
25293     ac_srcdir=.
25294     if test -z "$ac_top_builddir"; then
25295        ac_top_srcdir=.
25296     else
25297        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
25298     fi ;;
25299   [\\/]* | ?:[\\/]* )  # Absolute path.
25300     ac_srcdir=$srcdir$ac_dir_suffix;
25301     ac_top_srcdir=$srcdir ;;
25302   *) # Relative path.
25303     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
25304     ac_top_srcdir=$ac_top_builddir$srcdir ;;
25305 esac
25306
25307 # Do not use `cd foo && pwd` to compute absolute paths, because
25308 # the directories may not exist.
25309 case `pwd` in
25310 .) ac_abs_builddir="$ac_dir";;
25311 *)
25312   case "$ac_dir" in
25313   .) ac_abs_builddir=`pwd`;;
25314   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
25315   *) ac_abs_builddir=`pwd`/"$ac_dir";;
25316   esac;;
25317 esac
25318 case $ac_abs_builddir in
25319 .) ac_abs_top_builddir=${ac_top_builddir}.;;
25320 *)
25321   case ${ac_top_builddir}. in
25322   .) ac_abs_top_builddir=$ac_abs_builddir;;
25323   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
25324   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
25325   esac;;
25326 esac
25327 case $ac_abs_builddir in
25328 .) ac_abs_srcdir=$ac_srcdir;;
25329 *)
25330   case $ac_srcdir in
25331   .) ac_abs_srcdir=$ac_abs_builddir;;
25332   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
25333   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
25334   esac;;
25335 esac
25336 case $ac_abs_builddir in
25337 .) ac_abs_top_srcdir=$ac_top_srcdir;;
25338 *)
25339   case $ac_top_srcdir in
25340   .) ac_abs_top_srcdir=$ac_abs_builddir;;
25341   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
25342   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
25343   esac;;
25344 esac
25345
25346
25347   case $INSTALL in
25348   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
25349   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
25350   esac
25351
25352   if test x"$ac_file" != x-; then
25353     { echo "$as_me:$LINENO: creating $ac_file" >&5
25354 echo "$as_me: creating $ac_file" >&6;}
25355     rm -f "$ac_file"
25356   fi
25357   # Let's still pretend it is `configure' which instantiates (i.e., don't
25358   # use $as_me), people would be surprised to read:
25359   #    /* config.h.  Generated by config.status.  */
25360   if test x"$ac_file" = x-; then
25361     configure_input=
25362   else
25363     configure_input="$ac_file.  "
25364   fi
25365   configure_input=$configure_input"Generated from `echo $ac_file_in |
25366                                      sed 's,.*/,,'` by configure."
25367
25368   # First look for the input files in the build tree, otherwise in the
25369   # src tree.
25370   ac_file_inputs=`IFS=:
25371     for f in $ac_file_in; do
25372       case $f in
25373       -) echo $tmp/stdin ;;
25374       [\\/$]*)
25375          # Absolute (can't be DOS-style, as IFS=:)
25376          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25377 echo "$as_me: error: cannot find input file: $f" >&2;}
25378    { (exit 1); exit 1; }; }
25379          echo "$f";;
25380       *) # Relative
25381          if test -f "$f"; then
25382            # Build tree
25383            echo "$f"
25384          elif test -f "$srcdir/$f"; then
25385            # Source tree
25386            echo "$srcdir/$f"
25387          else
25388            # /dev/null tree
25389            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25390 echo "$as_me: error: cannot find input file: $f" >&2;}
25391    { (exit 1); exit 1; }; }
25392          fi;;
25393       esac
25394     done` || { (exit 1); exit 1; }
25395 _ACEOF
25396 cat >>$CONFIG_STATUS <<_ACEOF
25397   sed "$ac_vpsub
25398 $extrasub
25399 _ACEOF
25400 cat >>$CONFIG_STATUS <<\_ACEOF
25401 :t
25402 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
25403 s,@configure_input@,$configure_input,;t t
25404 s,@srcdir@,$ac_srcdir,;t t
25405 s,@abs_srcdir@,$ac_abs_srcdir,;t t
25406 s,@top_srcdir@,$ac_top_srcdir,;t t
25407 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
25408 s,@builddir@,$ac_builddir,;t t
25409 s,@abs_builddir@,$ac_abs_builddir,;t t
25410 s,@top_builddir@,$ac_top_builddir,;t t
25411 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
25412 s,@INSTALL@,$ac_INSTALL,;t t
25413 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
25414   rm -f $tmp/stdin
25415   if test x"$ac_file" != x-; then
25416     mv $tmp/out $ac_file
25417   else
25418     cat $tmp/out
25419     rm -f $tmp/out
25420   fi
25421
25422 done
25423 _ACEOF
25424 cat >>$CONFIG_STATUS <<\_ACEOF
25425
25426 #
25427 # CONFIG_HEADER section.
25428 #
25429
25430 # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
25431 # NAME is the cpp macro being defined and VALUE is the value it is being given.
25432 #
25433 # ac_d sets the value in "#define NAME VALUE" lines.
25434 ac_dA='s,^\([    ]*\)#\([        ]*define[       ][      ]*\)'
25435 ac_dB='[         ].*$,\1#\2'
25436 ac_dC=' '
25437 ac_dD=',;t'
25438 # ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
25439 ac_uA='s,^\([    ]*\)#\([        ]*\)undef\([    ][      ]*\)'
25440 ac_uB='$,\1#\2define\3'
25441 ac_uC=' '
25442 ac_uD=',;t'
25443
25444 for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue
25445   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
25446   case $ac_file in
25447   - | *:- | *:-:* ) # input from stdin
25448         cat >$tmp/stdin
25449         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25450         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25451   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25452         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25453   * )   ac_file_in=$ac_file.in ;;
25454   esac
25455
25456   test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5
25457 echo "$as_me: creating $ac_file" >&6;}
25458
25459   # First look for the input files in the build tree, otherwise in the
25460   # src tree.
25461   ac_file_inputs=`IFS=:
25462     for f in $ac_file_in; do
25463       case $f in
25464       -) echo $tmp/stdin ;;
25465       [\\/$]*)
25466          # Absolute (can't be DOS-style, as IFS=:)
25467          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25468 echo "$as_me: error: cannot find input file: $f" >&2;}
25469    { (exit 1); exit 1; }; }
25470          # Do quote $f, to prevent DOS paths from being IFS'd.
25471          echo "$f";;
25472       *) # Relative
25473          if test -f "$f"; then
25474            # Build tree
25475            echo "$f"
25476          elif test -f "$srcdir/$f"; then
25477            # Source tree
25478            echo "$srcdir/$f"
25479          else
25480            # /dev/null tree
25481            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25482 echo "$as_me: error: cannot find input file: $f" >&2;}
25483    { (exit 1); exit 1; }; }
25484          fi;;
25485       esac
25486     done` || { (exit 1); exit 1; }
25487   # Remove the trailing spaces.
25488   sed 's/[       ]*$//' $ac_file_inputs >$tmp/in
25489
25490 _ACEOF
25491
25492 # Transform confdefs.h into two sed scripts, `conftest.defines' and
25493 # `conftest.undefs', that substitutes the proper values into
25494 # config.h.in to produce config.h.  The first handles `#define'
25495 # templates, and the second `#undef' templates.
25496 # And first: Protect against being on the right side of a sed subst in
25497 # config.status.  Protect against being in an unquoted here document
25498 # in config.status.
25499 rm -f conftest.defines conftest.undefs
25500 # Using a here document instead of a string reduces the quoting nightmare.
25501 # Putting comments in sed scripts is not portable.
25502 #
25503 # `end' is used to avoid that the second main sed command (meant for
25504 # 0-ary CPP macros) applies to n-ary macro definitions.
25505 # See the Autoconf documentation for `clear'.
25506 cat >confdef2sed.sed <<\_ACEOF
25507 s/[\\&,]/\\&/g
25508 s,[\\$`],\\&,g
25509 t clear
25510 : clear
25511 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
25512 t end
25513 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
25514 : end
25515 _ACEOF
25516 # If some macros were called several times there might be several times
25517 # the same #defines, which is useless.  Nevertheless, we may not want to
25518 # sort them, since we want the *last* AC-DEFINE to be honored.
25519 uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines
25520 sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs
25521 rm -f confdef2sed.sed
25522
25523 # This sed command replaces #undef with comments.  This is necessary, for
25524 # example, in the case of _POSIX_SOURCE, which is predefined and required
25525 # on some systems where configure will not decide to define it.
25526 cat >>conftest.undefs <<\_ACEOF
25527 s,^[     ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
25528 _ACEOF
25529
25530 # Break up conftest.defines because some shells have a limit on the size
25531 # of here documents, and old seds have small limits too (100 cmds).
25532 echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
25533 echo '  if grep "^[      ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
25534 echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
25535 echo '  :' >>$CONFIG_STATUS
25536 rm -f conftest.tail
25537 while grep . conftest.defines >/dev/null
25538 do
25539   # Write a limited-size here document to $tmp/defines.sed.
25540   echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
25541   # Speed up: don't consider the non `#define' lines.
25542   echo '/^[      ]*#[    ]*define/!b' >>$CONFIG_STATUS
25543   # Work around the forget-to-reset-the-flag bug.
25544   echo 't clr' >>$CONFIG_STATUS
25545   echo ': clr' >>$CONFIG_STATUS
25546   sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS
25547   echo 'CEOF
25548   sed -f $tmp/defines.sed $tmp/in >$tmp/out
25549   rm -f $tmp/in
25550   mv $tmp/out $tmp/in
25551 ' >>$CONFIG_STATUS
25552   sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail
25553   rm -f conftest.defines
25554   mv conftest.tail conftest.defines
25555 done
25556 rm -f conftest.defines
25557 echo '  fi # grep' >>$CONFIG_STATUS
25558 echo >>$CONFIG_STATUS
25559
25560 # Break up conftest.undefs because some shells have a limit on the size
25561 # of here documents, and old seds have small limits too (100 cmds).
25562 echo '  # Handle all the #undef templates' >>$CONFIG_STATUS
25563 rm -f conftest.tail
25564 while grep . conftest.undefs >/dev/null
25565 do
25566   # Write a limited-size here document to $tmp/undefs.sed.
25567   echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
25568   # Speed up: don't consider the non `#undef'
25569   echo '/^[      ]*#[    ]*undef/!b' >>$CONFIG_STATUS
25570   # Work around the forget-to-reset-the-flag bug.
25571   echo 't clr' >>$CONFIG_STATUS
25572   echo ': clr' >>$CONFIG_STATUS
25573   sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS
25574   echo 'CEOF
25575   sed -f $tmp/undefs.sed $tmp/in >$tmp/out
25576   rm -f $tmp/in
25577   mv $tmp/out $tmp/in
25578 ' >>$CONFIG_STATUS
25579   sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail
25580   rm -f conftest.undefs
25581   mv conftest.tail conftest.undefs
25582 done
25583 rm -f conftest.undefs
25584
25585 cat >>$CONFIG_STATUS <<\_ACEOF
25586   # Let's still pretend it is `configure' which instantiates (i.e., don't
25587   # use $as_me), people would be surprised to read:
25588   #    /* config.h.  Generated by config.status.  */
25589   if test x"$ac_file" = x-; then
25590     echo "/* Generated by configure.  */" >$tmp/config.h
25591   else
25592     echo "/* $ac_file.  Generated by configure.  */" >$tmp/config.h
25593   fi
25594   cat $tmp/in >>$tmp/config.h
25595   rm -f $tmp/in
25596   if test x"$ac_file" != x-; then
25597     if diff $ac_file $tmp/config.h >/dev/null 2>&1; then
25598       { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
25599 echo "$as_me: $ac_file is unchanged" >&6;}
25600     else
25601       ac_dir=`(dirname "$ac_file") 2>/dev/null ||
25602 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25603          X"$ac_file" : 'X\(//\)[^/]' \| \
25604          X"$ac_file" : 'X\(//\)$' \| \
25605          X"$ac_file" : 'X\(/\)' \| \
25606          .     : '\(.\)' 2>/dev/null ||
25607 echo X"$ac_file" |
25608     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25609           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25610           /^X\(\/\/\)$/{ s//\1/; q; }
25611           /^X\(\/\).*/{ s//\1/; q; }
25612           s/.*/./; q'`
25613       { if $as_mkdir_p; then
25614     mkdir -p "$ac_dir"
25615   else
25616     as_dir="$ac_dir"
25617     as_dirs=
25618     while test ! -d "$as_dir"; do
25619       as_dirs="$as_dir $as_dirs"
25620       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25621 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25622          X"$as_dir" : 'X\(//\)[^/]' \| \
25623          X"$as_dir" : 'X\(//\)$' \| \
25624          X"$as_dir" : 'X\(/\)' \| \
25625          .     : '\(.\)' 2>/dev/null ||
25626 echo X"$as_dir" |
25627     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25628           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25629           /^X\(\/\/\)$/{ s//\1/; q; }
25630           /^X\(\/\).*/{ s//\1/; q; }
25631           s/.*/./; q'`
25632     done
25633     test ! -n "$as_dirs" || mkdir $as_dirs
25634   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
25635 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
25636    { (exit 1); exit 1; }; }; }
25637
25638       rm -f $ac_file
25639       mv $tmp/config.h $ac_file
25640     fi
25641   else
25642     cat $tmp/config.h
25643     rm -f $tmp/config.h
25644   fi
25645 # Compute $ac_file's index in $config_headers.
25646 _am_stamp_count=1
25647 for _am_header in $config_headers :; do
25648   case $_am_header in
25649     $ac_file | $ac_file:* )
25650       break ;;
25651     * )
25652       _am_stamp_count=`expr $_am_stamp_count + 1` ;;
25653   esac
25654 done
25655 echo "timestamp for $ac_file" >`(dirname $ac_file) 2>/dev/null ||
25656 $as_expr X$ac_file : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25657          X$ac_file : 'X\(//\)[^/]' \| \
25658          X$ac_file : 'X\(//\)$' \| \
25659          X$ac_file : 'X\(/\)' \| \
25660          .     : '\(.\)' 2>/dev/null ||
25661 echo X$ac_file |
25662     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25663           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25664           /^X\(\/\/\)$/{ s//\1/; q; }
25665           /^X\(\/\).*/{ s//\1/; q; }
25666           s/.*/./; q'`/stamp-h$_am_stamp_count
25667 done
25668 _ACEOF
25669 cat >>$CONFIG_STATUS <<\_ACEOF
25670
25671 #
25672 # CONFIG_COMMANDS section.
25673 #
25674 for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue
25675   ac_dest=`echo "$ac_file" | sed 's,:.*,,'`
25676   ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`
25677   ac_dir=`(dirname "$ac_dest") 2>/dev/null ||
25678 $as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25679          X"$ac_dest" : 'X\(//\)[^/]' \| \
25680          X"$ac_dest" : 'X\(//\)$' \| \
25681          X"$ac_dest" : 'X\(/\)' \| \
25682          .     : '\(.\)' 2>/dev/null ||
25683 echo X"$ac_dest" |
25684     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25685           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25686           /^X\(\/\/\)$/{ s//\1/; q; }
25687           /^X\(\/\).*/{ s//\1/; q; }
25688           s/.*/./; q'`
25689   { if $as_mkdir_p; then
25690     mkdir -p "$ac_dir"
25691   else
25692     as_dir="$ac_dir"
25693     as_dirs=
25694     while test ! -d "$as_dir"; do
25695       as_dirs="$as_dir $as_dirs"
25696       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25697 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25698          X"$as_dir" : 'X\(//\)[^/]' \| \
25699          X"$as_dir" : 'X\(//\)$' \| \
25700          X"$as_dir" : 'X\(/\)' \| \
25701          .     : '\(.\)' 2>/dev/null ||
25702 echo X"$as_dir" |
25703     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25704           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25705           /^X\(\/\/\)$/{ s//\1/; q; }
25706           /^X\(\/\).*/{ s//\1/; q; }
25707           s/.*/./; q'`
25708     done
25709     test ! -n "$as_dirs" || mkdir $as_dirs
25710   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
25711 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
25712    { (exit 1); exit 1; }; }; }
25713
25714   ac_builddir=.
25715
25716 if test "$ac_dir" != .; then
25717   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
25718   # A "../" for each directory in $ac_dir_suffix.
25719   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
25720 else
25721   ac_dir_suffix= ac_top_builddir=
25722 fi
25723
25724 case $srcdir in
25725   .)  # No --srcdir option.  We are building in place.
25726     ac_srcdir=.
25727     if test -z "$ac_top_builddir"; then
25728        ac_top_srcdir=.
25729     else
25730        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
25731     fi ;;
25732   [\\/]* | ?:[\\/]* )  # Absolute path.
25733     ac_srcdir=$srcdir$ac_dir_suffix;
25734     ac_top_srcdir=$srcdir ;;
25735   *) # Relative path.
25736     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
25737     ac_top_srcdir=$ac_top_builddir$srcdir ;;
25738 esac
25739
25740 # Do not use `cd foo && pwd` to compute absolute paths, because
25741 # the directories may not exist.
25742 case `pwd` in
25743 .) ac_abs_builddir="$ac_dir";;
25744 *)
25745   case "$ac_dir" in
25746   .) ac_abs_builddir=`pwd`;;
25747   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
25748   *) ac_abs_builddir=`pwd`/"$ac_dir";;
25749   esac;;
25750 esac
25751 case $ac_abs_builddir in
25752 .) ac_abs_top_builddir=${ac_top_builddir}.;;
25753 *)
25754   case ${ac_top_builddir}. in
25755   .) ac_abs_top_builddir=$ac_abs_builddir;;
25756   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
25757   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
25758   esac;;
25759 esac
25760 case $ac_abs_builddir in
25761 .) ac_abs_srcdir=$ac_srcdir;;
25762 *)
25763   case $ac_srcdir in
25764   .) ac_abs_srcdir=$ac_abs_builddir;;
25765   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
25766   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
25767   esac;;
25768 esac
25769 case $ac_abs_builddir in
25770 .) ac_abs_top_srcdir=$ac_top_srcdir;;
25771 *)
25772   case $ac_top_srcdir in
25773   .) ac_abs_top_srcdir=$ac_abs_builddir;;
25774   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
25775   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
25776   esac;;
25777 esac
25778
25779
25780   { echo "$as_me:$LINENO: executing $ac_dest commands" >&5
25781 echo "$as_me: executing $ac_dest commands" >&6;}
25782   case $ac_dest in
25783     default-1 )
25784 # Only add multilib support code if we just rebuilt the top-level
25785 # Makefile.
25786 case " $CONFIG_FILES " in
25787  *" Makefile "*)
25788    ac_file=Makefile . ${multi_basedir}/config-ml.in
25789    ;;
25790 esac ;;
25791     depfiles ) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do
25792   # Strip MF so we end up with the name of the file.
25793   mf=`echo "$mf" | sed -e 's/:.*$//'`
25794   # Check whether this is an Automake generated Makefile or not.
25795   # We used to match only the files named `Makefile.in', but
25796   # some people rename them; so instead we look at the file content.
25797   # Grep'ing the first line is not enough: some people post-process
25798   # each Makefile.in and add a new line on top of each file to say so.
25799   # So let's grep whole file.
25800   if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then
25801     dirpart=`(dirname "$mf") 2>/dev/null ||
25802 $as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25803          X"$mf" : 'X\(//\)[^/]' \| \
25804          X"$mf" : 'X\(//\)$' \| \
25805          X"$mf" : 'X\(/\)' \| \
25806          .     : '\(.\)' 2>/dev/null ||
25807 echo X"$mf" |
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   else
25814     continue
25815   fi
25816   # Extract the definition of DEPDIR, am__include, and am__quote
25817   # from the Makefile without running `make'.
25818   DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
25819   test -z "$DEPDIR" && continue
25820   am__include=`sed -n 's/^am__include = //p' < "$mf"`
25821   test -z "am__include" && continue
25822   am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
25823   # When using ansi2knr, U may be empty or an underscore; expand it
25824   U=`sed -n 's/^U = //p' < "$mf"`
25825   # Find all dependency output files, they are included files with
25826   # $(DEPDIR) in their names.  We invoke sed twice because it is the
25827   # simplest approach to changing $(DEPDIR) to its actual value in the
25828   # expansion.
25829   for file in `sed -n "
25830     s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
25831        sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
25832     # Make sure the directory exists.
25833     test -f "$dirpart/$file" && continue
25834     fdir=`(dirname "$file") 2>/dev/null ||
25835 $as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25836          X"$file" : 'X\(//\)[^/]' \| \
25837          X"$file" : 'X\(//\)$' \| \
25838          X"$file" : 'X\(/\)' \| \
25839          .     : '\(.\)' 2>/dev/null ||
25840 echo X"$file" |
25841     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25842           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25843           /^X\(\/\/\)$/{ s//\1/; q; }
25844           /^X\(\/\).*/{ s//\1/; q; }
25845           s/.*/./; q'`
25846     { if $as_mkdir_p; then
25847     mkdir -p $dirpart/$fdir
25848   else
25849     as_dir=$dirpart/$fdir
25850     as_dirs=
25851     while test ! -d "$as_dir"; do
25852       as_dirs="$as_dir $as_dirs"
25853       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25854 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25855          X"$as_dir" : 'X\(//\)[^/]' \| \
25856          X"$as_dir" : 'X\(//\)$' \| \
25857          X"$as_dir" : 'X\(/\)' \| \
25858          .     : '\(.\)' 2>/dev/null ||
25859 echo X"$as_dir" |
25860     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25861           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25862           /^X\(\/\/\)$/{ s//\1/; q; }
25863           /^X\(\/\).*/{ s//\1/; q; }
25864           s/.*/./; q'`
25865     done
25866     test ! -n "$as_dirs" || mkdir $as_dirs
25867   fi || { { echo "$as_me:$LINENO: error: cannot create directory $dirpart/$fdir" >&5
25868 echo "$as_me: error: cannot create directory $dirpart/$fdir" >&2;}
25869    { (exit 1); exit 1; }; }; }
25870
25871     # echo "creating $dirpart/$file"
25872     echo '# dummy' > "$dirpart/$file"
25873   done
25874 done
25875  ;;
25876     gstdint.h )
25877 if test "$GCC" = yes; then
25878   echo "/* generated for " `$CC --version | sed 1q` "*/" > tmp-stdint.h
25879 else
25880   echo "/* generated for $CC */" > tmp-stdint.h
25881 fi
25882
25883 sed 's/^ *//' >> tmp-stdint.h <<EOF
25884
25885   #ifndef GCC_GENERATED_STDINT_H
25886   #define GCC_GENERATED_STDINT_H 1
25887
25888   #include <sys/types.h>
25889 EOF
25890
25891 if test "$acx_cv_header_stdint" != stdint.h; then
25892   echo "#include <stddef.h>" >> tmp-stdint.h
25893 fi
25894 if test "$acx_cv_header_stdint" != stddef.h; then
25895   echo "#include <$acx_cv_header_stdint>" >> tmp-stdint.h
25896 fi
25897
25898 sed 's/^ *//' >> tmp-stdint.h <<EOF
25899   /* glibc uses these symbols as guards to prevent redefinitions.  */
25900   #ifdef __int8_t_defined
25901   #define _INT8_T
25902   #define _INT16_T
25903   #define _INT32_T
25904   #endif
25905   #ifdef __uint32_t_defined
25906   #define _UINT32_T
25907   #endif
25908
25909 EOF
25910
25911 # ----------------- done header, emit basic int types -------------
25912 if test "$acx_cv_header_stdint" = stddef.h; then
25913   sed 's/^ *//' >> tmp-stdint.h <<EOF
25914
25915     #ifndef _UINT8_T
25916     #define _UINT8_T
25917     typedef unsigned $acx_cv_type_int8_t uint8_t;
25918     #endif
25919
25920     #ifndef _UINT16_T
25921     #define _UINT16_T
25922     typedef unsigned $acx_cv_type_int16_t uint16_t;
25923     #endif
25924
25925     #ifndef _UINT32_T
25926     #define _UINT32_T
25927     typedef unsigned $acx_cv_type_int32_t uint32_t;
25928     #endif
25929
25930     #ifndef _INT8_T
25931     #define _INT8_T
25932     typedef $acx_cv_type_int8_t int8_t;
25933     #endif
25934
25935     #ifndef _INT16_T
25936     #define _INT16_T
25937     typedef $acx_cv_type_int16_t int16_t;
25938     #endif
25939
25940     #ifndef _INT32_T
25941     #define _INT32_T
25942     typedef $acx_cv_type_int32_t int32_t;
25943     #endif
25944 EOF
25945 elif test "$ac_cv_type_u_int32_t" = yes; then
25946   sed 's/^ *//' >> tmp-stdint.h <<EOF
25947
25948     /* int8_t int16_t int32_t defined by inet code, we do the u_intXX types */
25949     #ifndef _INT8_T
25950     #define _INT8_T
25951     #endif
25952     #ifndef _INT16_T
25953     #define _INT16_T
25954     #endif
25955     #ifndef _INT32_T
25956     #define _INT32_T
25957     #endif
25958
25959     #ifndef _UINT8_T
25960     #define _UINT8_T
25961     typedef u_int8_t uint8_t;
25962     #endif
25963
25964     #ifndef _UINT16_T
25965     #define _UINT16_T
25966     typedef u_int16_t uint16_t;
25967     #endif
25968
25969     #ifndef _UINT32_T
25970     #define _UINT32_T
25971     typedef u_int32_t uint32_t;
25972     #endif
25973 EOF
25974 else
25975   sed 's/^ *//' >> tmp-stdint.h <<EOF
25976
25977     /* Some systems have guard macros to prevent redefinitions, define them.  */
25978     #ifndef _INT8_T
25979     #define _INT8_T
25980     #endif
25981     #ifndef _INT16_T
25982     #define _INT16_T
25983     #endif
25984     #ifndef _INT32_T
25985     #define _INT32_T
25986     #endif
25987     #ifndef _UINT8_T
25988     #define _UINT8_T
25989     #endif
25990     #ifndef _UINT16_T
25991     #define _UINT16_T
25992     #endif
25993     #ifndef _UINT32_T
25994     #define _UINT32_T
25995     #endif
25996 EOF
25997 fi
25998
25999 # ------------- done basic int types, emit int64_t types ------------
26000 if test "$ac_cv_type_uint64_t" = yes; then
26001   sed 's/^ *//' >> tmp-stdint.h <<EOF
26002
26003     /* system headers have good uint64_t and int64_t */
26004     #ifndef _INT64_T
26005     #define _INT64_T
26006     #endif
26007     #ifndef _UINT64_T
26008     #define _UINT64_T
26009     #endif
26010 EOF
26011 elif test "$ac_cv_type_u_int64_t" = yes; then
26012   sed 's/^ *//' >> tmp-stdint.h <<EOF
26013
26014     /* system headers have an u_int64_t (and int64_t) */
26015     #ifndef _INT64_T
26016     #define _INT64_T
26017     #endif
26018     #ifndef _UINT64_T
26019     #define _UINT64_T
26020     typedef u_int64_t uint64_t;
26021     #endif
26022 EOF
26023 elif test -n "$acx_cv_type_int64_t"; then
26024   sed 's/^ *//' >> tmp-stdint.h <<EOF
26025
26026     /* architecture has a 64-bit type, $acx_cv_type_int64_t */
26027     #ifndef _INT64_T
26028     #define _INT64_T
26029     typedef $acx_cv_type_int64_t int64_t;
26030     #endif
26031     #ifndef _UINT64_T
26032     #define _UINT64_T
26033     typedef unsigned $acx_cv_type_int64_t uint64_t;
26034     #endif
26035 EOF
26036 else
26037   sed 's/^ *//' >> tmp-stdint.h <<EOF
26038
26039     /* some common heuristics for int64_t, using compiler-specific tests */
26040     #if defined __STDC_VERSION__ && (__STDC_VERSION__-0) >= 199901L
26041     #ifndef _INT64_T
26042     #define _INT64_T
26043     typedef long long int64_t;
26044     #endif
26045     #ifndef _UINT64_T
26046     #define _UINT64_T
26047     typedef unsigned long long uint64_t;
26048     #endif
26049
26050     #elif defined __GNUC__ && defined (__STDC__) && __STDC__-0
26051     /* NextStep 2.0 cc is really gcc 1.93 but it defines __GNUC__ = 2 and
26052        does not implement __extension__.  But that compiler doesn't define
26053        __GNUC_MINOR__.  */
26054     # if __GNUC__ < 2 || (__NeXT__ && !__GNUC_MINOR__)
26055     # define __extension__
26056     # endif
26057
26058     # ifndef _INT64_T
26059     # define _INT64_T
26060     __extension__ typedef long long int64_t;
26061     # endif
26062     # ifndef _UINT64_T
26063     # define _UINT64_T
26064     __extension__ typedef unsigned long long uint64_t;
26065     # endif
26066
26067     #elif !defined __STRICT_ANSI__
26068     # if defined _MSC_VER || defined __WATCOMC__ || defined __BORLANDC__
26069
26070     #  ifndef _INT64_T
26071     #  define _INT64_T
26072     typedef __int64 int64_t;
26073     #  endif
26074     #  ifndef _UINT64_T
26075     #  define _UINT64_T
26076     typedef unsigned __int64 uint64_t;
26077     #  endif
26078     # endif /* compiler */
26079
26080     #endif /* ANSI version */
26081 EOF
26082 fi
26083
26084 # ------------- done int64_t types, emit intptr types ------------
26085 if test "$ac_cv_type_uintptr_t" != yes; then
26086   sed 's/^ *//' >> tmp-stdint.h <<EOF
26087
26088     /* Define intptr_t based on sizeof(void*) = $ac_cv_sizeof_void_p */
26089     typedef u$acx_cv_type_intptr_t uintptr_t;
26090     typedef $acx_cv_type_intptr_t  intptr_t;
26091 EOF
26092 fi
26093
26094 # ------------- done intptr types, emit int_least types ------------
26095 if test "$ac_cv_type_int_least32_t" != yes; then
26096   sed 's/^ *//' >> tmp-stdint.h <<EOF
26097
26098     /* Define int_least types */
26099     typedef int8_t     int_least8_t;
26100     typedef int16_t    int_least16_t;
26101     typedef int32_t    int_least32_t;
26102     #ifdef _INT64_T
26103     typedef int64_t    int_least64_t;
26104     #endif
26105
26106     typedef uint8_t    uint_least8_t;
26107     typedef uint16_t   uint_least16_t;
26108     typedef uint32_t   uint_least32_t;
26109     #ifdef _UINT64_T
26110     typedef uint64_t   uint_least64_t;
26111     #endif
26112 EOF
26113 fi
26114
26115 # ------------- done intptr types, emit int_fast types ------------
26116 if test "$ac_cv_type_int_fast32_t" != yes; then
26117       sed 's/^ *//' >> tmp-stdint.h <<EOF
26118
26119     /* Define int_fast types.  short is often slow */
26120     typedef int8_t       int_fast8_t;
26121     typedef int          int_fast16_t;
26122     typedef int32_t      int_fast32_t;
26123     #ifdef _INT64_T
26124     typedef int64_t      int_fast64_t;
26125     #endif
26126
26127     typedef uint8_t      uint_fast8_t;
26128     typedef unsigned int uint_fast16_t;
26129     typedef uint32_t     uint_fast32_t;
26130     #ifdef _UINT64_T
26131     typedef uint64_t     uint_fast64_t;
26132     #endif
26133 EOF
26134 fi
26135
26136 if test "$ac_cv_type_uintmax_t" != yes; then
26137   sed 's/^ *//' >> tmp-stdint.h <<EOF
26138
26139     /* Define intmax based on what we found */
26140     #ifdef _INT64_T
26141     typedef int64_t       intmax_t;
26142     #else
26143     typedef long          intmax_t;
26144     #endif
26145     #ifdef _UINT64_T
26146     typedef uint64_t      uintmax_t;
26147     #else
26148     typedef unsigned long uintmax_t;
26149     #endif
26150 EOF
26151 fi
26152
26153 sed 's/^ *//' >> tmp-stdint.h <<EOF
26154
26155   #endif /* GCC_GENERATED_STDINT_H */
26156 EOF
26157
26158 if test -r gstdint.h && cmp -s tmp-stdint.h gstdint.h; then
26159   rm -f tmp-stdint.h
26160 else
26161   mv -f tmp-stdint.h gstdint.h
26162 fi
26163
26164  ;;
26165   esac
26166 done
26167 _ACEOF
26168
26169 cat >>$CONFIG_STATUS <<\_ACEOF
26170
26171 { (exit 0); exit 0; }
26172 _ACEOF
26173 chmod +x $CONFIG_STATUS
26174 ac_clean_files=$ac_clean_files_save
26175
26176
26177 # configure is writing to config.log, and then calls config.status.
26178 # config.status does its own redirection, appending to config.log.
26179 # Unfortunately, on DOS this fails, as config.log is still kept open
26180 # by configure, so config.status won't be able to write to it; its
26181 # output is simply discarded.  So we exec the FD to /dev/null,
26182 # effectively closing config.log, so it can be properly (re)opened and
26183 # appended to by config.status.  When coming back to configure, we
26184 # need to make the FD available again.
26185 if test "$no_create" != yes; then
26186   ac_cs_success=:
26187   ac_config_status_args=
26188   test "$silent" = yes &&
26189     ac_config_status_args="$ac_config_status_args --quiet"
26190   exec 5>/dev/null
26191   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
26192   exec 5>>config.log
26193   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
26194   # would make configure fail if this is the last instruction.
26195   $ac_cs_success || { (exit 1); exit 1; }
26196 fi
26197