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 for ac_header in fenv.h fptrap.h float.h
6579 do
6580 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6581 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6582   echo "$as_me:$LINENO: checking for $ac_header" >&5
6583 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6584 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6585   echo $ECHO_N "(cached) $ECHO_C" >&6
6586 fi
6587 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6588 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6589 else
6590   # Is the header compilable?
6591 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6592 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6593 cat >conftest.$ac_ext <<_ACEOF
6594 /* confdefs.h.  */
6595 _ACEOF
6596 cat confdefs.h >>conftest.$ac_ext
6597 cat >>conftest.$ac_ext <<_ACEOF
6598 /* end confdefs.h.  */
6599 $ac_includes_default
6600 #include <$ac_header>
6601 _ACEOF
6602 rm -f conftest.$ac_objext
6603 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6604   (eval $ac_compile) 2>conftest.er1
6605   ac_status=$?
6606   grep -v '^ *+' conftest.er1 >conftest.err
6607   rm -f conftest.er1
6608   cat conftest.err >&5
6609   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6610   (exit $ac_status); } &&
6611          { ac_try='test -z "$ac_c_werror_flag"
6612                          || test ! -s conftest.err'
6613   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6614   (eval $ac_try) 2>&5
6615   ac_status=$?
6616   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6617   (exit $ac_status); }; } &&
6618          { ac_try='test -s conftest.$ac_objext'
6619   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6620   (eval $ac_try) 2>&5
6621   ac_status=$?
6622   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6623   (exit $ac_status); }; }; then
6624   ac_header_compiler=yes
6625 else
6626   echo "$as_me: failed program was:" >&5
6627 sed 's/^/| /' conftest.$ac_ext >&5
6628
6629 ac_header_compiler=no
6630 fi
6631 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6632 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6633 echo "${ECHO_T}$ac_header_compiler" >&6
6634
6635 # Is the header present?
6636 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6637 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6638 cat >conftest.$ac_ext <<_ACEOF
6639 /* confdefs.h.  */
6640 _ACEOF
6641 cat confdefs.h >>conftest.$ac_ext
6642 cat >>conftest.$ac_ext <<_ACEOF
6643 /* end confdefs.h.  */
6644 #include <$ac_header>
6645 _ACEOF
6646 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6647   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6648   ac_status=$?
6649   grep -v '^ *+' conftest.er1 >conftest.err
6650   rm -f conftest.er1
6651   cat conftest.err >&5
6652   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6653   (exit $ac_status); } >/dev/null; then
6654   if test -s conftest.err; then
6655     ac_cpp_err=$ac_c_preproc_warn_flag
6656     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6657   else
6658     ac_cpp_err=
6659   fi
6660 else
6661   ac_cpp_err=yes
6662 fi
6663 if test -z "$ac_cpp_err"; then
6664   ac_header_preproc=yes
6665 else
6666   echo "$as_me: failed program was:" >&5
6667 sed 's/^/| /' conftest.$ac_ext >&5
6668
6669   ac_header_preproc=no
6670 fi
6671 rm -f conftest.err conftest.$ac_ext
6672 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6673 echo "${ECHO_T}$ac_header_preproc" >&6
6674
6675 # So?  What about this header?
6676 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6677   yes:no: )
6678     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6679 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6680     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6681 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6682     ac_header_preproc=yes
6683     ;;
6684   no:yes:* )
6685     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6686 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6687     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6688 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6689     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6690 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6691     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6692 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6693     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6694 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6695     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6696 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6697     (
6698       cat <<\_ASBOX
6699 ## ------------------------------------------------------ ##
6700 ## Report this to the GNU Fortran Runtime Library lists.  ##
6701 ## ------------------------------------------------------ ##
6702 _ASBOX
6703     ) |
6704       sed "s/^/$as_me: WARNING:     /" >&2
6705     ;;
6706 esac
6707 echo "$as_me:$LINENO: checking for $ac_header" >&5
6708 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6709 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6710   echo $ECHO_N "(cached) $ECHO_C" >&6
6711 else
6712   eval "$as_ac_Header=\$ac_header_preproc"
6713 fi
6714 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6715 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6716
6717 fi
6718 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6719   cat >>confdefs.h <<_ACEOF
6720 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6721 _ACEOF
6722
6723 fi
6724
6725 done
6726
6727 if test "${ac_cv_header_complex_h+set}" = set; then
6728   echo "$as_me:$LINENO: checking for complex.h" >&5
6729 echo $ECHO_N "checking for complex.h... $ECHO_C" >&6
6730 if test "${ac_cv_header_complex_h+set}" = set; then
6731   echo $ECHO_N "(cached) $ECHO_C" >&6
6732 fi
6733 echo "$as_me:$LINENO: result: $ac_cv_header_complex_h" >&5
6734 echo "${ECHO_T}$ac_cv_header_complex_h" >&6
6735 else
6736   # Is the header compilable?
6737 echo "$as_me:$LINENO: checking complex.h usability" >&5
6738 echo $ECHO_N "checking complex.h usability... $ECHO_C" >&6
6739 cat >conftest.$ac_ext <<_ACEOF
6740 /* confdefs.h.  */
6741 _ACEOF
6742 cat confdefs.h >>conftest.$ac_ext
6743 cat >>conftest.$ac_ext <<_ACEOF
6744 /* end confdefs.h.  */
6745 $ac_includes_default
6746 #include <complex.h>
6747 _ACEOF
6748 rm -f conftest.$ac_objext
6749 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6750   (eval $ac_compile) 2>conftest.er1
6751   ac_status=$?
6752   grep -v '^ *+' conftest.er1 >conftest.err
6753   rm -f conftest.er1
6754   cat conftest.err >&5
6755   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6756   (exit $ac_status); } &&
6757          { ac_try='test -z "$ac_c_werror_flag"
6758                          || test ! -s conftest.err'
6759   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6760   (eval $ac_try) 2>&5
6761   ac_status=$?
6762   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6763   (exit $ac_status); }; } &&
6764          { ac_try='test -s conftest.$ac_objext'
6765   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6766   (eval $ac_try) 2>&5
6767   ac_status=$?
6768   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6769   (exit $ac_status); }; }; then
6770   ac_header_compiler=yes
6771 else
6772   echo "$as_me: failed program was:" >&5
6773 sed 's/^/| /' conftest.$ac_ext >&5
6774
6775 ac_header_compiler=no
6776 fi
6777 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6778 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6779 echo "${ECHO_T}$ac_header_compiler" >&6
6780
6781 # Is the header present?
6782 echo "$as_me:$LINENO: checking complex.h presence" >&5
6783 echo $ECHO_N "checking complex.h presence... $ECHO_C" >&6
6784 cat >conftest.$ac_ext <<_ACEOF
6785 /* confdefs.h.  */
6786 _ACEOF
6787 cat confdefs.h >>conftest.$ac_ext
6788 cat >>conftest.$ac_ext <<_ACEOF
6789 /* end confdefs.h.  */
6790 #include <complex.h>
6791 _ACEOF
6792 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6793   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6794   ac_status=$?
6795   grep -v '^ *+' conftest.er1 >conftest.err
6796   rm -f conftest.er1
6797   cat conftest.err >&5
6798   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6799   (exit $ac_status); } >/dev/null; then
6800   if test -s conftest.err; then
6801     ac_cpp_err=$ac_c_preproc_warn_flag
6802     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6803   else
6804     ac_cpp_err=
6805   fi
6806 else
6807   ac_cpp_err=yes
6808 fi
6809 if test -z "$ac_cpp_err"; then
6810   ac_header_preproc=yes
6811 else
6812   echo "$as_me: failed program was:" >&5
6813 sed 's/^/| /' conftest.$ac_ext >&5
6814
6815   ac_header_preproc=no
6816 fi
6817 rm -f conftest.err conftest.$ac_ext
6818 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6819 echo "${ECHO_T}$ac_header_preproc" >&6
6820
6821 # So?  What about this header?
6822 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6823   yes:no: )
6824     { echo "$as_me:$LINENO: WARNING: complex.h: accepted by the compiler, rejected by the preprocessor!" >&5
6825 echo "$as_me: WARNING: complex.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6826     { echo "$as_me:$LINENO: WARNING: complex.h: proceeding with the compiler's result" >&5
6827 echo "$as_me: WARNING: complex.h: proceeding with the compiler's result" >&2;}
6828     ac_header_preproc=yes
6829     ;;
6830   no:yes:* )
6831     { echo "$as_me:$LINENO: WARNING: complex.h: present but cannot be compiled" >&5
6832 echo "$as_me: WARNING: complex.h: present but cannot be compiled" >&2;}
6833     { echo "$as_me:$LINENO: WARNING: complex.h:     check for missing prerequisite headers?" >&5
6834 echo "$as_me: WARNING: complex.h:     check for missing prerequisite headers?" >&2;}
6835     { echo "$as_me:$LINENO: WARNING: complex.h: see the Autoconf documentation" >&5
6836 echo "$as_me: WARNING: complex.h: see the Autoconf documentation" >&2;}
6837     { echo "$as_me:$LINENO: WARNING: complex.h:     section \"Present But Cannot Be Compiled\"" >&5
6838 echo "$as_me: WARNING: complex.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6839     { echo "$as_me:$LINENO: WARNING: complex.h: proceeding with the preprocessor's result" >&5
6840 echo "$as_me: WARNING: complex.h: proceeding with the preprocessor's result" >&2;}
6841     { echo "$as_me:$LINENO: WARNING: complex.h: in the future, the compiler will take precedence" >&5
6842 echo "$as_me: WARNING: complex.h: in the future, the compiler will take precedence" >&2;}
6843     (
6844       cat <<\_ASBOX
6845 ## ------------------------------------------------------ ##
6846 ## Report this to the GNU Fortran Runtime Library lists.  ##
6847 ## ------------------------------------------------------ ##
6848 _ASBOX
6849     ) |
6850       sed "s/^/$as_me: WARNING:     /" >&2
6851     ;;
6852 esac
6853 echo "$as_me:$LINENO: checking for complex.h" >&5
6854 echo $ECHO_N "checking for complex.h... $ECHO_C" >&6
6855 if test "${ac_cv_header_complex_h+set}" = set; then
6856   echo $ECHO_N "(cached) $ECHO_C" >&6
6857 else
6858   ac_cv_header_complex_h=$ac_header_preproc
6859 fi
6860 echo "$as_me:$LINENO: result: $ac_cv_header_complex_h" >&5
6861 echo "${ECHO_T}$ac_cv_header_complex_h" >&6
6862
6863 fi
6864 if test $ac_cv_header_complex_h = yes; then
6865
6866 cat >>confdefs.h <<\_ACEOF
6867 #define HAVE_COMPLEX_H 1
6868 _ACEOF
6869
6870 fi
6871
6872
6873
6874
6875 inttype_headers=`echo inttypes.h sys/inttypes.h  | sed -e 's/,/ /g'`
6876
6877 acx_cv_header_stdint=stddef.h
6878 acx_cv_header_stdint_kind="(already complete)"
6879 for i in stdint.h $inttype_headers; do
6880   unset ac_cv_type_uintptr_t
6881   unset ac_cv_type_uintmax_t
6882   unset ac_cv_type_int_least32_t
6883   unset ac_cv_type_int_fast32_t
6884   unset ac_cv_type_uint64_t
6885   echo $ECHO_N "looking for a compliant stdint.h in $i, $ECHO_C" >&6
6886   echo "$as_me:$LINENO: checking for uintmax_t" >&5
6887 echo $ECHO_N "checking for uintmax_t... $ECHO_C" >&6
6888 if test "${ac_cv_type_uintmax_t+set}" = set; then
6889   echo $ECHO_N "(cached) $ECHO_C" >&6
6890 else
6891   cat >conftest.$ac_ext <<_ACEOF
6892 /* confdefs.h.  */
6893 _ACEOF
6894 cat confdefs.h >>conftest.$ac_ext
6895 cat >>conftest.$ac_ext <<_ACEOF
6896 /* end confdefs.h.  */
6897 #include <sys/types.h>
6898 #include <$i>
6899
6900 int
6901 main ()
6902 {
6903 if ((uintmax_t *) 0)
6904   return 0;
6905 if (sizeof (uintmax_t))
6906   return 0;
6907   ;
6908   return 0;
6909 }
6910 _ACEOF
6911 rm -f conftest.$ac_objext
6912 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6913   (eval $ac_compile) 2>conftest.er1
6914   ac_status=$?
6915   grep -v '^ *+' conftest.er1 >conftest.err
6916   rm -f conftest.er1
6917   cat conftest.err >&5
6918   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6919   (exit $ac_status); } &&
6920          { ac_try='test -z "$ac_c_werror_flag"
6921                          || test ! -s conftest.err'
6922   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6923   (eval $ac_try) 2>&5
6924   ac_status=$?
6925   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6926   (exit $ac_status); }; } &&
6927          { ac_try='test -s conftest.$ac_objext'
6928   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6929   (eval $ac_try) 2>&5
6930   ac_status=$?
6931   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6932   (exit $ac_status); }; }; then
6933   ac_cv_type_uintmax_t=yes
6934 else
6935   echo "$as_me: failed program was:" >&5
6936 sed 's/^/| /' conftest.$ac_ext >&5
6937
6938 ac_cv_type_uintmax_t=no
6939 fi
6940 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6941 fi
6942 echo "$as_me:$LINENO: result: $ac_cv_type_uintmax_t" >&5
6943 echo "${ECHO_T}$ac_cv_type_uintmax_t" >&6
6944 if test $ac_cv_type_uintmax_t = yes; then
6945   acx_cv_header_stdint=$i
6946 else
6947   continue
6948 fi
6949
6950   echo "$as_me:$LINENO: checking for uintptr_t" >&5
6951 echo $ECHO_N "checking for uintptr_t... $ECHO_C" >&6
6952 if test "${ac_cv_type_uintptr_t+set}" = set; then
6953   echo $ECHO_N "(cached) $ECHO_C" >&6
6954 else
6955   cat >conftest.$ac_ext <<_ACEOF
6956 /* confdefs.h.  */
6957 _ACEOF
6958 cat confdefs.h >>conftest.$ac_ext
6959 cat >>conftest.$ac_ext <<_ACEOF
6960 /* end confdefs.h.  */
6961 #include <sys/types.h>
6962 #include <$i>
6963
6964 int
6965 main ()
6966 {
6967 if ((uintptr_t *) 0)
6968   return 0;
6969 if (sizeof (uintptr_t))
6970   return 0;
6971   ;
6972   return 0;
6973 }
6974 _ACEOF
6975 rm -f conftest.$ac_objext
6976 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6977   (eval $ac_compile) 2>conftest.er1
6978   ac_status=$?
6979   grep -v '^ *+' conftest.er1 >conftest.err
6980   rm -f conftest.er1
6981   cat conftest.err >&5
6982   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6983   (exit $ac_status); } &&
6984          { ac_try='test -z "$ac_c_werror_flag"
6985                          || test ! -s conftest.err'
6986   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6987   (eval $ac_try) 2>&5
6988   ac_status=$?
6989   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6990   (exit $ac_status); }; } &&
6991          { ac_try='test -s conftest.$ac_objext'
6992   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6993   (eval $ac_try) 2>&5
6994   ac_status=$?
6995   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6996   (exit $ac_status); }; }; then
6997   ac_cv_type_uintptr_t=yes
6998 else
6999   echo "$as_me: failed program was:" >&5
7000 sed 's/^/| /' conftest.$ac_ext >&5
7001
7002 ac_cv_type_uintptr_t=no
7003 fi
7004 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7005 fi
7006 echo "$as_me:$LINENO: result: $ac_cv_type_uintptr_t" >&5
7007 echo "${ECHO_T}$ac_cv_type_uintptr_t" >&6
7008 if test $ac_cv_type_uintptr_t = yes; then
7009   :
7010 else
7011   acx_cv_header_stdint_kind="(mostly complete)"
7012 fi
7013
7014   echo "$as_me:$LINENO: checking for int_least32_t" >&5
7015 echo $ECHO_N "checking for int_least32_t... $ECHO_C" >&6
7016 if test "${ac_cv_type_int_least32_t+set}" = set; then
7017   echo $ECHO_N "(cached) $ECHO_C" >&6
7018 else
7019   cat >conftest.$ac_ext <<_ACEOF
7020 /* confdefs.h.  */
7021 _ACEOF
7022 cat confdefs.h >>conftest.$ac_ext
7023 cat >>conftest.$ac_ext <<_ACEOF
7024 /* end confdefs.h.  */
7025 #include <sys/types.h>
7026 #include <$i>
7027
7028 int
7029 main ()
7030 {
7031 if ((int_least32_t *) 0)
7032   return 0;
7033 if (sizeof (int_least32_t))
7034   return 0;
7035   ;
7036   return 0;
7037 }
7038 _ACEOF
7039 rm -f conftest.$ac_objext
7040 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7041   (eval $ac_compile) 2>conftest.er1
7042   ac_status=$?
7043   grep -v '^ *+' conftest.er1 >conftest.err
7044   rm -f conftest.er1
7045   cat conftest.err >&5
7046   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7047   (exit $ac_status); } &&
7048          { ac_try='test -z "$ac_c_werror_flag"
7049                          || test ! -s conftest.err'
7050   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7051   (eval $ac_try) 2>&5
7052   ac_status=$?
7053   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7054   (exit $ac_status); }; } &&
7055          { ac_try='test -s conftest.$ac_objext'
7056   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7057   (eval $ac_try) 2>&5
7058   ac_status=$?
7059   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7060   (exit $ac_status); }; }; then
7061   ac_cv_type_int_least32_t=yes
7062 else
7063   echo "$as_me: failed program was:" >&5
7064 sed 's/^/| /' conftest.$ac_ext >&5
7065
7066 ac_cv_type_int_least32_t=no
7067 fi
7068 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7069 fi
7070 echo "$as_me:$LINENO: result: $ac_cv_type_int_least32_t" >&5
7071 echo "${ECHO_T}$ac_cv_type_int_least32_t" >&6
7072 if test $ac_cv_type_int_least32_t = yes; then
7073   :
7074 else
7075   acx_cv_header_stdint_kind="(mostly complete)"
7076 fi
7077
7078   echo "$as_me:$LINENO: checking for int_fast32_t" >&5
7079 echo $ECHO_N "checking for int_fast32_t... $ECHO_C" >&6
7080 if test "${ac_cv_type_int_fast32_t+set}" = set; then
7081   echo $ECHO_N "(cached) $ECHO_C" >&6
7082 else
7083   cat >conftest.$ac_ext <<_ACEOF
7084 /* confdefs.h.  */
7085 _ACEOF
7086 cat confdefs.h >>conftest.$ac_ext
7087 cat >>conftest.$ac_ext <<_ACEOF
7088 /* end confdefs.h.  */
7089 #include <sys/types.h>
7090 #include <$i>
7091
7092 int
7093 main ()
7094 {
7095 if ((int_fast32_t *) 0)
7096   return 0;
7097 if (sizeof (int_fast32_t))
7098   return 0;
7099   ;
7100   return 0;
7101 }
7102 _ACEOF
7103 rm -f conftest.$ac_objext
7104 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7105   (eval $ac_compile) 2>conftest.er1
7106   ac_status=$?
7107   grep -v '^ *+' conftest.er1 >conftest.err
7108   rm -f conftest.er1
7109   cat conftest.err >&5
7110   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7111   (exit $ac_status); } &&
7112          { ac_try='test -z "$ac_c_werror_flag"
7113                          || test ! -s conftest.err'
7114   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7115   (eval $ac_try) 2>&5
7116   ac_status=$?
7117   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7118   (exit $ac_status); }; } &&
7119          { ac_try='test -s conftest.$ac_objext'
7120   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7121   (eval $ac_try) 2>&5
7122   ac_status=$?
7123   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7124   (exit $ac_status); }; }; then
7125   ac_cv_type_int_fast32_t=yes
7126 else
7127   echo "$as_me: failed program was:" >&5
7128 sed 's/^/| /' conftest.$ac_ext >&5
7129
7130 ac_cv_type_int_fast32_t=no
7131 fi
7132 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7133 fi
7134 echo "$as_me:$LINENO: result: $ac_cv_type_int_fast32_t" >&5
7135 echo "${ECHO_T}$ac_cv_type_int_fast32_t" >&6
7136 if test $ac_cv_type_int_fast32_t = yes; then
7137   :
7138 else
7139   acx_cv_header_stdint_kind="(mostly complete)"
7140 fi
7141
7142   echo "$as_me:$LINENO: checking for uint64_t" >&5
7143 echo $ECHO_N "checking for uint64_t... $ECHO_C" >&6
7144 if test "${ac_cv_type_uint64_t+set}" = set; then
7145   echo $ECHO_N "(cached) $ECHO_C" >&6
7146 else
7147   cat >conftest.$ac_ext <<_ACEOF
7148 /* confdefs.h.  */
7149 _ACEOF
7150 cat confdefs.h >>conftest.$ac_ext
7151 cat >>conftest.$ac_ext <<_ACEOF
7152 /* end confdefs.h.  */
7153 #include <sys/types.h>
7154 #include <$i>
7155
7156 int
7157 main ()
7158 {
7159 if ((uint64_t *) 0)
7160   return 0;
7161 if (sizeof (uint64_t))
7162   return 0;
7163   ;
7164   return 0;
7165 }
7166 _ACEOF
7167 rm -f conftest.$ac_objext
7168 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7169   (eval $ac_compile) 2>conftest.er1
7170   ac_status=$?
7171   grep -v '^ *+' conftest.er1 >conftest.err
7172   rm -f conftest.er1
7173   cat conftest.err >&5
7174   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7175   (exit $ac_status); } &&
7176          { ac_try='test -z "$ac_c_werror_flag"
7177                          || test ! -s conftest.err'
7178   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7179   (eval $ac_try) 2>&5
7180   ac_status=$?
7181   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7182   (exit $ac_status); }; } &&
7183          { ac_try='test -s conftest.$ac_objext'
7184   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7185   (eval $ac_try) 2>&5
7186   ac_status=$?
7187   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7188   (exit $ac_status); }; }; then
7189   ac_cv_type_uint64_t=yes
7190 else
7191   echo "$as_me: failed program was:" >&5
7192 sed 's/^/| /' conftest.$ac_ext >&5
7193
7194 ac_cv_type_uint64_t=no
7195 fi
7196 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7197 fi
7198 echo "$as_me:$LINENO: result: $ac_cv_type_uint64_t" >&5
7199 echo "${ECHO_T}$ac_cv_type_uint64_t" >&6
7200 if test $ac_cv_type_uint64_t = yes; then
7201   :
7202 else
7203   acx_cv_header_stdint_kind="(lacks uint64_t)"
7204 fi
7205
7206   break
7207 done
7208 if test "$acx_cv_header_stdint" = stddef.h; then
7209   acx_cv_header_stdint_kind="(lacks uintmax_t)"
7210   for i in stdint.h $inttype_headers; do
7211     unset ac_cv_type_uintptr_t
7212     unset ac_cv_type_uint32_t
7213     unset ac_cv_type_uint64_t
7214     echo $ECHO_N "looking for an incomplete stdint.h in $i, $ECHO_C" >&6
7215     echo "$as_me:$LINENO: checking for uint32_t" >&5
7216 echo $ECHO_N "checking for uint32_t... $ECHO_C" >&6
7217 if test "${ac_cv_type_uint32_t+set}" = set; then
7218   echo $ECHO_N "(cached) $ECHO_C" >&6
7219 else
7220   cat >conftest.$ac_ext <<_ACEOF
7221 /* confdefs.h.  */
7222 _ACEOF
7223 cat confdefs.h >>conftest.$ac_ext
7224 cat >>conftest.$ac_ext <<_ACEOF
7225 /* end confdefs.h.  */
7226 #include <sys/types.h>
7227 #include <$i>
7228
7229 int
7230 main ()
7231 {
7232 if ((uint32_t *) 0)
7233   return 0;
7234 if (sizeof (uint32_t))
7235   return 0;
7236   ;
7237   return 0;
7238 }
7239 _ACEOF
7240 rm -f conftest.$ac_objext
7241 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7242   (eval $ac_compile) 2>conftest.er1
7243   ac_status=$?
7244   grep -v '^ *+' conftest.er1 >conftest.err
7245   rm -f conftest.er1
7246   cat conftest.err >&5
7247   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7248   (exit $ac_status); } &&
7249          { ac_try='test -z "$ac_c_werror_flag"
7250                          || test ! -s conftest.err'
7251   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7252   (eval $ac_try) 2>&5
7253   ac_status=$?
7254   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7255   (exit $ac_status); }; } &&
7256          { ac_try='test -s conftest.$ac_objext'
7257   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7258   (eval $ac_try) 2>&5
7259   ac_status=$?
7260   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7261   (exit $ac_status); }; }; then
7262   ac_cv_type_uint32_t=yes
7263 else
7264   echo "$as_me: failed program was:" >&5
7265 sed 's/^/| /' conftest.$ac_ext >&5
7266
7267 ac_cv_type_uint32_t=no
7268 fi
7269 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7270 fi
7271 echo "$as_me:$LINENO: result: $ac_cv_type_uint32_t" >&5
7272 echo "${ECHO_T}$ac_cv_type_uint32_t" >&6
7273 if test $ac_cv_type_uint32_t = yes; then
7274   acx_cv_header_stdint=$i
7275 else
7276   continue
7277 fi
7278
7279     echo "$as_me:$LINENO: checking for uint64_t" >&5
7280 echo $ECHO_N "checking for uint64_t... $ECHO_C" >&6
7281 if test "${ac_cv_type_uint64_t+set}" = set; then
7282   echo $ECHO_N "(cached) $ECHO_C" >&6
7283 else
7284   cat >conftest.$ac_ext <<_ACEOF
7285 /* confdefs.h.  */
7286 _ACEOF
7287 cat confdefs.h >>conftest.$ac_ext
7288 cat >>conftest.$ac_ext <<_ACEOF
7289 /* end confdefs.h.  */
7290 #include <sys/types.h>
7291 #include <$i>
7292
7293 int
7294 main ()
7295 {
7296 if ((uint64_t *) 0)
7297   return 0;
7298 if (sizeof (uint64_t))
7299   return 0;
7300   ;
7301   return 0;
7302 }
7303 _ACEOF
7304 rm -f conftest.$ac_objext
7305 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7306   (eval $ac_compile) 2>conftest.er1
7307   ac_status=$?
7308   grep -v '^ *+' conftest.er1 >conftest.err
7309   rm -f conftest.er1
7310   cat conftest.err >&5
7311   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7312   (exit $ac_status); } &&
7313          { ac_try='test -z "$ac_c_werror_flag"
7314                          || test ! -s conftest.err'
7315   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7316   (eval $ac_try) 2>&5
7317   ac_status=$?
7318   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7319   (exit $ac_status); }; } &&
7320          { ac_try='test -s conftest.$ac_objext'
7321   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7322   (eval $ac_try) 2>&5
7323   ac_status=$?
7324   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7325   (exit $ac_status); }; }; then
7326   ac_cv_type_uint64_t=yes
7327 else
7328   echo "$as_me: failed program was:" >&5
7329 sed 's/^/| /' conftest.$ac_ext >&5
7330
7331 ac_cv_type_uint64_t=no
7332 fi
7333 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7334 fi
7335 echo "$as_me:$LINENO: result: $ac_cv_type_uint64_t" >&5
7336 echo "${ECHO_T}$ac_cv_type_uint64_t" >&6
7337
7338     echo "$as_me:$LINENO: checking for uintptr_t" >&5
7339 echo $ECHO_N "checking for uintptr_t... $ECHO_C" >&6
7340 if test "${ac_cv_type_uintptr_t+set}" = set; then
7341   echo $ECHO_N "(cached) $ECHO_C" >&6
7342 else
7343   cat >conftest.$ac_ext <<_ACEOF
7344 /* confdefs.h.  */
7345 _ACEOF
7346 cat confdefs.h >>conftest.$ac_ext
7347 cat >>conftest.$ac_ext <<_ACEOF
7348 /* end confdefs.h.  */
7349 #include <sys/types.h>
7350 #include <$i>
7351
7352 int
7353 main ()
7354 {
7355 if ((uintptr_t *) 0)
7356   return 0;
7357 if (sizeof (uintptr_t))
7358   return 0;
7359   ;
7360   return 0;
7361 }
7362 _ACEOF
7363 rm -f conftest.$ac_objext
7364 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7365   (eval $ac_compile) 2>conftest.er1
7366   ac_status=$?
7367   grep -v '^ *+' conftest.er1 >conftest.err
7368   rm -f conftest.er1
7369   cat conftest.err >&5
7370   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7371   (exit $ac_status); } &&
7372          { ac_try='test -z "$ac_c_werror_flag"
7373                          || test ! -s conftest.err'
7374   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7375   (eval $ac_try) 2>&5
7376   ac_status=$?
7377   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7378   (exit $ac_status); }; } &&
7379          { ac_try='test -s conftest.$ac_objext'
7380   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7381   (eval $ac_try) 2>&5
7382   ac_status=$?
7383   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7384   (exit $ac_status); }; }; then
7385   ac_cv_type_uintptr_t=yes
7386 else
7387   echo "$as_me: failed program was:" >&5
7388 sed 's/^/| /' conftest.$ac_ext >&5
7389
7390 ac_cv_type_uintptr_t=no
7391 fi
7392 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7393 fi
7394 echo "$as_me:$LINENO: result: $ac_cv_type_uintptr_t" >&5
7395 echo "${ECHO_T}$ac_cv_type_uintptr_t" >&6
7396
7397     break
7398   done
7399 fi
7400 if test "$acx_cv_header_stdint" = stddef.h; then
7401   acx_cv_header_stdint_kind="(u_intXX_t style)"
7402   for i in sys/types.h $inttype_headers; do
7403     unset ac_cv_type_u_int32_t
7404     unset ac_cv_type_u_int64_t
7405     echo $ECHO_N "looking for u_intXX_t types in $i, $ECHO_C" >&6
7406     echo "$as_me:$LINENO: checking for u_int32_t" >&5
7407 echo $ECHO_N "checking for u_int32_t... $ECHO_C" >&6
7408 if test "${ac_cv_type_u_int32_t+set}" = set; then
7409   echo $ECHO_N "(cached) $ECHO_C" >&6
7410 else
7411   cat >conftest.$ac_ext <<_ACEOF
7412 /* confdefs.h.  */
7413 _ACEOF
7414 cat confdefs.h >>conftest.$ac_ext
7415 cat >>conftest.$ac_ext <<_ACEOF
7416 /* end confdefs.h.  */
7417 #include <sys/types.h>
7418 #include <$i>
7419
7420 int
7421 main ()
7422 {
7423 if ((u_int32_t *) 0)
7424   return 0;
7425 if (sizeof (u_int32_t))
7426   return 0;
7427   ;
7428   return 0;
7429 }
7430 _ACEOF
7431 rm -f conftest.$ac_objext
7432 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7433   (eval $ac_compile) 2>conftest.er1
7434   ac_status=$?
7435   grep -v '^ *+' conftest.er1 >conftest.err
7436   rm -f conftest.er1
7437   cat conftest.err >&5
7438   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7439   (exit $ac_status); } &&
7440          { ac_try='test -z "$ac_c_werror_flag"
7441                          || test ! -s conftest.err'
7442   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7443   (eval $ac_try) 2>&5
7444   ac_status=$?
7445   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7446   (exit $ac_status); }; } &&
7447          { ac_try='test -s conftest.$ac_objext'
7448   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7449   (eval $ac_try) 2>&5
7450   ac_status=$?
7451   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7452   (exit $ac_status); }; }; then
7453   ac_cv_type_u_int32_t=yes
7454 else
7455   echo "$as_me: failed program was:" >&5
7456 sed 's/^/| /' conftest.$ac_ext >&5
7457
7458 ac_cv_type_u_int32_t=no
7459 fi
7460 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7461 fi
7462 echo "$as_me:$LINENO: result: $ac_cv_type_u_int32_t" >&5
7463 echo "${ECHO_T}$ac_cv_type_u_int32_t" >&6
7464 if test $ac_cv_type_u_int32_t = yes; then
7465   acx_cv_header_stdint=$i
7466 else
7467   continue
7468 fi
7469
7470     echo "$as_me:$LINENO: checking for u_int64_t" >&5
7471 echo $ECHO_N "checking for u_int64_t... $ECHO_C" >&6
7472 if test "${ac_cv_type_u_int64_t+set}" = set; then
7473   echo $ECHO_N "(cached) $ECHO_C" >&6
7474 else
7475   cat >conftest.$ac_ext <<_ACEOF
7476 /* confdefs.h.  */
7477 _ACEOF
7478 cat confdefs.h >>conftest.$ac_ext
7479 cat >>conftest.$ac_ext <<_ACEOF
7480 /* end confdefs.h.  */
7481 #include <sys/types.h>
7482 #include <$i>
7483
7484 int
7485 main ()
7486 {
7487 if ((u_int64_t *) 0)
7488   return 0;
7489 if (sizeof (u_int64_t))
7490   return 0;
7491   ;
7492   return 0;
7493 }
7494 _ACEOF
7495 rm -f conftest.$ac_objext
7496 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7497   (eval $ac_compile) 2>conftest.er1
7498   ac_status=$?
7499   grep -v '^ *+' conftest.er1 >conftest.err
7500   rm -f conftest.er1
7501   cat conftest.err >&5
7502   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7503   (exit $ac_status); } &&
7504          { ac_try='test -z "$ac_c_werror_flag"
7505                          || test ! -s conftest.err'
7506   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7507   (eval $ac_try) 2>&5
7508   ac_status=$?
7509   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7510   (exit $ac_status); }; } &&
7511          { ac_try='test -s conftest.$ac_objext'
7512   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7513   (eval $ac_try) 2>&5
7514   ac_status=$?
7515   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7516   (exit $ac_status); }; }; then
7517   ac_cv_type_u_int64_t=yes
7518 else
7519   echo "$as_me: failed program was:" >&5
7520 sed 's/^/| /' conftest.$ac_ext >&5
7521
7522 ac_cv_type_u_int64_t=no
7523 fi
7524 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7525 fi
7526 echo "$as_me:$LINENO: result: $ac_cv_type_u_int64_t" >&5
7527 echo "${ECHO_T}$ac_cv_type_u_int64_t" >&6
7528
7529     break
7530   done
7531 fi
7532 if test "$acx_cv_header_stdint" = stddef.h; then
7533   acx_cv_header_stdint_kind="(using manual detection)"
7534 fi
7535
7536 test -z "$ac_cv_type_uintptr_t" && ac_cv_type_uintptr_t=no
7537 test -z "$ac_cv_type_uint64_t" && ac_cv_type_uint64_t=no
7538 test -z "$ac_cv_type_u_int64_t" && ac_cv_type_u_int64_t=no
7539 test -z "$ac_cv_type_int_least32_t" && ac_cv_type_int_least32_t=no
7540 test -z "$ac_cv_type_int_fast32_t" && ac_cv_type_int_fast32_t=no
7541
7542 # ----------------- Summarize what we found so far
7543
7544 echo "$as_me:$LINENO: checking what to include in gstdint.h" >&5
7545 echo $ECHO_N "checking what to include in gstdint.h... $ECHO_C" >&6
7546
7547 case `$as_basename gstdint.h ||
7548 $as_expr X/gstdint.h : '.*/\([^/][^/]*\)/*$' \| \
7549          Xgstdint.h : 'X\(//\)$' \| \
7550          Xgstdint.h : 'X\(/\)$' \| \
7551          .     : '\(.\)' 2>/dev/null ||
7552 echo X/gstdint.h |
7553     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
7554           /^X\/\(\/\/\)$/{ s//\1/; q; }
7555           /^X\/\(\/\).*/{ s//\1/; q; }
7556           s/.*/./; q'` in
7557   stdint.h) { echo "$as_me:$LINENO: WARNING: are you sure you want it there?" >&5
7558 echo "$as_me: WARNING: are you sure you want it there?" >&2;} ;;
7559   inttypes.h) { echo "$as_me:$LINENO: WARNING: are you sure you want it there?" >&5
7560 echo "$as_me: WARNING: are you sure you want it there?" >&2;} ;;
7561   *) ;;
7562 esac
7563
7564 echo "$as_me:$LINENO: result: $acx_cv_header_stdint $acx_cv_header_stdint_kind" >&5
7565 echo "${ECHO_T}$acx_cv_header_stdint $acx_cv_header_stdint_kind" >&6
7566
7567 # ----------------- done included file, check C basic types --------
7568
7569 # Lacking an uintptr_t?  Test size of void *
7570 case "$acx_cv_header_stdint:$ac_cv_type_uintptr_t" in
7571   stddef.h:* | *:no) echo "$as_me:$LINENO: checking for void *" >&5
7572 echo $ECHO_N "checking for void *... $ECHO_C" >&6
7573 if test "${ac_cv_type_void_p+set}" = set; then
7574   echo $ECHO_N "(cached) $ECHO_C" >&6
7575 else
7576   cat >conftest.$ac_ext <<_ACEOF
7577 /* confdefs.h.  */
7578 _ACEOF
7579 cat confdefs.h >>conftest.$ac_ext
7580 cat >>conftest.$ac_ext <<_ACEOF
7581 /* end confdefs.h.  */
7582 $ac_includes_default
7583 int
7584 main ()
7585 {
7586 if ((void * *) 0)
7587   return 0;
7588 if (sizeof (void *))
7589   return 0;
7590   ;
7591   return 0;
7592 }
7593 _ACEOF
7594 rm -f conftest.$ac_objext
7595 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7596   (eval $ac_compile) 2>conftest.er1
7597   ac_status=$?
7598   grep -v '^ *+' conftest.er1 >conftest.err
7599   rm -f conftest.er1
7600   cat conftest.err >&5
7601   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7602   (exit $ac_status); } &&
7603          { ac_try='test -z "$ac_c_werror_flag"
7604                          || test ! -s conftest.err'
7605   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7606   (eval $ac_try) 2>&5
7607   ac_status=$?
7608   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7609   (exit $ac_status); }; } &&
7610          { ac_try='test -s conftest.$ac_objext'
7611   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7612   (eval $ac_try) 2>&5
7613   ac_status=$?
7614   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7615   (exit $ac_status); }; }; then
7616   ac_cv_type_void_p=yes
7617 else
7618   echo "$as_me: failed program was:" >&5
7619 sed 's/^/| /' conftest.$ac_ext >&5
7620
7621 ac_cv_type_void_p=no
7622 fi
7623 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7624 fi
7625 echo "$as_me:$LINENO: result: $ac_cv_type_void_p" >&5
7626 echo "${ECHO_T}$ac_cv_type_void_p" >&6
7627
7628 echo "$as_me:$LINENO: checking size of void *" >&5
7629 echo $ECHO_N "checking size of void *... $ECHO_C" >&6
7630 if test "${ac_cv_sizeof_void_p+set}" = set; then
7631   echo $ECHO_N "(cached) $ECHO_C" >&6
7632 else
7633   if test "$ac_cv_type_void_p" = yes; then
7634   # The cast to unsigned long works around a bug in the HP C Compiler
7635   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
7636   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
7637   # This bug is HP SR number 8606223364.
7638   if test "$cross_compiling" = yes; then
7639   # Depending upon the size, compute the lo and hi bounds.
7640 cat >conftest.$ac_ext <<_ACEOF
7641 /* confdefs.h.  */
7642 _ACEOF
7643 cat confdefs.h >>conftest.$ac_ext
7644 cat >>conftest.$ac_ext <<_ACEOF
7645 /* end confdefs.h.  */
7646 $ac_includes_default
7647 int
7648 main ()
7649 {
7650 static int test_array [1 - 2 * !(((long) (sizeof (void *))) >= 0)];
7651 test_array [0] = 0
7652
7653   ;
7654   return 0;
7655 }
7656 _ACEOF
7657 rm -f conftest.$ac_objext
7658 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7659   (eval $ac_compile) 2>conftest.er1
7660   ac_status=$?
7661   grep -v '^ *+' conftest.er1 >conftest.err
7662   rm -f conftest.er1
7663   cat conftest.err >&5
7664   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7665   (exit $ac_status); } &&
7666          { ac_try='test -z "$ac_c_werror_flag"
7667                          || test ! -s conftest.err'
7668   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7669   (eval $ac_try) 2>&5
7670   ac_status=$?
7671   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7672   (exit $ac_status); }; } &&
7673          { ac_try='test -s conftest.$ac_objext'
7674   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7675   (eval $ac_try) 2>&5
7676   ac_status=$?
7677   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7678   (exit $ac_status); }; }; then
7679   ac_lo=0 ac_mid=0
7680   while :; do
7681     cat >conftest.$ac_ext <<_ACEOF
7682 /* confdefs.h.  */
7683 _ACEOF
7684 cat confdefs.h >>conftest.$ac_ext
7685 cat >>conftest.$ac_ext <<_ACEOF
7686 /* end confdefs.h.  */
7687 $ac_includes_default
7688 int
7689 main ()
7690 {
7691 static int test_array [1 - 2 * !(((long) (sizeof (void *))) <= $ac_mid)];
7692 test_array [0] = 0
7693
7694   ;
7695   return 0;
7696 }
7697 _ACEOF
7698 rm -f conftest.$ac_objext
7699 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7700   (eval $ac_compile) 2>conftest.er1
7701   ac_status=$?
7702   grep -v '^ *+' conftest.er1 >conftest.err
7703   rm -f conftest.er1
7704   cat conftest.err >&5
7705   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7706   (exit $ac_status); } &&
7707          { ac_try='test -z "$ac_c_werror_flag"
7708                          || test ! -s conftest.err'
7709   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7710   (eval $ac_try) 2>&5
7711   ac_status=$?
7712   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7713   (exit $ac_status); }; } &&
7714          { ac_try='test -s conftest.$ac_objext'
7715   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7716   (eval $ac_try) 2>&5
7717   ac_status=$?
7718   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7719   (exit $ac_status); }; }; then
7720   ac_hi=$ac_mid; break
7721 else
7722   echo "$as_me: failed program was:" >&5
7723 sed 's/^/| /' conftest.$ac_ext >&5
7724
7725 ac_lo=`expr $ac_mid + 1`
7726                     if test $ac_lo -le $ac_mid; then
7727                       ac_lo= ac_hi=
7728                       break
7729                     fi
7730                     ac_mid=`expr 2 '*' $ac_mid + 1`
7731 fi
7732 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7733   done
7734 else
7735   echo "$as_me: failed program was:" >&5
7736 sed 's/^/| /' conftest.$ac_ext >&5
7737
7738 cat >conftest.$ac_ext <<_ACEOF
7739 /* confdefs.h.  */
7740 _ACEOF
7741 cat confdefs.h >>conftest.$ac_ext
7742 cat >>conftest.$ac_ext <<_ACEOF
7743 /* end confdefs.h.  */
7744 $ac_includes_default
7745 int
7746 main ()
7747 {
7748 static int test_array [1 - 2 * !(((long) (sizeof (void *))) < 0)];
7749 test_array [0] = 0
7750
7751   ;
7752   return 0;
7753 }
7754 _ACEOF
7755 rm -f conftest.$ac_objext
7756 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7757   (eval $ac_compile) 2>conftest.er1
7758   ac_status=$?
7759   grep -v '^ *+' conftest.er1 >conftest.err
7760   rm -f conftest.er1
7761   cat conftest.err >&5
7762   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7763   (exit $ac_status); } &&
7764          { ac_try='test -z "$ac_c_werror_flag"
7765                          || test ! -s conftest.err'
7766   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7767   (eval $ac_try) 2>&5
7768   ac_status=$?
7769   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7770   (exit $ac_status); }; } &&
7771          { ac_try='test -s conftest.$ac_objext'
7772   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7773   (eval $ac_try) 2>&5
7774   ac_status=$?
7775   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7776   (exit $ac_status); }; }; then
7777   ac_hi=-1 ac_mid=-1
7778   while :; do
7779     cat >conftest.$ac_ext <<_ACEOF
7780 /* confdefs.h.  */
7781 _ACEOF
7782 cat confdefs.h >>conftest.$ac_ext
7783 cat >>conftest.$ac_ext <<_ACEOF
7784 /* end confdefs.h.  */
7785 $ac_includes_default
7786 int
7787 main ()
7788 {
7789 static int test_array [1 - 2 * !(((long) (sizeof (void *))) >= $ac_mid)];
7790 test_array [0] = 0
7791
7792   ;
7793   return 0;
7794 }
7795 _ACEOF
7796 rm -f conftest.$ac_objext
7797 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7798   (eval $ac_compile) 2>conftest.er1
7799   ac_status=$?
7800   grep -v '^ *+' conftest.er1 >conftest.err
7801   rm -f conftest.er1
7802   cat conftest.err >&5
7803   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7804   (exit $ac_status); } &&
7805          { ac_try='test -z "$ac_c_werror_flag"
7806                          || test ! -s conftest.err'
7807   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7808   (eval $ac_try) 2>&5
7809   ac_status=$?
7810   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7811   (exit $ac_status); }; } &&
7812          { ac_try='test -s conftest.$ac_objext'
7813   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7814   (eval $ac_try) 2>&5
7815   ac_status=$?
7816   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7817   (exit $ac_status); }; }; then
7818   ac_lo=$ac_mid; break
7819 else
7820   echo "$as_me: failed program was:" >&5
7821 sed 's/^/| /' conftest.$ac_ext >&5
7822
7823 ac_hi=`expr '(' $ac_mid ')' - 1`
7824                        if test $ac_mid -le $ac_hi; then
7825                          ac_lo= ac_hi=
7826                          break
7827                        fi
7828                        ac_mid=`expr 2 '*' $ac_mid`
7829 fi
7830 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7831   done
7832 else
7833   echo "$as_me: failed program was:" >&5
7834 sed 's/^/| /' conftest.$ac_ext >&5
7835
7836 ac_lo= ac_hi=
7837 fi
7838 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7839 fi
7840 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7841 # Binary search between lo and hi bounds.
7842 while test "x$ac_lo" != "x$ac_hi"; do
7843   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
7844   cat >conftest.$ac_ext <<_ACEOF
7845 /* confdefs.h.  */
7846 _ACEOF
7847 cat confdefs.h >>conftest.$ac_ext
7848 cat >>conftest.$ac_ext <<_ACEOF
7849 /* end confdefs.h.  */
7850 $ac_includes_default
7851 int
7852 main ()
7853 {
7854 static int test_array [1 - 2 * !(((long) (sizeof (void *))) <= $ac_mid)];
7855 test_array [0] = 0
7856
7857   ;
7858   return 0;
7859 }
7860 _ACEOF
7861 rm -f conftest.$ac_objext
7862 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7863   (eval $ac_compile) 2>conftest.er1
7864   ac_status=$?
7865   grep -v '^ *+' conftest.er1 >conftest.err
7866   rm -f conftest.er1
7867   cat conftest.err >&5
7868   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7869   (exit $ac_status); } &&
7870          { ac_try='test -z "$ac_c_werror_flag"
7871                          || test ! -s conftest.err'
7872   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7873   (eval $ac_try) 2>&5
7874   ac_status=$?
7875   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7876   (exit $ac_status); }; } &&
7877          { ac_try='test -s conftest.$ac_objext'
7878   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7879   (eval $ac_try) 2>&5
7880   ac_status=$?
7881   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7882   (exit $ac_status); }; }; then
7883   ac_hi=$ac_mid
7884 else
7885   echo "$as_me: failed program was:" >&5
7886 sed 's/^/| /' conftest.$ac_ext >&5
7887
7888 ac_lo=`expr '(' $ac_mid ')' + 1`
7889 fi
7890 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7891 done
7892 case $ac_lo in
7893 ?*) ac_cv_sizeof_void_p=$ac_lo;;
7894 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (void *), 77
7895 See \`config.log' for more details." >&5
7896 echo "$as_me: error: cannot compute sizeof (void *), 77
7897 See \`config.log' for more details." >&2;}
7898    { (exit 1); exit 1; }; } ;;
7899 esac
7900 else
7901   if test "$cross_compiling" = yes; then
7902   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
7903 See \`config.log' for more details." >&5
7904 echo "$as_me: error: cannot run test program while cross compiling
7905 See \`config.log' for more details." >&2;}
7906    { (exit 1); exit 1; }; }
7907 else
7908   cat >conftest.$ac_ext <<_ACEOF
7909 /* confdefs.h.  */
7910 _ACEOF
7911 cat confdefs.h >>conftest.$ac_ext
7912 cat >>conftest.$ac_ext <<_ACEOF
7913 /* end confdefs.h.  */
7914 $ac_includes_default
7915 long longval () { return (long) (sizeof (void *)); }
7916 unsigned long ulongval () { return (long) (sizeof (void *)); }
7917 #include <stdio.h>
7918 #include <stdlib.h>
7919 int
7920 main ()
7921 {
7922
7923   FILE *f = fopen ("conftest.val", "w");
7924   if (! f)
7925     exit (1);
7926   if (((long) (sizeof (void *))) < 0)
7927     {
7928       long i = longval ();
7929       if (i != ((long) (sizeof (void *))))
7930         exit (1);
7931       fprintf (f, "%ld\n", i);
7932     }
7933   else
7934     {
7935       unsigned long i = ulongval ();
7936       if (i != ((long) (sizeof (void *))))
7937         exit (1);
7938       fprintf (f, "%lu\n", i);
7939     }
7940   exit (ferror (f) || fclose (f) != 0);
7941
7942   ;
7943   return 0;
7944 }
7945 _ACEOF
7946 rm -f conftest$ac_exeext
7947 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7948   (eval $ac_link) 2>&5
7949   ac_status=$?
7950   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7951   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7952   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7953   (eval $ac_try) 2>&5
7954   ac_status=$?
7955   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7956   (exit $ac_status); }; }; then
7957   ac_cv_sizeof_void_p=`cat conftest.val`
7958 else
7959   echo "$as_me: program exited with status $ac_status" >&5
7960 echo "$as_me: failed program was:" >&5
7961 sed 's/^/| /' conftest.$ac_ext >&5
7962
7963 ( exit $ac_status )
7964 { { echo "$as_me:$LINENO: error: cannot compute sizeof (void *), 77
7965 See \`config.log' for more details." >&5
7966 echo "$as_me: error: cannot compute sizeof (void *), 77
7967 See \`config.log' for more details." >&2;}
7968    { (exit 1); exit 1; }; }
7969 fi
7970 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7971 fi
7972 fi
7973 rm -f conftest.val
7974 else
7975   ac_cv_sizeof_void_p=0
7976 fi
7977 fi
7978 echo "$as_me:$LINENO: result: $ac_cv_sizeof_void_p" >&5
7979 echo "${ECHO_T}$ac_cv_sizeof_void_p" >&6
7980 cat >>confdefs.h <<_ACEOF
7981 #define SIZEOF_VOID_P $ac_cv_sizeof_void_p
7982 _ACEOF
7983
7984  ;;
7985 esac
7986
7987 # Lacking an uint64_t?  Test size of long
7988 case "$acx_cv_header_stdint:$ac_cv_type_uint64_t:$ac_cv_type_u_int64_t" in
7989   stddef.h:*:* | *:no:no) echo "$as_me:$LINENO: checking for long" >&5
7990 echo $ECHO_N "checking for long... $ECHO_C" >&6
7991 if test "${ac_cv_type_long+set}" = set; then
7992   echo $ECHO_N "(cached) $ECHO_C" >&6
7993 else
7994   cat >conftest.$ac_ext <<_ACEOF
7995 /* confdefs.h.  */
7996 _ACEOF
7997 cat confdefs.h >>conftest.$ac_ext
7998 cat >>conftest.$ac_ext <<_ACEOF
7999 /* end confdefs.h.  */
8000 $ac_includes_default
8001 int
8002 main ()
8003 {
8004 if ((long *) 0)
8005   return 0;
8006 if (sizeof (long))
8007   return 0;
8008   ;
8009   return 0;
8010 }
8011 _ACEOF
8012 rm -f conftest.$ac_objext
8013 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8014   (eval $ac_compile) 2>conftest.er1
8015   ac_status=$?
8016   grep -v '^ *+' conftest.er1 >conftest.err
8017   rm -f conftest.er1
8018   cat conftest.err >&5
8019   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8020   (exit $ac_status); } &&
8021          { ac_try='test -z "$ac_c_werror_flag"
8022                          || test ! -s conftest.err'
8023   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8024   (eval $ac_try) 2>&5
8025   ac_status=$?
8026   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8027   (exit $ac_status); }; } &&
8028          { ac_try='test -s conftest.$ac_objext'
8029   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8030   (eval $ac_try) 2>&5
8031   ac_status=$?
8032   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8033   (exit $ac_status); }; }; then
8034   ac_cv_type_long=yes
8035 else
8036   echo "$as_me: failed program was:" >&5
8037 sed 's/^/| /' conftest.$ac_ext >&5
8038
8039 ac_cv_type_long=no
8040 fi
8041 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8042 fi
8043 echo "$as_me:$LINENO: result: $ac_cv_type_long" >&5
8044 echo "${ECHO_T}$ac_cv_type_long" >&6
8045
8046 echo "$as_me:$LINENO: checking size of long" >&5
8047 echo $ECHO_N "checking size of long... $ECHO_C" >&6
8048 if test "${ac_cv_sizeof_long+set}" = set; then
8049   echo $ECHO_N "(cached) $ECHO_C" >&6
8050 else
8051   if test "$ac_cv_type_long" = yes; then
8052   # The cast to unsigned long works around a bug in the HP C Compiler
8053   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
8054   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
8055   # This bug is HP SR number 8606223364.
8056   if test "$cross_compiling" = yes; then
8057   # Depending upon the size, compute the lo and hi bounds.
8058 cat >conftest.$ac_ext <<_ACEOF
8059 /* confdefs.h.  */
8060 _ACEOF
8061 cat confdefs.h >>conftest.$ac_ext
8062 cat >>conftest.$ac_ext <<_ACEOF
8063 /* end confdefs.h.  */
8064 $ac_includes_default
8065 int
8066 main ()
8067 {
8068 static int test_array [1 - 2 * !(((long) (sizeof (long))) >= 0)];
8069 test_array [0] = 0
8070
8071   ;
8072   return 0;
8073 }
8074 _ACEOF
8075 rm -f conftest.$ac_objext
8076 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8077   (eval $ac_compile) 2>conftest.er1
8078   ac_status=$?
8079   grep -v '^ *+' conftest.er1 >conftest.err
8080   rm -f conftest.er1
8081   cat conftest.err >&5
8082   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8083   (exit $ac_status); } &&
8084          { ac_try='test -z "$ac_c_werror_flag"
8085                          || test ! -s conftest.err'
8086   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8087   (eval $ac_try) 2>&5
8088   ac_status=$?
8089   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8090   (exit $ac_status); }; } &&
8091          { ac_try='test -s conftest.$ac_objext'
8092   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8093   (eval $ac_try) 2>&5
8094   ac_status=$?
8095   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8096   (exit $ac_status); }; }; then
8097   ac_lo=0 ac_mid=0
8098   while :; do
8099     cat >conftest.$ac_ext <<_ACEOF
8100 /* confdefs.h.  */
8101 _ACEOF
8102 cat confdefs.h >>conftest.$ac_ext
8103 cat >>conftest.$ac_ext <<_ACEOF
8104 /* end confdefs.h.  */
8105 $ac_includes_default
8106 int
8107 main ()
8108 {
8109 static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];
8110 test_array [0] = 0
8111
8112   ;
8113   return 0;
8114 }
8115 _ACEOF
8116 rm -f conftest.$ac_objext
8117 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8118   (eval $ac_compile) 2>conftest.er1
8119   ac_status=$?
8120   grep -v '^ *+' conftest.er1 >conftest.err
8121   rm -f conftest.er1
8122   cat conftest.err >&5
8123   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8124   (exit $ac_status); } &&
8125          { ac_try='test -z "$ac_c_werror_flag"
8126                          || test ! -s conftest.err'
8127   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8128   (eval $ac_try) 2>&5
8129   ac_status=$?
8130   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8131   (exit $ac_status); }; } &&
8132          { ac_try='test -s conftest.$ac_objext'
8133   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8134   (eval $ac_try) 2>&5
8135   ac_status=$?
8136   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8137   (exit $ac_status); }; }; then
8138   ac_hi=$ac_mid; break
8139 else
8140   echo "$as_me: failed program was:" >&5
8141 sed 's/^/| /' conftest.$ac_ext >&5
8142
8143 ac_lo=`expr $ac_mid + 1`
8144                     if test $ac_lo -le $ac_mid; then
8145                       ac_lo= ac_hi=
8146                       break
8147                     fi
8148                     ac_mid=`expr 2 '*' $ac_mid + 1`
8149 fi
8150 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8151   done
8152 else
8153   echo "$as_me: failed program was:" >&5
8154 sed 's/^/| /' conftest.$ac_ext >&5
8155
8156 cat >conftest.$ac_ext <<_ACEOF
8157 /* confdefs.h.  */
8158 _ACEOF
8159 cat confdefs.h >>conftest.$ac_ext
8160 cat >>conftest.$ac_ext <<_ACEOF
8161 /* end confdefs.h.  */
8162 $ac_includes_default
8163 int
8164 main ()
8165 {
8166 static int test_array [1 - 2 * !(((long) (sizeof (long))) < 0)];
8167 test_array [0] = 0
8168
8169   ;
8170   return 0;
8171 }
8172 _ACEOF
8173 rm -f conftest.$ac_objext
8174 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8175   (eval $ac_compile) 2>conftest.er1
8176   ac_status=$?
8177   grep -v '^ *+' conftest.er1 >conftest.err
8178   rm -f conftest.er1
8179   cat conftest.err >&5
8180   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8181   (exit $ac_status); } &&
8182          { ac_try='test -z "$ac_c_werror_flag"
8183                          || test ! -s conftest.err'
8184   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8185   (eval $ac_try) 2>&5
8186   ac_status=$?
8187   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8188   (exit $ac_status); }; } &&
8189          { ac_try='test -s conftest.$ac_objext'
8190   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8191   (eval $ac_try) 2>&5
8192   ac_status=$?
8193   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8194   (exit $ac_status); }; }; then
8195   ac_hi=-1 ac_mid=-1
8196   while :; do
8197     cat >conftest.$ac_ext <<_ACEOF
8198 /* confdefs.h.  */
8199 _ACEOF
8200 cat confdefs.h >>conftest.$ac_ext
8201 cat >>conftest.$ac_ext <<_ACEOF
8202 /* end confdefs.h.  */
8203 $ac_includes_default
8204 int
8205 main ()
8206 {
8207 static int test_array [1 - 2 * !(((long) (sizeof (long))) >= $ac_mid)];
8208 test_array [0] = 0
8209
8210   ;
8211   return 0;
8212 }
8213 _ACEOF
8214 rm -f conftest.$ac_objext
8215 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8216   (eval $ac_compile) 2>conftest.er1
8217   ac_status=$?
8218   grep -v '^ *+' conftest.er1 >conftest.err
8219   rm -f conftest.er1
8220   cat conftest.err >&5
8221   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8222   (exit $ac_status); } &&
8223          { ac_try='test -z "$ac_c_werror_flag"
8224                          || test ! -s conftest.err'
8225   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8226   (eval $ac_try) 2>&5
8227   ac_status=$?
8228   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8229   (exit $ac_status); }; } &&
8230          { ac_try='test -s conftest.$ac_objext'
8231   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8232   (eval $ac_try) 2>&5
8233   ac_status=$?
8234   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8235   (exit $ac_status); }; }; then
8236   ac_lo=$ac_mid; break
8237 else
8238   echo "$as_me: failed program was:" >&5
8239 sed 's/^/| /' conftest.$ac_ext >&5
8240
8241 ac_hi=`expr '(' $ac_mid ')' - 1`
8242                        if test $ac_mid -le $ac_hi; then
8243                          ac_lo= ac_hi=
8244                          break
8245                        fi
8246                        ac_mid=`expr 2 '*' $ac_mid`
8247 fi
8248 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8249   done
8250 else
8251   echo "$as_me: failed program was:" >&5
8252 sed 's/^/| /' conftest.$ac_ext >&5
8253
8254 ac_lo= ac_hi=
8255 fi
8256 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8257 fi
8258 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8259 # Binary search between lo and hi bounds.
8260 while test "x$ac_lo" != "x$ac_hi"; do
8261   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
8262   cat >conftest.$ac_ext <<_ACEOF
8263 /* confdefs.h.  */
8264 _ACEOF
8265 cat confdefs.h >>conftest.$ac_ext
8266 cat >>conftest.$ac_ext <<_ACEOF
8267 /* end confdefs.h.  */
8268 $ac_includes_default
8269 int
8270 main ()
8271 {
8272 static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];
8273 test_array [0] = 0
8274
8275   ;
8276   return 0;
8277 }
8278 _ACEOF
8279 rm -f conftest.$ac_objext
8280 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8281   (eval $ac_compile) 2>conftest.er1
8282   ac_status=$?
8283   grep -v '^ *+' conftest.er1 >conftest.err
8284   rm -f conftest.er1
8285   cat conftest.err >&5
8286   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8287   (exit $ac_status); } &&
8288          { ac_try='test -z "$ac_c_werror_flag"
8289                          || test ! -s conftest.err'
8290   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8291   (eval $ac_try) 2>&5
8292   ac_status=$?
8293   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8294   (exit $ac_status); }; } &&
8295          { ac_try='test -s conftest.$ac_objext'
8296   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8297   (eval $ac_try) 2>&5
8298   ac_status=$?
8299   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8300   (exit $ac_status); }; }; then
8301   ac_hi=$ac_mid
8302 else
8303   echo "$as_me: failed program was:" >&5
8304 sed 's/^/| /' conftest.$ac_ext >&5
8305
8306 ac_lo=`expr '(' $ac_mid ')' + 1`
8307 fi
8308 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8309 done
8310 case $ac_lo in
8311 ?*) ac_cv_sizeof_long=$ac_lo;;
8312 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77
8313 See \`config.log' for more details." >&5
8314 echo "$as_me: error: cannot compute sizeof (long), 77
8315 See \`config.log' for more details." >&2;}
8316    { (exit 1); exit 1; }; } ;;
8317 esac
8318 else
8319   if test "$cross_compiling" = yes; then
8320   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
8321 See \`config.log' for more details." >&5
8322 echo "$as_me: error: cannot run test program while cross compiling
8323 See \`config.log' for more details." >&2;}
8324    { (exit 1); exit 1; }; }
8325 else
8326   cat >conftest.$ac_ext <<_ACEOF
8327 /* confdefs.h.  */
8328 _ACEOF
8329 cat confdefs.h >>conftest.$ac_ext
8330 cat >>conftest.$ac_ext <<_ACEOF
8331 /* end confdefs.h.  */
8332 $ac_includes_default
8333 long longval () { return (long) (sizeof (long)); }
8334 unsigned long ulongval () { return (long) (sizeof (long)); }
8335 #include <stdio.h>
8336 #include <stdlib.h>
8337 int
8338 main ()
8339 {
8340
8341   FILE *f = fopen ("conftest.val", "w");
8342   if (! f)
8343     exit (1);
8344   if (((long) (sizeof (long))) < 0)
8345     {
8346       long i = longval ();
8347       if (i != ((long) (sizeof (long))))
8348         exit (1);
8349       fprintf (f, "%ld\n", i);
8350     }
8351   else
8352     {
8353       unsigned long i = ulongval ();
8354       if (i != ((long) (sizeof (long))))
8355         exit (1);
8356       fprintf (f, "%lu\n", i);
8357     }
8358   exit (ferror (f) || fclose (f) != 0);
8359
8360   ;
8361   return 0;
8362 }
8363 _ACEOF
8364 rm -f conftest$ac_exeext
8365 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8366   (eval $ac_link) 2>&5
8367   ac_status=$?
8368   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8369   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8370   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8371   (eval $ac_try) 2>&5
8372   ac_status=$?
8373   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8374   (exit $ac_status); }; }; then
8375   ac_cv_sizeof_long=`cat conftest.val`
8376 else
8377   echo "$as_me: program exited with status $ac_status" >&5
8378 echo "$as_me: failed program was:" >&5
8379 sed 's/^/| /' conftest.$ac_ext >&5
8380
8381 ( exit $ac_status )
8382 { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77
8383 See \`config.log' for more details." >&5
8384 echo "$as_me: error: cannot compute sizeof (long), 77
8385 See \`config.log' for more details." >&2;}
8386    { (exit 1); exit 1; }; }
8387 fi
8388 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8389 fi
8390 fi
8391 rm -f conftest.val
8392 else
8393   ac_cv_sizeof_long=0
8394 fi
8395 fi
8396 echo "$as_me:$LINENO: result: $ac_cv_sizeof_long" >&5
8397 echo "${ECHO_T}$ac_cv_sizeof_long" >&6
8398 cat >>confdefs.h <<_ACEOF
8399 #define SIZEOF_LONG $ac_cv_sizeof_long
8400 _ACEOF
8401
8402  ;;
8403 esac
8404
8405 if test $acx_cv_header_stdint = stddef.h; then
8406   # Lacking a good header?  Test size of everything and deduce all types.
8407   echo "$as_me:$LINENO: checking for int" >&5
8408 echo $ECHO_N "checking for int... $ECHO_C" >&6
8409 if test "${ac_cv_type_int+set}" = set; then
8410   echo $ECHO_N "(cached) $ECHO_C" >&6
8411 else
8412   cat >conftest.$ac_ext <<_ACEOF
8413 /* confdefs.h.  */
8414 _ACEOF
8415 cat confdefs.h >>conftest.$ac_ext
8416 cat >>conftest.$ac_ext <<_ACEOF
8417 /* end confdefs.h.  */
8418 $ac_includes_default
8419 int
8420 main ()
8421 {
8422 if ((int *) 0)
8423   return 0;
8424 if (sizeof (int))
8425   return 0;
8426   ;
8427   return 0;
8428 }
8429 _ACEOF
8430 rm -f conftest.$ac_objext
8431 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8432   (eval $ac_compile) 2>conftest.er1
8433   ac_status=$?
8434   grep -v '^ *+' conftest.er1 >conftest.err
8435   rm -f conftest.er1
8436   cat conftest.err >&5
8437   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8438   (exit $ac_status); } &&
8439          { ac_try='test -z "$ac_c_werror_flag"
8440                          || test ! -s conftest.err'
8441   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8442   (eval $ac_try) 2>&5
8443   ac_status=$?
8444   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8445   (exit $ac_status); }; } &&
8446          { ac_try='test -s conftest.$ac_objext'
8447   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8448   (eval $ac_try) 2>&5
8449   ac_status=$?
8450   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8451   (exit $ac_status); }; }; then
8452   ac_cv_type_int=yes
8453 else
8454   echo "$as_me: failed program was:" >&5
8455 sed 's/^/| /' conftest.$ac_ext >&5
8456
8457 ac_cv_type_int=no
8458 fi
8459 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8460 fi
8461 echo "$as_me:$LINENO: result: $ac_cv_type_int" >&5
8462 echo "${ECHO_T}$ac_cv_type_int" >&6
8463
8464 echo "$as_me:$LINENO: checking size of int" >&5
8465 echo $ECHO_N "checking size of int... $ECHO_C" >&6
8466 if test "${ac_cv_sizeof_int+set}" = set; then
8467   echo $ECHO_N "(cached) $ECHO_C" >&6
8468 else
8469   if test "$ac_cv_type_int" = yes; then
8470   # The cast to unsigned long works around a bug in the HP C Compiler
8471   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
8472   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
8473   # This bug is HP SR number 8606223364.
8474   if test "$cross_compiling" = yes; then
8475   # Depending upon the size, compute the lo and hi bounds.
8476 cat >conftest.$ac_ext <<_ACEOF
8477 /* confdefs.h.  */
8478 _ACEOF
8479 cat confdefs.h >>conftest.$ac_ext
8480 cat >>conftest.$ac_ext <<_ACEOF
8481 /* end confdefs.h.  */
8482 $ac_includes_default
8483 int
8484 main ()
8485 {
8486 static int test_array [1 - 2 * !(((long) (sizeof (int))) >= 0)];
8487 test_array [0] = 0
8488
8489   ;
8490   return 0;
8491 }
8492 _ACEOF
8493 rm -f conftest.$ac_objext
8494 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8495   (eval $ac_compile) 2>conftest.er1
8496   ac_status=$?
8497   grep -v '^ *+' conftest.er1 >conftest.err
8498   rm -f conftest.er1
8499   cat conftest.err >&5
8500   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8501   (exit $ac_status); } &&
8502          { ac_try='test -z "$ac_c_werror_flag"
8503                          || test ! -s conftest.err'
8504   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8505   (eval $ac_try) 2>&5
8506   ac_status=$?
8507   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8508   (exit $ac_status); }; } &&
8509          { ac_try='test -s conftest.$ac_objext'
8510   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8511   (eval $ac_try) 2>&5
8512   ac_status=$?
8513   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8514   (exit $ac_status); }; }; then
8515   ac_lo=0 ac_mid=0
8516   while :; do
8517     cat >conftest.$ac_ext <<_ACEOF
8518 /* confdefs.h.  */
8519 _ACEOF
8520 cat confdefs.h >>conftest.$ac_ext
8521 cat >>conftest.$ac_ext <<_ACEOF
8522 /* end confdefs.h.  */
8523 $ac_includes_default
8524 int
8525 main ()
8526 {
8527 static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)];
8528 test_array [0] = 0
8529
8530   ;
8531   return 0;
8532 }
8533 _ACEOF
8534 rm -f conftest.$ac_objext
8535 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8536   (eval $ac_compile) 2>conftest.er1
8537   ac_status=$?
8538   grep -v '^ *+' conftest.er1 >conftest.err
8539   rm -f conftest.er1
8540   cat conftest.err >&5
8541   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8542   (exit $ac_status); } &&
8543          { ac_try='test -z "$ac_c_werror_flag"
8544                          || test ! -s conftest.err'
8545   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8546   (eval $ac_try) 2>&5
8547   ac_status=$?
8548   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8549   (exit $ac_status); }; } &&
8550          { ac_try='test -s conftest.$ac_objext'
8551   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8552   (eval $ac_try) 2>&5
8553   ac_status=$?
8554   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8555   (exit $ac_status); }; }; then
8556   ac_hi=$ac_mid; break
8557 else
8558   echo "$as_me: failed program was:" >&5
8559 sed 's/^/| /' conftest.$ac_ext >&5
8560
8561 ac_lo=`expr $ac_mid + 1`
8562                     if test $ac_lo -le $ac_mid; then
8563                       ac_lo= ac_hi=
8564                       break
8565                     fi
8566                     ac_mid=`expr 2 '*' $ac_mid + 1`
8567 fi
8568 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8569   done
8570 else
8571   echo "$as_me: failed program was:" >&5
8572 sed 's/^/| /' conftest.$ac_ext >&5
8573
8574 cat >conftest.$ac_ext <<_ACEOF
8575 /* confdefs.h.  */
8576 _ACEOF
8577 cat confdefs.h >>conftest.$ac_ext
8578 cat >>conftest.$ac_ext <<_ACEOF
8579 /* end confdefs.h.  */
8580 $ac_includes_default
8581 int
8582 main ()
8583 {
8584 static int test_array [1 - 2 * !(((long) (sizeof (int))) < 0)];
8585 test_array [0] = 0
8586
8587   ;
8588   return 0;
8589 }
8590 _ACEOF
8591 rm -f conftest.$ac_objext
8592 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8593   (eval $ac_compile) 2>conftest.er1
8594   ac_status=$?
8595   grep -v '^ *+' conftest.er1 >conftest.err
8596   rm -f conftest.er1
8597   cat conftest.err >&5
8598   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8599   (exit $ac_status); } &&
8600          { ac_try='test -z "$ac_c_werror_flag"
8601                          || test ! -s conftest.err'
8602   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8603   (eval $ac_try) 2>&5
8604   ac_status=$?
8605   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8606   (exit $ac_status); }; } &&
8607          { ac_try='test -s conftest.$ac_objext'
8608   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8609   (eval $ac_try) 2>&5
8610   ac_status=$?
8611   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8612   (exit $ac_status); }; }; then
8613   ac_hi=-1 ac_mid=-1
8614   while :; do
8615     cat >conftest.$ac_ext <<_ACEOF
8616 /* confdefs.h.  */
8617 _ACEOF
8618 cat confdefs.h >>conftest.$ac_ext
8619 cat >>conftest.$ac_ext <<_ACEOF
8620 /* end confdefs.h.  */
8621 $ac_includes_default
8622 int
8623 main ()
8624 {
8625 static int test_array [1 - 2 * !(((long) (sizeof (int))) >= $ac_mid)];
8626 test_array [0] = 0
8627
8628   ;
8629   return 0;
8630 }
8631 _ACEOF
8632 rm -f conftest.$ac_objext
8633 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8634   (eval $ac_compile) 2>conftest.er1
8635   ac_status=$?
8636   grep -v '^ *+' conftest.er1 >conftest.err
8637   rm -f conftest.er1
8638   cat conftest.err >&5
8639   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8640   (exit $ac_status); } &&
8641          { ac_try='test -z "$ac_c_werror_flag"
8642                          || test ! -s conftest.err'
8643   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8644   (eval $ac_try) 2>&5
8645   ac_status=$?
8646   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8647   (exit $ac_status); }; } &&
8648          { ac_try='test -s conftest.$ac_objext'
8649   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8650   (eval $ac_try) 2>&5
8651   ac_status=$?
8652   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8653   (exit $ac_status); }; }; then
8654   ac_lo=$ac_mid; break
8655 else
8656   echo "$as_me: failed program was:" >&5
8657 sed 's/^/| /' conftest.$ac_ext >&5
8658
8659 ac_hi=`expr '(' $ac_mid ')' - 1`
8660                        if test $ac_mid -le $ac_hi; then
8661                          ac_lo= ac_hi=
8662                          break
8663                        fi
8664                        ac_mid=`expr 2 '*' $ac_mid`
8665 fi
8666 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8667   done
8668 else
8669   echo "$as_me: failed program was:" >&5
8670 sed 's/^/| /' conftest.$ac_ext >&5
8671
8672 ac_lo= ac_hi=
8673 fi
8674 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8675 fi
8676 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8677 # Binary search between lo and hi bounds.
8678 while test "x$ac_lo" != "x$ac_hi"; do
8679   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
8680   cat >conftest.$ac_ext <<_ACEOF
8681 /* confdefs.h.  */
8682 _ACEOF
8683 cat confdefs.h >>conftest.$ac_ext
8684 cat >>conftest.$ac_ext <<_ACEOF
8685 /* end confdefs.h.  */
8686 $ac_includes_default
8687 int
8688 main ()
8689 {
8690 static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)];
8691 test_array [0] = 0
8692
8693   ;
8694   return 0;
8695 }
8696 _ACEOF
8697 rm -f conftest.$ac_objext
8698 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8699   (eval $ac_compile) 2>conftest.er1
8700   ac_status=$?
8701   grep -v '^ *+' conftest.er1 >conftest.err
8702   rm -f conftest.er1
8703   cat conftest.err >&5
8704   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8705   (exit $ac_status); } &&
8706          { ac_try='test -z "$ac_c_werror_flag"
8707                          || test ! -s conftest.err'
8708   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8709   (eval $ac_try) 2>&5
8710   ac_status=$?
8711   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8712   (exit $ac_status); }; } &&
8713          { ac_try='test -s conftest.$ac_objext'
8714   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8715   (eval $ac_try) 2>&5
8716   ac_status=$?
8717   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8718   (exit $ac_status); }; }; then
8719   ac_hi=$ac_mid
8720 else
8721   echo "$as_me: failed program was:" >&5
8722 sed 's/^/| /' conftest.$ac_ext >&5
8723
8724 ac_lo=`expr '(' $ac_mid ')' + 1`
8725 fi
8726 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8727 done
8728 case $ac_lo in
8729 ?*) ac_cv_sizeof_int=$ac_lo;;
8730 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77
8731 See \`config.log' for more details." >&5
8732 echo "$as_me: error: cannot compute sizeof (int), 77
8733 See \`config.log' for more details." >&2;}
8734    { (exit 1); exit 1; }; } ;;
8735 esac
8736 else
8737   if test "$cross_compiling" = yes; then
8738   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
8739 See \`config.log' for more details." >&5
8740 echo "$as_me: error: cannot run test program while cross compiling
8741 See \`config.log' for more details." >&2;}
8742    { (exit 1); exit 1; }; }
8743 else
8744   cat >conftest.$ac_ext <<_ACEOF
8745 /* confdefs.h.  */
8746 _ACEOF
8747 cat confdefs.h >>conftest.$ac_ext
8748 cat >>conftest.$ac_ext <<_ACEOF
8749 /* end confdefs.h.  */
8750 $ac_includes_default
8751 long longval () { return (long) (sizeof (int)); }
8752 unsigned long ulongval () { return (long) (sizeof (int)); }
8753 #include <stdio.h>
8754 #include <stdlib.h>
8755 int
8756 main ()
8757 {
8758
8759   FILE *f = fopen ("conftest.val", "w");
8760   if (! f)
8761     exit (1);
8762   if (((long) (sizeof (int))) < 0)
8763     {
8764       long i = longval ();
8765       if (i != ((long) (sizeof (int))))
8766         exit (1);
8767       fprintf (f, "%ld\n", i);
8768     }
8769   else
8770     {
8771       unsigned long i = ulongval ();
8772       if (i != ((long) (sizeof (int))))
8773         exit (1);
8774       fprintf (f, "%lu\n", i);
8775     }
8776   exit (ferror (f) || fclose (f) != 0);
8777
8778   ;
8779   return 0;
8780 }
8781 _ACEOF
8782 rm -f conftest$ac_exeext
8783 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8784   (eval $ac_link) 2>&5
8785   ac_status=$?
8786   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8787   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8788   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8789   (eval $ac_try) 2>&5
8790   ac_status=$?
8791   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8792   (exit $ac_status); }; }; then
8793   ac_cv_sizeof_int=`cat conftest.val`
8794 else
8795   echo "$as_me: program exited with status $ac_status" >&5
8796 echo "$as_me: failed program was:" >&5
8797 sed 's/^/| /' conftest.$ac_ext >&5
8798
8799 ( exit $ac_status )
8800 { { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77
8801 See \`config.log' for more details." >&5
8802 echo "$as_me: error: cannot compute sizeof (int), 77
8803 See \`config.log' for more details." >&2;}
8804    { (exit 1); exit 1; }; }
8805 fi
8806 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8807 fi
8808 fi
8809 rm -f conftest.val
8810 else
8811   ac_cv_sizeof_int=0
8812 fi
8813 fi
8814 echo "$as_me:$LINENO: result: $ac_cv_sizeof_int" >&5
8815 echo "${ECHO_T}$ac_cv_sizeof_int" >&6
8816 cat >>confdefs.h <<_ACEOF
8817 #define SIZEOF_INT $ac_cv_sizeof_int
8818 _ACEOF
8819
8820
8821   echo "$as_me:$LINENO: checking for short" >&5
8822 echo $ECHO_N "checking for short... $ECHO_C" >&6
8823 if test "${ac_cv_type_short+set}" = set; then
8824   echo $ECHO_N "(cached) $ECHO_C" >&6
8825 else
8826   cat >conftest.$ac_ext <<_ACEOF
8827 /* confdefs.h.  */
8828 _ACEOF
8829 cat confdefs.h >>conftest.$ac_ext
8830 cat >>conftest.$ac_ext <<_ACEOF
8831 /* end confdefs.h.  */
8832 $ac_includes_default
8833 int
8834 main ()
8835 {
8836 if ((short *) 0)
8837   return 0;
8838 if (sizeof (short))
8839   return 0;
8840   ;
8841   return 0;
8842 }
8843 _ACEOF
8844 rm -f conftest.$ac_objext
8845 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8846   (eval $ac_compile) 2>conftest.er1
8847   ac_status=$?
8848   grep -v '^ *+' conftest.er1 >conftest.err
8849   rm -f conftest.er1
8850   cat conftest.err >&5
8851   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8852   (exit $ac_status); } &&
8853          { ac_try='test -z "$ac_c_werror_flag"
8854                          || test ! -s conftest.err'
8855   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8856   (eval $ac_try) 2>&5
8857   ac_status=$?
8858   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8859   (exit $ac_status); }; } &&
8860          { ac_try='test -s conftest.$ac_objext'
8861   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8862   (eval $ac_try) 2>&5
8863   ac_status=$?
8864   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8865   (exit $ac_status); }; }; then
8866   ac_cv_type_short=yes
8867 else
8868   echo "$as_me: failed program was:" >&5
8869 sed 's/^/| /' conftest.$ac_ext >&5
8870
8871 ac_cv_type_short=no
8872 fi
8873 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8874 fi
8875 echo "$as_me:$LINENO: result: $ac_cv_type_short" >&5
8876 echo "${ECHO_T}$ac_cv_type_short" >&6
8877
8878 echo "$as_me:$LINENO: checking size of short" >&5
8879 echo $ECHO_N "checking size of short... $ECHO_C" >&6
8880 if test "${ac_cv_sizeof_short+set}" = set; then
8881   echo $ECHO_N "(cached) $ECHO_C" >&6
8882 else
8883   if test "$ac_cv_type_short" = yes; then
8884   # The cast to unsigned long works around a bug in the HP C Compiler
8885   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
8886   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
8887   # This bug is HP SR number 8606223364.
8888   if test "$cross_compiling" = yes; then
8889   # Depending upon the size, compute the lo and hi bounds.
8890 cat >conftest.$ac_ext <<_ACEOF
8891 /* confdefs.h.  */
8892 _ACEOF
8893 cat confdefs.h >>conftest.$ac_ext
8894 cat >>conftest.$ac_ext <<_ACEOF
8895 /* end confdefs.h.  */
8896 $ac_includes_default
8897 int
8898 main ()
8899 {
8900 static int test_array [1 - 2 * !(((long) (sizeof (short))) >= 0)];
8901 test_array [0] = 0
8902
8903   ;
8904   return 0;
8905 }
8906 _ACEOF
8907 rm -f conftest.$ac_objext
8908 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8909   (eval $ac_compile) 2>conftest.er1
8910   ac_status=$?
8911   grep -v '^ *+' conftest.er1 >conftest.err
8912   rm -f conftest.er1
8913   cat conftest.err >&5
8914   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8915   (exit $ac_status); } &&
8916          { ac_try='test -z "$ac_c_werror_flag"
8917                          || test ! -s conftest.err'
8918   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8919   (eval $ac_try) 2>&5
8920   ac_status=$?
8921   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8922   (exit $ac_status); }; } &&
8923          { ac_try='test -s conftest.$ac_objext'
8924   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8925   (eval $ac_try) 2>&5
8926   ac_status=$?
8927   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8928   (exit $ac_status); }; }; then
8929   ac_lo=0 ac_mid=0
8930   while :; do
8931     cat >conftest.$ac_ext <<_ACEOF
8932 /* confdefs.h.  */
8933 _ACEOF
8934 cat confdefs.h >>conftest.$ac_ext
8935 cat >>conftest.$ac_ext <<_ACEOF
8936 /* end confdefs.h.  */
8937 $ac_includes_default
8938 int
8939 main ()
8940 {
8941 static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)];
8942 test_array [0] = 0
8943
8944   ;
8945   return 0;
8946 }
8947 _ACEOF
8948 rm -f conftest.$ac_objext
8949 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8950   (eval $ac_compile) 2>conftest.er1
8951   ac_status=$?
8952   grep -v '^ *+' conftest.er1 >conftest.err
8953   rm -f conftest.er1
8954   cat conftest.err >&5
8955   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8956   (exit $ac_status); } &&
8957          { ac_try='test -z "$ac_c_werror_flag"
8958                          || test ! -s conftest.err'
8959   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8960   (eval $ac_try) 2>&5
8961   ac_status=$?
8962   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8963   (exit $ac_status); }; } &&
8964          { ac_try='test -s conftest.$ac_objext'
8965   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8966   (eval $ac_try) 2>&5
8967   ac_status=$?
8968   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8969   (exit $ac_status); }; }; then
8970   ac_hi=$ac_mid; break
8971 else
8972   echo "$as_me: failed program was:" >&5
8973 sed 's/^/| /' conftest.$ac_ext >&5
8974
8975 ac_lo=`expr $ac_mid + 1`
8976                     if test $ac_lo -le $ac_mid; then
8977                       ac_lo= ac_hi=
8978                       break
8979                     fi
8980                     ac_mid=`expr 2 '*' $ac_mid + 1`
8981 fi
8982 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8983   done
8984 else
8985   echo "$as_me: failed program was:" >&5
8986 sed 's/^/| /' conftest.$ac_ext >&5
8987
8988 cat >conftest.$ac_ext <<_ACEOF
8989 /* confdefs.h.  */
8990 _ACEOF
8991 cat confdefs.h >>conftest.$ac_ext
8992 cat >>conftest.$ac_ext <<_ACEOF
8993 /* end confdefs.h.  */
8994 $ac_includes_default
8995 int
8996 main ()
8997 {
8998 static int test_array [1 - 2 * !(((long) (sizeof (short))) < 0)];
8999 test_array [0] = 0
9000
9001   ;
9002   return 0;
9003 }
9004 _ACEOF
9005 rm -f conftest.$ac_objext
9006 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9007   (eval $ac_compile) 2>conftest.er1
9008   ac_status=$?
9009   grep -v '^ *+' conftest.er1 >conftest.err
9010   rm -f conftest.er1
9011   cat conftest.err >&5
9012   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9013   (exit $ac_status); } &&
9014          { ac_try='test -z "$ac_c_werror_flag"
9015                          || test ! -s conftest.err'
9016   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9017   (eval $ac_try) 2>&5
9018   ac_status=$?
9019   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9020   (exit $ac_status); }; } &&
9021          { ac_try='test -s conftest.$ac_objext'
9022   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9023   (eval $ac_try) 2>&5
9024   ac_status=$?
9025   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9026   (exit $ac_status); }; }; then
9027   ac_hi=-1 ac_mid=-1
9028   while :; do
9029     cat >conftest.$ac_ext <<_ACEOF
9030 /* confdefs.h.  */
9031 _ACEOF
9032 cat confdefs.h >>conftest.$ac_ext
9033 cat >>conftest.$ac_ext <<_ACEOF
9034 /* end confdefs.h.  */
9035 $ac_includes_default
9036 int
9037 main ()
9038 {
9039 static int test_array [1 - 2 * !(((long) (sizeof (short))) >= $ac_mid)];
9040 test_array [0] = 0
9041
9042   ;
9043   return 0;
9044 }
9045 _ACEOF
9046 rm -f conftest.$ac_objext
9047 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9048   (eval $ac_compile) 2>conftest.er1
9049   ac_status=$?
9050   grep -v '^ *+' conftest.er1 >conftest.err
9051   rm -f conftest.er1
9052   cat conftest.err >&5
9053   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9054   (exit $ac_status); } &&
9055          { ac_try='test -z "$ac_c_werror_flag"
9056                          || test ! -s conftest.err'
9057   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9058   (eval $ac_try) 2>&5
9059   ac_status=$?
9060   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9061   (exit $ac_status); }; } &&
9062          { ac_try='test -s conftest.$ac_objext'
9063   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9064   (eval $ac_try) 2>&5
9065   ac_status=$?
9066   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9067   (exit $ac_status); }; }; then
9068   ac_lo=$ac_mid; break
9069 else
9070   echo "$as_me: failed program was:" >&5
9071 sed 's/^/| /' conftest.$ac_ext >&5
9072
9073 ac_hi=`expr '(' $ac_mid ')' - 1`
9074                        if test $ac_mid -le $ac_hi; then
9075                          ac_lo= ac_hi=
9076                          break
9077                        fi
9078                        ac_mid=`expr 2 '*' $ac_mid`
9079 fi
9080 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9081   done
9082 else
9083   echo "$as_me: failed program was:" >&5
9084 sed 's/^/| /' conftest.$ac_ext >&5
9085
9086 ac_lo= ac_hi=
9087 fi
9088 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9089 fi
9090 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9091 # Binary search between lo and hi bounds.
9092 while test "x$ac_lo" != "x$ac_hi"; do
9093   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
9094   cat >conftest.$ac_ext <<_ACEOF
9095 /* confdefs.h.  */
9096 _ACEOF
9097 cat confdefs.h >>conftest.$ac_ext
9098 cat >>conftest.$ac_ext <<_ACEOF
9099 /* end confdefs.h.  */
9100 $ac_includes_default
9101 int
9102 main ()
9103 {
9104 static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)];
9105 test_array [0] = 0
9106
9107   ;
9108   return 0;
9109 }
9110 _ACEOF
9111 rm -f conftest.$ac_objext
9112 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9113   (eval $ac_compile) 2>conftest.er1
9114   ac_status=$?
9115   grep -v '^ *+' conftest.er1 >conftest.err
9116   rm -f conftest.er1
9117   cat conftest.err >&5
9118   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9119   (exit $ac_status); } &&
9120          { ac_try='test -z "$ac_c_werror_flag"
9121                          || test ! -s conftest.err'
9122   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9123   (eval $ac_try) 2>&5
9124   ac_status=$?
9125   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9126   (exit $ac_status); }; } &&
9127          { ac_try='test -s conftest.$ac_objext'
9128   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9129   (eval $ac_try) 2>&5
9130   ac_status=$?
9131   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9132   (exit $ac_status); }; }; then
9133   ac_hi=$ac_mid
9134 else
9135   echo "$as_me: failed program was:" >&5
9136 sed 's/^/| /' conftest.$ac_ext >&5
9137
9138 ac_lo=`expr '(' $ac_mid ')' + 1`
9139 fi
9140 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9141 done
9142 case $ac_lo in
9143 ?*) ac_cv_sizeof_short=$ac_lo;;
9144 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77
9145 See \`config.log' for more details." >&5
9146 echo "$as_me: error: cannot compute sizeof (short), 77
9147 See \`config.log' for more details." >&2;}
9148    { (exit 1); exit 1; }; } ;;
9149 esac
9150 else
9151   if test "$cross_compiling" = yes; then
9152   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
9153 See \`config.log' for more details." >&5
9154 echo "$as_me: error: cannot run test program while cross compiling
9155 See \`config.log' for more details." >&2;}
9156    { (exit 1); exit 1; }; }
9157 else
9158   cat >conftest.$ac_ext <<_ACEOF
9159 /* confdefs.h.  */
9160 _ACEOF
9161 cat confdefs.h >>conftest.$ac_ext
9162 cat >>conftest.$ac_ext <<_ACEOF
9163 /* end confdefs.h.  */
9164 $ac_includes_default
9165 long longval () { return (long) (sizeof (short)); }
9166 unsigned long ulongval () { return (long) (sizeof (short)); }
9167 #include <stdio.h>
9168 #include <stdlib.h>
9169 int
9170 main ()
9171 {
9172
9173   FILE *f = fopen ("conftest.val", "w");
9174   if (! f)
9175     exit (1);
9176   if (((long) (sizeof (short))) < 0)
9177     {
9178       long i = longval ();
9179       if (i != ((long) (sizeof (short))))
9180         exit (1);
9181       fprintf (f, "%ld\n", i);
9182     }
9183   else
9184     {
9185       unsigned long i = ulongval ();
9186       if (i != ((long) (sizeof (short))))
9187         exit (1);
9188       fprintf (f, "%lu\n", i);
9189     }
9190   exit (ferror (f) || fclose (f) != 0);
9191
9192   ;
9193   return 0;
9194 }
9195 _ACEOF
9196 rm -f conftest$ac_exeext
9197 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9198   (eval $ac_link) 2>&5
9199   ac_status=$?
9200   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9201   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9202   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9203   (eval $ac_try) 2>&5
9204   ac_status=$?
9205   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9206   (exit $ac_status); }; }; then
9207   ac_cv_sizeof_short=`cat conftest.val`
9208 else
9209   echo "$as_me: program exited with status $ac_status" >&5
9210 echo "$as_me: failed program was:" >&5
9211 sed 's/^/| /' conftest.$ac_ext >&5
9212
9213 ( exit $ac_status )
9214 { { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77
9215 See \`config.log' for more details." >&5
9216 echo "$as_me: error: cannot compute sizeof (short), 77
9217 See \`config.log' for more details." >&2;}
9218    { (exit 1); exit 1; }; }
9219 fi
9220 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9221 fi
9222 fi
9223 rm -f conftest.val
9224 else
9225   ac_cv_sizeof_short=0
9226 fi
9227 fi
9228 echo "$as_me:$LINENO: result: $ac_cv_sizeof_short" >&5
9229 echo "${ECHO_T}$ac_cv_sizeof_short" >&6
9230 cat >>confdefs.h <<_ACEOF
9231 #define SIZEOF_SHORT $ac_cv_sizeof_short
9232 _ACEOF
9233
9234
9235   echo "$as_me:$LINENO: checking for char" >&5
9236 echo $ECHO_N "checking for char... $ECHO_C" >&6
9237 if test "${ac_cv_type_char+set}" = set; then
9238   echo $ECHO_N "(cached) $ECHO_C" >&6
9239 else
9240   cat >conftest.$ac_ext <<_ACEOF
9241 /* confdefs.h.  */
9242 _ACEOF
9243 cat confdefs.h >>conftest.$ac_ext
9244 cat >>conftest.$ac_ext <<_ACEOF
9245 /* end confdefs.h.  */
9246 $ac_includes_default
9247 int
9248 main ()
9249 {
9250 if ((char *) 0)
9251   return 0;
9252 if (sizeof (char))
9253   return 0;
9254   ;
9255   return 0;
9256 }
9257 _ACEOF
9258 rm -f conftest.$ac_objext
9259 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9260   (eval $ac_compile) 2>conftest.er1
9261   ac_status=$?
9262   grep -v '^ *+' conftest.er1 >conftest.err
9263   rm -f conftest.er1
9264   cat conftest.err >&5
9265   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9266   (exit $ac_status); } &&
9267          { ac_try='test -z "$ac_c_werror_flag"
9268                          || test ! -s conftest.err'
9269   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9270   (eval $ac_try) 2>&5
9271   ac_status=$?
9272   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9273   (exit $ac_status); }; } &&
9274          { ac_try='test -s conftest.$ac_objext'
9275   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9276   (eval $ac_try) 2>&5
9277   ac_status=$?
9278   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9279   (exit $ac_status); }; }; then
9280   ac_cv_type_char=yes
9281 else
9282   echo "$as_me: failed program was:" >&5
9283 sed 's/^/| /' conftest.$ac_ext >&5
9284
9285 ac_cv_type_char=no
9286 fi
9287 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9288 fi
9289 echo "$as_me:$LINENO: result: $ac_cv_type_char" >&5
9290 echo "${ECHO_T}$ac_cv_type_char" >&6
9291
9292 echo "$as_me:$LINENO: checking size of char" >&5
9293 echo $ECHO_N "checking size of char... $ECHO_C" >&6
9294 if test "${ac_cv_sizeof_char+set}" = set; then
9295   echo $ECHO_N "(cached) $ECHO_C" >&6
9296 else
9297   if test "$ac_cv_type_char" = yes; then
9298   # The cast to unsigned long works around a bug in the HP C Compiler
9299   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
9300   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
9301   # This bug is HP SR number 8606223364.
9302   if test "$cross_compiling" = yes; then
9303   # Depending upon the size, compute the lo and hi bounds.
9304 cat >conftest.$ac_ext <<_ACEOF
9305 /* confdefs.h.  */
9306 _ACEOF
9307 cat confdefs.h >>conftest.$ac_ext
9308 cat >>conftest.$ac_ext <<_ACEOF
9309 /* end confdefs.h.  */
9310 $ac_includes_default
9311 int
9312 main ()
9313 {
9314 static int test_array [1 - 2 * !(((long) (sizeof (char))) >= 0)];
9315 test_array [0] = 0
9316
9317   ;
9318   return 0;
9319 }
9320 _ACEOF
9321 rm -f conftest.$ac_objext
9322 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9323   (eval $ac_compile) 2>conftest.er1
9324   ac_status=$?
9325   grep -v '^ *+' conftest.er1 >conftest.err
9326   rm -f conftest.er1
9327   cat conftest.err >&5
9328   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9329   (exit $ac_status); } &&
9330          { ac_try='test -z "$ac_c_werror_flag"
9331                          || test ! -s conftest.err'
9332   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9333   (eval $ac_try) 2>&5
9334   ac_status=$?
9335   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9336   (exit $ac_status); }; } &&
9337          { ac_try='test -s conftest.$ac_objext'
9338   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9339   (eval $ac_try) 2>&5
9340   ac_status=$?
9341   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9342   (exit $ac_status); }; }; then
9343   ac_lo=0 ac_mid=0
9344   while :; do
9345     cat >conftest.$ac_ext <<_ACEOF
9346 /* confdefs.h.  */
9347 _ACEOF
9348 cat confdefs.h >>conftest.$ac_ext
9349 cat >>conftest.$ac_ext <<_ACEOF
9350 /* end confdefs.h.  */
9351 $ac_includes_default
9352 int
9353 main ()
9354 {
9355 static int test_array [1 - 2 * !(((long) (sizeof (char))) <= $ac_mid)];
9356 test_array [0] = 0
9357
9358   ;
9359   return 0;
9360 }
9361 _ACEOF
9362 rm -f conftest.$ac_objext
9363 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9364   (eval $ac_compile) 2>conftest.er1
9365   ac_status=$?
9366   grep -v '^ *+' conftest.er1 >conftest.err
9367   rm -f conftest.er1
9368   cat conftest.err >&5
9369   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9370   (exit $ac_status); } &&
9371          { ac_try='test -z "$ac_c_werror_flag"
9372                          || test ! -s conftest.err'
9373   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9374   (eval $ac_try) 2>&5
9375   ac_status=$?
9376   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9377   (exit $ac_status); }; } &&
9378          { ac_try='test -s conftest.$ac_objext'
9379   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9380   (eval $ac_try) 2>&5
9381   ac_status=$?
9382   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9383   (exit $ac_status); }; }; then
9384   ac_hi=$ac_mid; break
9385 else
9386   echo "$as_me: failed program was:" >&5
9387 sed 's/^/| /' conftest.$ac_ext >&5
9388
9389 ac_lo=`expr $ac_mid + 1`
9390                     if test $ac_lo -le $ac_mid; then
9391                       ac_lo= ac_hi=
9392                       break
9393                     fi
9394                     ac_mid=`expr 2 '*' $ac_mid + 1`
9395 fi
9396 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9397   done
9398 else
9399   echo "$as_me: failed program was:" >&5
9400 sed 's/^/| /' conftest.$ac_ext >&5
9401
9402 cat >conftest.$ac_ext <<_ACEOF
9403 /* confdefs.h.  */
9404 _ACEOF
9405 cat confdefs.h >>conftest.$ac_ext
9406 cat >>conftest.$ac_ext <<_ACEOF
9407 /* end confdefs.h.  */
9408 $ac_includes_default
9409 int
9410 main ()
9411 {
9412 static int test_array [1 - 2 * !(((long) (sizeof (char))) < 0)];
9413 test_array [0] = 0
9414
9415   ;
9416   return 0;
9417 }
9418 _ACEOF
9419 rm -f conftest.$ac_objext
9420 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9421   (eval $ac_compile) 2>conftest.er1
9422   ac_status=$?
9423   grep -v '^ *+' conftest.er1 >conftest.err
9424   rm -f conftest.er1
9425   cat conftest.err >&5
9426   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9427   (exit $ac_status); } &&
9428          { ac_try='test -z "$ac_c_werror_flag"
9429                          || test ! -s conftest.err'
9430   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9431   (eval $ac_try) 2>&5
9432   ac_status=$?
9433   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9434   (exit $ac_status); }; } &&
9435          { ac_try='test -s conftest.$ac_objext'
9436   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9437   (eval $ac_try) 2>&5
9438   ac_status=$?
9439   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9440   (exit $ac_status); }; }; then
9441   ac_hi=-1 ac_mid=-1
9442   while :; do
9443     cat >conftest.$ac_ext <<_ACEOF
9444 /* confdefs.h.  */
9445 _ACEOF
9446 cat confdefs.h >>conftest.$ac_ext
9447 cat >>conftest.$ac_ext <<_ACEOF
9448 /* end confdefs.h.  */
9449 $ac_includes_default
9450 int
9451 main ()
9452 {
9453 static int test_array [1 - 2 * !(((long) (sizeof (char))) >= $ac_mid)];
9454 test_array [0] = 0
9455
9456   ;
9457   return 0;
9458 }
9459 _ACEOF
9460 rm -f conftest.$ac_objext
9461 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9462   (eval $ac_compile) 2>conftest.er1
9463   ac_status=$?
9464   grep -v '^ *+' conftest.er1 >conftest.err
9465   rm -f conftest.er1
9466   cat conftest.err >&5
9467   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9468   (exit $ac_status); } &&
9469          { ac_try='test -z "$ac_c_werror_flag"
9470                          || test ! -s conftest.err'
9471   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9472   (eval $ac_try) 2>&5
9473   ac_status=$?
9474   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9475   (exit $ac_status); }; } &&
9476          { ac_try='test -s conftest.$ac_objext'
9477   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9478   (eval $ac_try) 2>&5
9479   ac_status=$?
9480   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9481   (exit $ac_status); }; }; then
9482   ac_lo=$ac_mid; break
9483 else
9484   echo "$as_me: failed program was:" >&5
9485 sed 's/^/| /' conftest.$ac_ext >&5
9486
9487 ac_hi=`expr '(' $ac_mid ')' - 1`
9488                        if test $ac_mid -le $ac_hi; then
9489                          ac_lo= ac_hi=
9490                          break
9491                        fi
9492                        ac_mid=`expr 2 '*' $ac_mid`
9493 fi
9494 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9495   done
9496 else
9497   echo "$as_me: failed program was:" >&5
9498 sed 's/^/| /' conftest.$ac_ext >&5
9499
9500 ac_lo= ac_hi=
9501 fi
9502 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9503 fi
9504 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9505 # Binary search between lo and hi bounds.
9506 while test "x$ac_lo" != "x$ac_hi"; do
9507   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
9508   cat >conftest.$ac_ext <<_ACEOF
9509 /* confdefs.h.  */
9510 _ACEOF
9511 cat confdefs.h >>conftest.$ac_ext
9512 cat >>conftest.$ac_ext <<_ACEOF
9513 /* end confdefs.h.  */
9514 $ac_includes_default
9515 int
9516 main ()
9517 {
9518 static int test_array [1 - 2 * !(((long) (sizeof (char))) <= $ac_mid)];
9519 test_array [0] = 0
9520
9521   ;
9522   return 0;
9523 }
9524 _ACEOF
9525 rm -f conftest.$ac_objext
9526 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9527   (eval $ac_compile) 2>conftest.er1
9528   ac_status=$?
9529   grep -v '^ *+' conftest.er1 >conftest.err
9530   rm -f conftest.er1
9531   cat conftest.err >&5
9532   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9533   (exit $ac_status); } &&
9534          { ac_try='test -z "$ac_c_werror_flag"
9535                          || test ! -s conftest.err'
9536   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9537   (eval $ac_try) 2>&5
9538   ac_status=$?
9539   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9540   (exit $ac_status); }; } &&
9541          { ac_try='test -s conftest.$ac_objext'
9542   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9543   (eval $ac_try) 2>&5
9544   ac_status=$?
9545   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9546   (exit $ac_status); }; }; then
9547   ac_hi=$ac_mid
9548 else
9549   echo "$as_me: failed program was:" >&5
9550 sed 's/^/| /' conftest.$ac_ext >&5
9551
9552 ac_lo=`expr '(' $ac_mid ')' + 1`
9553 fi
9554 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9555 done
9556 case $ac_lo in
9557 ?*) ac_cv_sizeof_char=$ac_lo;;
9558 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (char), 77
9559 See \`config.log' for more details." >&5
9560 echo "$as_me: error: cannot compute sizeof (char), 77
9561 See \`config.log' for more details." >&2;}
9562    { (exit 1); exit 1; }; } ;;
9563 esac
9564 else
9565   if test "$cross_compiling" = yes; then
9566   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
9567 See \`config.log' for more details." >&5
9568 echo "$as_me: error: cannot run test program while cross compiling
9569 See \`config.log' for more details." >&2;}
9570    { (exit 1); exit 1; }; }
9571 else
9572   cat >conftest.$ac_ext <<_ACEOF
9573 /* confdefs.h.  */
9574 _ACEOF
9575 cat confdefs.h >>conftest.$ac_ext
9576 cat >>conftest.$ac_ext <<_ACEOF
9577 /* end confdefs.h.  */
9578 $ac_includes_default
9579 long longval () { return (long) (sizeof (char)); }
9580 unsigned long ulongval () { return (long) (sizeof (char)); }
9581 #include <stdio.h>
9582 #include <stdlib.h>
9583 int
9584 main ()
9585 {
9586
9587   FILE *f = fopen ("conftest.val", "w");
9588   if (! f)
9589     exit (1);
9590   if (((long) (sizeof (char))) < 0)
9591     {
9592       long i = longval ();
9593       if (i != ((long) (sizeof (char))))
9594         exit (1);
9595       fprintf (f, "%ld\n", i);
9596     }
9597   else
9598     {
9599       unsigned long i = ulongval ();
9600       if (i != ((long) (sizeof (char))))
9601         exit (1);
9602       fprintf (f, "%lu\n", i);
9603     }
9604   exit (ferror (f) || fclose (f) != 0);
9605
9606   ;
9607   return 0;
9608 }
9609 _ACEOF
9610 rm -f conftest$ac_exeext
9611 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9612   (eval $ac_link) 2>&5
9613   ac_status=$?
9614   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9615   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9616   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9617   (eval $ac_try) 2>&5
9618   ac_status=$?
9619   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9620   (exit $ac_status); }; }; then
9621   ac_cv_sizeof_char=`cat conftest.val`
9622 else
9623   echo "$as_me: program exited with status $ac_status" >&5
9624 echo "$as_me: failed program was:" >&5
9625 sed 's/^/| /' conftest.$ac_ext >&5
9626
9627 ( exit $ac_status )
9628 { { echo "$as_me:$LINENO: error: cannot compute sizeof (char), 77
9629 See \`config.log' for more details." >&5
9630 echo "$as_me: error: cannot compute sizeof (char), 77
9631 See \`config.log' for more details." >&2;}
9632    { (exit 1); exit 1; }; }
9633 fi
9634 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9635 fi
9636 fi
9637 rm -f conftest.val
9638 else
9639   ac_cv_sizeof_char=0
9640 fi
9641 fi
9642 echo "$as_me:$LINENO: result: $ac_cv_sizeof_char" >&5
9643 echo "${ECHO_T}$ac_cv_sizeof_char" >&6
9644 cat >>confdefs.h <<_ACEOF
9645 #define SIZEOF_CHAR $ac_cv_sizeof_char
9646 _ACEOF
9647
9648
9649
9650   echo "$as_me:$LINENO: checking for type equivalent to int8_t" >&5
9651 echo $ECHO_N "checking for type equivalent to int8_t... $ECHO_C" >&6
9652   case "$ac_cv_sizeof_char" in
9653     1) acx_cv_type_int8_t=char ;;
9654     *) { { echo "$as_me:$LINENO: error: no 8-bit type" >&5
9655 echo "$as_me: error: no 8-bit type" >&2;}
9656    { (exit please report a bug); exit please report a bug; }; }
9657   esac
9658   echo "$as_me:$LINENO: result: $acx_cv_type_int8_t" >&5
9659 echo "${ECHO_T}$acx_cv_type_int8_t" >&6
9660
9661   echo "$as_me:$LINENO: checking for type equivalent to int16_t" >&5
9662 echo $ECHO_N "checking for type equivalent to int16_t... $ECHO_C" >&6
9663   case "$ac_cv_sizeof_int:$ac_cv_sizeof_short" in
9664     2:*) acx_cv_type_int16_t=int ;;
9665     *:2) acx_cv_type_int16_t=short ;;
9666     *) { { echo "$as_me:$LINENO: error: no 16-bit type" >&5
9667 echo "$as_me: error: no 16-bit type" >&2;}
9668    { (exit please report a bug); exit please report a bug; }; }
9669   esac
9670   echo "$as_me:$LINENO: result: $acx_cv_type_int16_t" >&5
9671 echo "${ECHO_T}$acx_cv_type_int16_t" >&6
9672
9673   echo "$as_me:$LINENO: checking for type equivalent to int32_t" >&5
9674 echo $ECHO_N "checking for type equivalent to int32_t... $ECHO_C" >&6
9675   case "$ac_cv_sizeof_int:$ac_cv_sizeof_long" in
9676     4:*) acx_cv_type_int32_t=int ;;
9677     *:4) acx_cv_type_int32_t=long ;;
9678     *) { { echo "$as_me:$LINENO: error: no 32-bit type" >&5
9679 echo "$as_me: error: no 32-bit type" >&2;}
9680    { (exit please report a bug); exit please report a bug; }; }
9681   esac
9682   echo "$as_me:$LINENO: result: $acx_cv_type_int32_t" >&5
9683 echo "${ECHO_T}$acx_cv_type_int32_t" >&6
9684 fi
9685
9686 # These tests are here to make the output prettier
9687
9688 if test "$ac_cv_type_uint64_t" != yes && test "$ac_cv_type_u_int64_t" != yes; then
9689   case "$ac_cv_sizeof_long" in
9690     8) acx_cv_type_int64_t=long ;;
9691   esac
9692   echo "$as_me:$LINENO: checking for type equivalent to int64_t" >&5
9693 echo $ECHO_N "checking for type equivalent to int64_t... $ECHO_C" >&6
9694   echo "$as_me:$LINENO: result: ${acx_cv_type_int64_t-'using preprocessor symbols'}" >&5
9695 echo "${ECHO_T}${acx_cv_type_int64_t-'using preprocessor symbols'}" >&6
9696 fi
9697
9698 # Now we can use the above types
9699
9700 if test "$ac_cv_type_uintptr_t" != yes; then
9701   echo "$as_me:$LINENO: checking for type equivalent to intptr_t" >&5
9702 echo $ECHO_N "checking for type equivalent to intptr_t... $ECHO_C" >&6
9703   case $ac_cv_sizeof_void_p in
9704     2) acx_cv_type_intptr_t=int16_t ;;
9705     4) acx_cv_type_intptr_t=int32_t ;;
9706     8) acx_cv_type_intptr_t=int64_t ;;
9707     *) { { echo "$as_me:$LINENO: error: no equivalent for intptr_t" >&5
9708 echo "$as_me: error: no equivalent for intptr_t" >&2;}
9709    { (exit please report a bug); exit please report a bug; }; }
9710   esac
9711   echo "$as_me:$LINENO: result: $acx_cv_type_intptr_t" >&5
9712 echo "${ECHO_T}$acx_cv_type_intptr_t" >&6
9713 fi
9714
9715 # ----------------- done all checks, emit header -------------
9716           ac_config_commands="$ac_config_commands gstdint.h"
9717
9718
9719
9720
9721 echo "$as_me:$LINENO: checking for struct stat.st_blksize" >&5
9722 echo $ECHO_N "checking for struct stat.st_blksize... $ECHO_C" >&6
9723 if test "${ac_cv_member_struct_stat_st_blksize+set}" = set; then
9724   echo $ECHO_N "(cached) $ECHO_C" >&6
9725 else
9726   cat >conftest.$ac_ext <<_ACEOF
9727 /* confdefs.h.  */
9728 _ACEOF
9729 cat confdefs.h >>conftest.$ac_ext
9730 cat >>conftest.$ac_ext <<_ACEOF
9731 /* end confdefs.h.  */
9732 $ac_includes_default
9733 int
9734 main ()
9735 {
9736 static struct stat ac_aggr;
9737 if (ac_aggr.st_blksize)
9738 return 0;
9739   ;
9740   return 0;
9741 }
9742 _ACEOF
9743 rm -f conftest.$ac_objext
9744 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9745   (eval $ac_compile) 2>conftest.er1
9746   ac_status=$?
9747   grep -v '^ *+' conftest.er1 >conftest.err
9748   rm -f conftest.er1
9749   cat conftest.err >&5
9750   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9751   (exit $ac_status); } &&
9752          { ac_try='test -z "$ac_c_werror_flag"
9753                          || test ! -s conftest.err'
9754   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9755   (eval $ac_try) 2>&5
9756   ac_status=$?
9757   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9758   (exit $ac_status); }; } &&
9759          { ac_try='test -s conftest.$ac_objext'
9760   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9761   (eval $ac_try) 2>&5
9762   ac_status=$?
9763   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9764   (exit $ac_status); }; }; then
9765   ac_cv_member_struct_stat_st_blksize=yes
9766 else
9767   echo "$as_me: failed program was:" >&5
9768 sed 's/^/| /' conftest.$ac_ext >&5
9769
9770 cat >conftest.$ac_ext <<_ACEOF
9771 /* confdefs.h.  */
9772 _ACEOF
9773 cat confdefs.h >>conftest.$ac_ext
9774 cat >>conftest.$ac_ext <<_ACEOF
9775 /* end confdefs.h.  */
9776 $ac_includes_default
9777 int
9778 main ()
9779 {
9780 static struct stat ac_aggr;
9781 if (sizeof ac_aggr.st_blksize)
9782 return 0;
9783   ;
9784   return 0;
9785 }
9786 _ACEOF
9787 rm -f conftest.$ac_objext
9788 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9789   (eval $ac_compile) 2>conftest.er1
9790   ac_status=$?
9791   grep -v '^ *+' conftest.er1 >conftest.err
9792   rm -f conftest.er1
9793   cat conftest.err >&5
9794   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9795   (exit $ac_status); } &&
9796          { ac_try='test -z "$ac_c_werror_flag"
9797                          || test ! -s conftest.err'
9798   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9799   (eval $ac_try) 2>&5
9800   ac_status=$?
9801   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9802   (exit $ac_status); }; } &&
9803          { ac_try='test -s conftest.$ac_objext'
9804   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9805   (eval $ac_try) 2>&5
9806   ac_status=$?
9807   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9808   (exit $ac_status); }; }; then
9809   ac_cv_member_struct_stat_st_blksize=yes
9810 else
9811   echo "$as_me: failed program was:" >&5
9812 sed 's/^/| /' conftest.$ac_ext >&5
9813
9814 ac_cv_member_struct_stat_st_blksize=no
9815 fi
9816 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9817 fi
9818 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9819 fi
9820 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blksize" >&5
9821 echo "${ECHO_T}$ac_cv_member_struct_stat_st_blksize" >&6
9822 if test $ac_cv_member_struct_stat_st_blksize = yes; then
9823
9824 cat >>confdefs.h <<_ACEOF
9825 #define HAVE_STRUCT_STAT_ST_BLKSIZE 1
9826 _ACEOF
9827
9828
9829 fi
9830
9831 echo "$as_me:$LINENO: checking for struct stat.st_blocks" >&5
9832 echo $ECHO_N "checking for struct stat.st_blocks... $ECHO_C" >&6
9833 if test "${ac_cv_member_struct_stat_st_blocks+set}" = set; then
9834   echo $ECHO_N "(cached) $ECHO_C" >&6
9835 else
9836   cat >conftest.$ac_ext <<_ACEOF
9837 /* confdefs.h.  */
9838 _ACEOF
9839 cat confdefs.h >>conftest.$ac_ext
9840 cat >>conftest.$ac_ext <<_ACEOF
9841 /* end confdefs.h.  */
9842 $ac_includes_default
9843 int
9844 main ()
9845 {
9846 static struct stat ac_aggr;
9847 if (ac_aggr.st_blocks)
9848 return 0;
9849   ;
9850   return 0;
9851 }
9852 _ACEOF
9853 rm -f conftest.$ac_objext
9854 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9855   (eval $ac_compile) 2>conftest.er1
9856   ac_status=$?
9857   grep -v '^ *+' conftest.er1 >conftest.err
9858   rm -f conftest.er1
9859   cat conftest.err >&5
9860   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9861   (exit $ac_status); } &&
9862          { ac_try='test -z "$ac_c_werror_flag"
9863                          || test ! -s conftest.err'
9864   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9865   (eval $ac_try) 2>&5
9866   ac_status=$?
9867   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9868   (exit $ac_status); }; } &&
9869          { ac_try='test -s conftest.$ac_objext'
9870   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9871   (eval $ac_try) 2>&5
9872   ac_status=$?
9873   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9874   (exit $ac_status); }; }; then
9875   ac_cv_member_struct_stat_st_blocks=yes
9876 else
9877   echo "$as_me: failed program was:" >&5
9878 sed 's/^/| /' conftest.$ac_ext >&5
9879
9880 cat >conftest.$ac_ext <<_ACEOF
9881 /* confdefs.h.  */
9882 _ACEOF
9883 cat confdefs.h >>conftest.$ac_ext
9884 cat >>conftest.$ac_ext <<_ACEOF
9885 /* end confdefs.h.  */
9886 $ac_includes_default
9887 int
9888 main ()
9889 {
9890 static struct stat ac_aggr;
9891 if (sizeof ac_aggr.st_blocks)
9892 return 0;
9893   ;
9894   return 0;
9895 }
9896 _ACEOF
9897 rm -f conftest.$ac_objext
9898 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9899   (eval $ac_compile) 2>conftest.er1
9900   ac_status=$?
9901   grep -v '^ *+' conftest.er1 >conftest.err
9902   rm -f conftest.er1
9903   cat conftest.err >&5
9904   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9905   (exit $ac_status); } &&
9906          { ac_try='test -z "$ac_c_werror_flag"
9907                          || test ! -s conftest.err'
9908   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9909   (eval $ac_try) 2>&5
9910   ac_status=$?
9911   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9912   (exit $ac_status); }; } &&
9913          { ac_try='test -s conftest.$ac_objext'
9914   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9915   (eval $ac_try) 2>&5
9916   ac_status=$?
9917   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9918   (exit $ac_status); }; }; then
9919   ac_cv_member_struct_stat_st_blocks=yes
9920 else
9921   echo "$as_me: failed program was:" >&5
9922 sed 's/^/| /' conftest.$ac_ext >&5
9923
9924 ac_cv_member_struct_stat_st_blocks=no
9925 fi
9926 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9927 fi
9928 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9929 fi
9930 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blocks" >&5
9931 echo "${ECHO_T}$ac_cv_member_struct_stat_st_blocks" >&6
9932 if test $ac_cv_member_struct_stat_st_blocks = yes; then
9933
9934 cat >>confdefs.h <<_ACEOF
9935 #define HAVE_STRUCT_STAT_ST_BLOCKS 1
9936 _ACEOF
9937
9938
9939 fi
9940
9941 echo "$as_me:$LINENO: checking for struct stat.st_rdev" >&5
9942 echo $ECHO_N "checking for struct stat.st_rdev... $ECHO_C" >&6
9943 if test "${ac_cv_member_struct_stat_st_rdev+set}" = set; then
9944   echo $ECHO_N "(cached) $ECHO_C" >&6
9945 else
9946   cat >conftest.$ac_ext <<_ACEOF
9947 /* confdefs.h.  */
9948 _ACEOF
9949 cat confdefs.h >>conftest.$ac_ext
9950 cat >>conftest.$ac_ext <<_ACEOF
9951 /* end confdefs.h.  */
9952 $ac_includes_default
9953 int
9954 main ()
9955 {
9956 static struct stat ac_aggr;
9957 if (ac_aggr.st_rdev)
9958 return 0;
9959   ;
9960   return 0;
9961 }
9962 _ACEOF
9963 rm -f conftest.$ac_objext
9964 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9965   (eval $ac_compile) 2>conftest.er1
9966   ac_status=$?
9967   grep -v '^ *+' conftest.er1 >conftest.err
9968   rm -f conftest.er1
9969   cat conftest.err >&5
9970   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9971   (exit $ac_status); } &&
9972          { ac_try='test -z "$ac_c_werror_flag"
9973                          || test ! -s conftest.err'
9974   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9975   (eval $ac_try) 2>&5
9976   ac_status=$?
9977   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9978   (exit $ac_status); }; } &&
9979          { ac_try='test -s conftest.$ac_objext'
9980   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9981   (eval $ac_try) 2>&5
9982   ac_status=$?
9983   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9984   (exit $ac_status); }; }; then
9985   ac_cv_member_struct_stat_st_rdev=yes
9986 else
9987   echo "$as_me: failed program was:" >&5
9988 sed 's/^/| /' conftest.$ac_ext >&5
9989
9990 cat >conftest.$ac_ext <<_ACEOF
9991 /* confdefs.h.  */
9992 _ACEOF
9993 cat confdefs.h >>conftest.$ac_ext
9994 cat >>conftest.$ac_ext <<_ACEOF
9995 /* end confdefs.h.  */
9996 $ac_includes_default
9997 int
9998 main ()
9999 {
10000 static struct stat ac_aggr;
10001 if (sizeof ac_aggr.st_rdev)
10002 return 0;
10003   ;
10004   return 0;
10005 }
10006 _ACEOF
10007 rm -f conftest.$ac_objext
10008 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10009   (eval $ac_compile) 2>conftest.er1
10010   ac_status=$?
10011   grep -v '^ *+' conftest.er1 >conftest.err
10012   rm -f conftest.er1
10013   cat conftest.err >&5
10014   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10015   (exit $ac_status); } &&
10016          { ac_try='test -z "$ac_c_werror_flag"
10017                          || test ! -s conftest.err'
10018   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10019   (eval $ac_try) 2>&5
10020   ac_status=$?
10021   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10022   (exit $ac_status); }; } &&
10023          { ac_try='test -s conftest.$ac_objext'
10024   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10025   (eval $ac_try) 2>&5
10026   ac_status=$?
10027   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10028   (exit $ac_status); }; }; then
10029   ac_cv_member_struct_stat_st_rdev=yes
10030 else
10031   echo "$as_me: failed program was:" >&5
10032 sed 's/^/| /' conftest.$ac_ext >&5
10033
10034 ac_cv_member_struct_stat_st_rdev=no
10035 fi
10036 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10037 fi
10038 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10039 fi
10040 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_rdev" >&5
10041 echo "${ECHO_T}$ac_cv_member_struct_stat_st_rdev" >&6
10042 if test $ac_cv_member_struct_stat_st_rdev = yes; then
10043
10044 cat >>confdefs.h <<_ACEOF
10045 #define HAVE_STRUCT_STAT_ST_RDEV 1
10046 _ACEOF
10047
10048
10049 fi
10050
10051
10052 # Check for library functions.
10053
10054
10055
10056
10057
10058
10059
10060
10061 for ac_func in getrusage times mkstemp strtof strtold snprintf ftruncate chsize
10062 do
10063 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10064 echo "$as_me:$LINENO: checking for $ac_func" >&5
10065 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10066 if eval "test \"\${$as_ac_var+set}\" = set"; then
10067   echo $ECHO_N "(cached) $ECHO_C" >&6
10068 else
10069   if test x$gcc_no_link = xyes; then
10070   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10071 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10072    { (exit 1); exit 1; }; }
10073 fi
10074 cat >conftest.$ac_ext <<_ACEOF
10075 /* confdefs.h.  */
10076 _ACEOF
10077 cat confdefs.h >>conftest.$ac_ext
10078 cat >>conftest.$ac_ext <<_ACEOF
10079 /* end confdefs.h.  */
10080 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10081    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10082 #define $ac_func innocuous_$ac_func
10083
10084 /* System header to define __stub macros and hopefully few prototypes,
10085     which can conflict with char $ac_func (); below.
10086     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10087     <limits.h> exists even on freestanding compilers.  */
10088
10089 #ifdef __STDC__
10090 # include <limits.h>
10091 #else
10092 # include <assert.h>
10093 #endif
10094
10095 #undef $ac_func
10096
10097 /* Override any gcc2 internal prototype to avoid an error.  */
10098 #ifdef __cplusplus
10099 extern "C"
10100 {
10101 #endif
10102 /* We use char because int might match the return type of a gcc2
10103    builtin and then its argument prototype would still apply.  */
10104 char $ac_func ();
10105 /* The GNU C library defines this for functions which it implements
10106     to always fail with ENOSYS.  Some functions are actually named
10107     something starting with __ and the normal name is an alias.  */
10108 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10109 choke me
10110 #else
10111 char (*f) () = $ac_func;
10112 #endif
10113 #ifdef __cplusplus
10114 }
10115 #endif
10116
10117 int
10118 main ()
10119 {
10120 return f != $ac_func;
10121   ;
10122   return 0;
10123 }
10124 _ACEOF
10125 rm -f conftest.$ac_objext conftest$ac_exeext
10126 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10127   (eval $ac_link) 2>conftest.er1
10128   ac_status=$?
10129   grep -v '^ *+' conftest.er1 >conftest.err
10130   rm -f conftest.er1
10131   cat conftest.err >&5
10132   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10133   (exit $ac_status); } &&
10134          { ac_try='test -z "$ac_c_werror_flag"
10135                          || test ! -s conftest.err'
10136   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10137   (eval $ac_try) 2>&5
10138   ac_status=$?
10139   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10140   (exit $ac_status); }; } &&
10141          { ac_try='test -s conftest$ac_exeext'
10142   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10143   (eval $ac_try) 2>&5
10144   ac_status=$?
10145   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10146   (exit $ac_status); }; }; then
10147   eval "$as_ac_var=yes"
10148 else
10149   echo "$as_me: failed program was:" >&5
10150 sed 's/^/| /' conftest.$ac_ext >&5
10151
10152 eval "$as_ac_var=no"
10153 fi
10154 rm -f conftest.err conftest.$ac_objext \
10155       conftest$ac_exeext conftest.$ac_ext
10156 fi
10157 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10158 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10159 if test `eval echo '${'$as_ac_var'}'` = yes; then
10160   cat >>confdefs.h <<_ACEOF
10161 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10162 _ACEOF
10163
10164 fi
10165 done
10166
10167
10168
10169
10170
10171
10172
10173
10174
10175 for ac_func in chdir strerror getlogin gethostname kill link symlink perror
10176 do
10177 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10178 echo "$as_me:$LINENO: checking for $ac_func" >&5
10179 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10180 if eval "test \"\${$as_ac_var+set}\" = set"; then
10181   echo $ECHO_N "(cached) $ECHO_C" >&6
10182 else
10183   if test x$gcc_no_link = xyes; then
10184   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10185 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10186    { (exit 1); exit 1; }; }
10187 fi
10188 cat >conftest.$ac_ext <<_ACEOF
10189 /* confdefs.h.  */
10190 _ACEOF
10191 cat confdefs.h >>conftest.$ac_ext
10192 cat >>conftest.$ac_ext <<_ACEOF
10193 /* end confdefs.h.  */
10194 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10195    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10196 #define $ac_func innocuous_$ac_func
10197
10198 /* System header to define __stub macros and hopefully few prototypes,
10199     which can conflict with char $ac_func (); below.
10200     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10201     <limits.h> exists even on freestanding compilers.  */
10202
10203 #ifdef __STDC__
10204 # include <limits.h>
10205 #else
10206 # include <assert.h>
10207 #endif
10208
10209 #undef $ac_func
10210
10211 /* Override any gcc2 internal prototype to avoid an error.  */
10212 #ifdef __cplusplus
10213 extern "C"
10214 {
10215 #endif
10216 /* We use char because int might match the return type of a gcc2
10217    builtin and then its argument prototype would still apply.  */
10218 char $ac_func ();
10219 /* The GNU C library defines this for functions which it implements
10220     to always fail with ENOSYS.  Some functions are actually named
10221     something starting with __ and the normal name is an alias.  */
10222 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10223 choke me
10224 #else
10225 char (*f) () = $ac_func;
10226 #endif
10227 #ifdef __cplusplus
10228 }
10229 #endif
10230
10231 int
10232 main ()
10233 {
10234 return f != $ac_func;
10235   ;
10236   return 0;
10237 }
10238 _ACEOF
10239 rm -f conftest.$ac_objext conftest$ac_exeext
10240 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10241   (eval $ac_link) 2>conftest.er1
10242   ac_status=$?
10243   grep -v '^ *+' conftest.er1 >conftest.err
10244   rm -f conftest.er1
10245   cat conftest.err >&5
10246   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10247   (exit $ac_status); } &&
10248          { ac_try='test -z "$ac_c_werror_flag"
10249                          || test ! -s conftest.err'
10250   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10251   (eval $ac_try) 2>&5
10252   ac_status=$?
10253   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10254   (exit $ac_status); }; } &&
10255          { ac_try='test -s conftest$ac_exeext'
10256   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10257   (eval $ac_try) 2>&5
10258   ac_status=$?
10259   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10260   (exit $ac_status); }; }; then
10261   eval "$as_ac_var=yes"
10262 else
10263   echo "$as_me: failed program was:" >&5
10264 sed 's/^/| /' conftest.$ac_ext >&5
10265
10266 eval "$as_ac_var=no"
10267 fi
10268 rm -f conftest.err conftest.$ac_objext \
10269       conftest$ac_exeext conftest.$ac_ext
10270 fi
10271 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10272 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10273 if test `eval echo '${'$as_ac_var'}'` = yes; then
10274   cat >>confdefs.h <<_ACEOF
10275 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10276 _ACEOF
10277
10278 fi
10279 done
10280
10281
10282
10283
10284
10285
10286
10287
10288
10289
10290
10291 for ac_func in sleep time ttyname signal alarm ctime clock access fork execl
10292 do
10293 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10294 echo "$as_me:$LINENO: checking for $ac_func" >&5
10295 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10296 if eval "test \"\${$as_ac_var+set}\" = set"; then
10297   echo $ECHO_N "(cached) $ECHO_C" >&6
10298 else
10299   if test x$gcc_no_link = xyes; then
10300   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10301 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10302    { (exit 1); exit 1; }; }
10303 fi
10304 cat >conftest.$ac_ext <<_ACEOF
10305 /* confdefs.h.  */
10306 _ACEOF
10307 cat confdefs.h >>conftest.$ac_ext
10308 cat >>conftest.$ac_ext <<_ACEOF
10309 /* end confdefs.h.  */
10310 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10311    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10312 #define $ac_func innocuous_$ac_func
10313
10314 /* System header to define __stub macros and hopefully few prototypes,
10315     which can conflict with char $ac_func (); below.
10316     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10317     <limits.h> exists even on freestanding compilers.  */
10318
10319 #ifdef __STDC__
10320 # include <limits.h>
10321 #else
10322 # include <assert.h>
10323 #endif
10324
10325 #undef $ac_func
10326
10327 /* Override any gcc2 internal prototype to avoid an error.  */
10328 #ifdef __cplusplus
10329 extern "C"
10330 {
10331 #endif
10332 /* We use char because int might match the return type of a gcc2
10333    builtin and then its argument prototype would still apply.  */
10334 char $ac_func ();
10335 /* The GNU C library defines this for functions which it implements
10336     to always fail with ENOSYS.  Some functions are actually named
10337     something starting with __ and the normal name is an alias.  */
10338 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10339 choke me
10340 #else
10341 char (*f) () = $ac_func;
10342 #endif
10343 #ifdef __cplusplus
10344 }
10345 #endif
10346
10347 int
10348 main ()
10349 {
10350 return f != $ac_func;
10351   ;
10352   return 0;
10353 }
10354 _ACEOF
10355 rm -f conftest.$ac_objext conftest$ac_exeext
10356 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10357   (eval $ac_link) 2>conftest.er1
10358   ac_status=$?
10359   grep -v '^ *+' conftest.er1 >conftest.err
10360   rm -f conftest.er1
10361   cat conftest.err >&5
10362   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10363   (exit $ac_status); } &&
10364          { ac_try='test -z "$ac_c_werror_flag"
10365                          || test ! -s conftest.err'
10366   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10367   (eval $ac_try) 2>&5
10368   ac_status=$?
10369   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10370   (exit $ac_status); }; } &&
10371          { ac_try='test -s conftest$ac_exeext'
10372   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10373   (eval $ac_try) 2>&5
10374   ac_status=$?
10375   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10376   (exit $ac_status); }; }; then
10377   eval "$as_ac_var=yes"
10378 else
10379   echo "$as_me: failed program was:" >&5
10380 sed 's/^/| /' conftest.$ac_ext >&5
10381
10382 eval "$as_ac_var=no"
10383 fi
10384 rm -f conftest.err conftest.$ac_objext \
10385       conftest$ac_exeext conftest.$ac_ext
10386 fi
10387 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10388 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10389 if test `eval echo '${'$as_ac_var'}'` = yes; then
10390   cat >>confdefs.h <<_ACEOF
10391 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10392 _ACEOF
10393
10394 fi
10395 done
10396
10397
10398
10399
10400
10401 for ac_func in wait setmode getrlimit gettimeofday
10402 do
10403 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10404 echo "$as_me:$LINENO: checking for $ac_func" >&5
10405 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10406 if eval "test \"\${$as_ac_var+set}\" = set"; then
10407   echo $ECHO_N "(cached) $ECHO_C" >&6
10408 else
10409   if test x$gcc_no_link = xyes; then
10410   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10411 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10412    { (exit 1); exit 1; }; }
10413 fi
10414 cat >conftest.$ac_ext <<_ACEOF
10415 /* confdefs.h.  */
10416 _ACEOF
10417 cat confdefs.h >>conftest.$ac_ext
10418 cat >>conftest.$ac_ext <<_ACEOF
10419 /* end confdefs.h.  */
10420 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10421    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10422 #define $ac_func innocuous_$ac_func
10423
10424 /* System header to define __stub macros and hopefully few prototypes,
10425     which can conflict with char $ac_func (); below.
10426     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10427     <limits.h> exists even on freestanding compilers.  */
10428
10429 #ifdef __STDC__
10430 # include <limits.h>
10431 #else
10432 # include <assert.h>
10433 #endif
10434
10435 #undef $ac_func
10436
10437 /* Override any gcc2 internal prototype to avoid an error.  */
10438 #ifdef __cplusplus
10439 extern "C"
10440 {
10441 #endif
10442 /* We use char because int might match the return type of a gcc2
10443    builtin and then its argument prototype would still apply.  */
10444 char $ac_func ();
10445 /* The GNU C library defines this for functions which it implements
10446     to always fail with ENOSYS.  Some functions are actually named
10447     something starting with __ and the normal name is an alias.  */
10448 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10449 choke me
10450 #else
10451 char (*f) () = $ac_func;
10452 #endif
10453 #ifdef __cplusplus
10454 }
10455 #endif
10456
10457 int
10458 main ()
10459 {
10460 return f != $ac_func;
10461   ;
10462   return 0;
10463 }
10464 _ACEOF
10465 rm -f conftest.$ac_objext conftest$ac_exeext
10466 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10467   (eval $ac_link) 2>conftest.er1
10468   ac_status=$?
10469   grep -v '^ *+' conftest.er1 >conftest.err
10470   rm -f conftest.er1
10471   cat conftest.err >&5
10472   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10473   (exit $ac_status); } &&
10474          { ac_try='test -z "$ac_c_werror_flag"
10475                          || test ! -s conftest.err'
10476   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10477   (eval $ac_try) 2>&5
10478   ac_status=$?
10479   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10480   (exit $ac_status); }; } &&
10481          { ac_try='test -s conftest$ac_exeext'
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); }; }; then
10487   eval "$as_ac_var=yes"
10488 else
10489   echo "$as_me: failed program was:" >&5
10490 sed 's/^/| /' conftest.$ac_ext >&5
10491
10492 eval "$as_ac_var=no"
10493 fi
10494 rm -f conftest.err conftest.$ac_objext \
10495       conftest$ac_exeext conftest.$ac_ext
10496 fi
10497 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10498 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10499 if test `eval echo '${'$as_ac_var'}'` = yes; then
10500   cat >>confdefs.h <<_ACEOF
10501 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10502 _ACEOF
10503
10504 fi
10505 done
10506
10507
10508 # Check for types
10509 echo "$as_me:$LINENO: checking for intptr_t" >&5
10510 echo $ECHO_N "checking for intptr_t... $ECHO_C" >&6
10511 if test "${ac_cv_type_intptr_t+set}" = set; then
10512   echo $ECHO_N "(cached) $ECHO_C" >&6
10513 else
10514   cat >conftest.$ac_ext <<_ACEOF
10515 /* confdefs.h.  */
10516 _ACEOF
10517 cat confdefs.h >>conftest.$ac_ext
10518 cat >>conftest.$ac_ext <<_ACEOF
10519 /* end confdefs.h.  */
10520 $ac_includes_default
10521 int
10522 main ()
10523 {
10524 if ((intptr_t *) 0)
10525   return 0;
10526 if (sizeof (intptr_t))
10527   return 0;
10528   ;
10529   return 0;
10530 }
10531 _ACEOF
10532 rm -f conftest.$ac_objext
10533 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10534   (eval $ac_compile) 2>conftest.er1
10535   ac_status=$?
10536   grep -v '^ *+' conftest.er1 >conftest.err
10537   rm -f conftest.er1
10538   cat conftest.err >&5
10539   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10540   (exit $ac_status); } &&
10541          { ac_try='test -z "$ac_c_werror_flag"
10542                          || test ! -s conftest.err'
10543   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10544   (eval $ac_try) 2>&5
10545   ac_status=$?
10546   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10547   (exit $ac_status); }; } &&
10548          { ac_try='test -s conftest.$ac_objext'
10549   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10550   (eval $ac_try) 2>&5
10551   ac_status=$?
10552   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10553   (exit $ac_status); }; }; then
10554   ac_cv_type_intptr_t=yes
10555 else
10556   echo "$as_me: failed program was:" >&5
10557 sed 's/^/| /' conftest.$ac_ext >&5
10558
10559 ac_cv_type_intptr_t=no
10560 fi
10561 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10562 fi
10563 echo "$as_me:$LINENO: result: $ac_cv_type_intptr_t" >&5
10564 echo "${ECHO_T}$ac_cv_type_intptr_t" >&6
10565 if test $ac_cv_type_intptr_t = yes; then
10566
10567 cat >>confdefs.h <<_ACEOF
10568 #define HAVE_INTPTR_T 1
10569 _ACEOF
10570
10571
10572 fi
10573
10574
10575 # Check libc for getgid, getpid, getuid
10576 echo "$as_me:$LINENO: checking for getgid in -lc" >&5
10577 echo $ECHO_N "checking for getgid in -lc... $ECHO_C" >&6
10578 if test "${ac_cv_lib_c_getgid+set}" = set; then
10579   echo $ECHO_N "(cached) $ECHO_C" >&6
10580 else
10581   ac_check_lib_save_LIBS=$LIBS
10582 LIBS="-lc  $LIBS"
10583 if test x$gcc_no_link = xyes; then
10584   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10585 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10586    { (exit 1); exit 1; }; }
10587 fi
10588 cat >conftest.$ac_ext <<_ACEOF
10589 /* confdefs.h.  */
10590 _ACEOF
10591 cat confdefs.h >>conftest.$ac_ext
10592 cat >>conftest.$ac_ext <<_ACEOF
10593 /* end confdefs.h.  */
10594
10595 /* Override any gcc2 internal prototype to avoid an error.  */
10596 #ifdef __cplusplus
10597 extern "C"
10598 #endif
10599 /* We use char because int might match the return type of a gcc2
10600    builtin and then its argument prototype would still apply.  */
10601 char getgid ();
10602 int
10603 main ()
10604 {
10605 getgid ();
10606   ;
10607   return 0;
10608 }
10609 _ACEOF
10610 rm -f conftest.$ac_objext conftest$ac_exeext
10611 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10612   (eval $ac_link) 2>conftest.er1
10613   ac_status=$?
10614   grep -v '^ *+' conftest.er1 >conftest.err
10615   rm -f conftest.er1
10616   cat conftest.err >&5
10617   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10618   (exit $ac_status); } &&
10619          { ac_try='test -z "$ac_c_werror_flag"
10620                          || test ! -s conftest.err'
10621   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10622   (eval $ac_try) 2>&5
10623   ac_status=$?
10624   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10625   (exit $ac_status); }; } &&
10626          { ac_try='test -s conftest$ac_exeext'
10627   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10628   (eval $ac_try) 2>&5
10629   ac_status=$?
10630   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10631   (exit $ac_status); }; }; then
10632   ac_cv_lib_c_getgid=yes
10633 else
10634   echo "$as_me: failed program was:" >&5
10635 sed 's/^/| /' conftest.$ac_ext >&5
10636
10637 ac_cv_lib_c_getgid=no
10638 fi
10639 rm -f conftest.err conftest.$ac_objext \
10640       conftest$ac_exeext conftest.$ac_ext
10641 LIBS=$ac_check_lib_save_LIBS
10642 fi
10643 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getgid" >&5
10644 echo "${ECHO_T}$ac_cv_lib_c_getgid" >&6
10645 if test $ac_cv_lib_c_getgid = yes; then
10646
10647 cat >>confdefs.h <<\_ACEOF
10648 #define HAVE_GETGID 1
10649 _ACEOF
10650
10651 fi
10652
10653 echo "$as_me:$LINENO: checking for getpid in -lc" >&5
10654 echo $ECHO_N "checking for getpid in -lc... $ECHO_C" >&6
10655 if test "${ac_cv_lib_c_getpid+set}" = set; then
10656   echo $ECHO_N "(cached) $ECHO_C" >&6
10657 else
10658   ac_check_lib_save_LIBS=$LIBS
10659 LIBS="-lc  $LIBS"
10660 if test x$gcc_no_link = xyes; then
10661   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10662 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10663    { (exit 1); exit 1; }; }
10664 fi
10665 cat >conftest.$ac_ext <<_ACEOF
10666 /* confdefs.h.  */
10667 _ACEOF
10668 cat confdefs.h >>conftest.$ac_ext
10669 cat >>conftest.$ac_ext <<_ACEOF
10670 /* end confdefs.h.  */
10671
10672 /* Override any gcc2 internal prototype to avoid an error.  */
10673 #ifdef __cplusplus
10674 extern "C"
10675 #endif
10676 /* We use char because int might match the return type of a gcc2
10677    builtin and then its argument prototype would still apply.  */
10678 char getpid ();
10679 int
10680 main ()
10681 {
10682 getpid ();
10683   ;
10684   return 0;
10685 }
10686 _ACEOF
10687 rm -f conftest.$ac_objext conftest$ac_exeext
10688 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10689   (eval $ac_link) 2>conftest.er1
10690   ac_status=$?
10691   grep -v '^ *+' conftest.er1 >conftest.err
10692   rm -f conftest.er1
10693   cat conftest.err >&5
10694   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10695   (exit $ac_status); } &&
10696          { ac_try='test -z "$ac_c_werror_flag"
10697                          || test ! -s conftest.err'
10698   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10699   (eval $ac_try) 2>&5
10700   ac_status=$?
10701   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10702   (exit $ac_status); }; } &&
10703          { ac_try='test -s conftest$ac_exeext'
10704   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10705   (eval $ac_try) 2>&5
10706   ac_status=$?
10707   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10708   (exit $ac_status); }; }; then
10709   ac_cv_lib_c_getpid=yes
10710 else
10711   echo "$as_me: failed program was:" >&5
10712 sed 's/^/| /' conftest.$ac_ext >&5
10713
10714 ac_cv_lib_c_getpid=no
10715 fi
10716 rm -f conftest.err conftest.$ac_objext \
10717       conftest$ac_exeext conftest.$ac_ext
10718 LIBS=$ac_check_lib_save_LIBS
10719 fi
10720 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getpid" >&5
10721 echo "${ECHO_T}$ac_cv_lib_c_getpid" >&6
10722 if test $ac_cv_lib_c_getpid = yes; then
10723
10724 cat >>confdefs.h <<\_ACEOF
10725 #define HAVE_GETPID 1
10726 _ACEOF
10727
10728 fi
10729
10730 echo "$as_me:$LINENO: checking for getuid in -lc" >&5
10731 echo $ECHO_N "checking for getuid in -lc... $ECHO_C" >&6
10732 if test "${ac_cv_lib_c_getuid+set}" = set; then
10733   echo $ECHO_N "(cached) $ECHO_C" >&6
10734 else
10735   ac_check_lib_save_LIBS=$LIBS
10736 LIBS="-lc  $LIBS"
10737 if test x$gcc_no_link = xyes; then
10738   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10739 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10740    { (exit 1); exit 1; }; }
10741 fi
10742 cat >conftest.$ac_ext <<_ACEOF
10743 /* confdefs.h.  */
10744 _ACEOF
10745 cat confdefs.h >>conftest.$ac_ext
10746 cat >>conftest.$ac_ext <<_ACEOF
10747 /* end confdefs.h.  */
10748
10749 /* Override any gcc2 internal prototype to avoid an error.  */
10750 #ifdef __cplusplus
10751 extern "C"
10752 #endif
10753 /* We use char because int might match the return type of a gcc2
10754    builtin and then its argument prototype would still apply.  */
10755 char getuid ();
10756 int
10757 main ()
10758 {
10759 getuid ();
10760   ;
10761   return 0;
10762 }
10763 _ACEOF
10764 rm -f conftest.$ac_objext conftest$ac_exeext
10765 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10766   (eval $ac_link) 2>conftest.er1
10767   ac_status=$?
10768   grep -v '^ *+' conftest.er1 >conftest.err
10769   rm -f conftest.er1
10770   cat conftest.err >&5
10771   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10772   (exit $ac_status); } &&
10773          { ac_try='test -z "$ac_c_werror_flag"
10774                          || test ! -s conftest.err'
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); }; } &&
10780          { ac_try='test -s conftest$ac_exeext'
10781   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10782   (eval $ac_try) 2>&5
10783   ac_status=$?
10784   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10785   (exit $ac_status); }; }; then
10786   ac_cv_lib_c_getuid=yes
10787 else
10788   echo "$as_me: failed program was:" >&5
10789 sed 's/^/| /' conftest.$ac_ext >&5
10790
10791 ac_cv_lib_c_getuid=no
10792 fi
10793 rm -f conftest.err conftest.$ac_objext \
10794       conftest$ac_exeext conftest.$ac_ext
10795 LIBS=$ac_check_lib_save_LIBS
10796 fi
10797 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getuid" >&5
10798 echo "${ECHO_T}$ac_cv_lib_c_getuid" >&6
10799 if test $ac_cv_lib_c_getuid = yes; then
10800
10801 cat >>confdefs.h <<\_ACEOF
10802 #define HAVE_GETUID 1
10803 _ACEOF
10804
10805 fi
10806
10807
10808 # Check for C99 (and other IEEE) math functions
10809 # ??? This list seems awful long. Is there a better way to test for these?
10810 echo "$as_me:$LINENO: checking for acosf in -lm" >&5
10811 echo $ECHO_N "checking for acosf in -lm... $ECHO_C" >&6
10812 if test "${ac_cv_lib_m_acosf+set}" = set; then
10813   echo $ECHO_N "(cached) $ECHO_C" >&6
10814 else
10815   ac_check_lib_save_LIBS=$LIBS
10816 LIBS="-lm  $LIBS"
10817 if test x$gcc_no_link = xyes; then
10818   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10819 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10820    { (exit 1); exit 1; }; }
10821 fi
10822 cat >conftest.$ac_ext <<_ACEOF
10823 /* confdefs.h.  */
10824 _ACEOF
10825 cat confdefs.h >>conftest.$ac_ext
10826 cat >>conftest.$ac_ext <<_ACEOF
10827 /* end confdefs.h.  */
10828
10829 /* Override any gcc2 internal prototype to avoid an error.  */
10830 #ifdef __cplusplus
10831 extern "C"
10832 #endif
10833 /* We use char because int might match the return type of a gcc2
10834    builtin and then its argument prototype would still apply.  */
10835 char acosf ();
10836 int
10837 main ()
10838 {
10839 acosf ();
10840   ;
10841   return 0;
10842 }
10843 _ACEOF
10844 rm -f conftest.$ac_objext conftest$ac_exeext
10845 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10846   (eval $ac_link) 2>conftest.er1
10847   ac_status=$?
10848   grep -v '^ *+' conftest.er1 >conftest.err
10849   rm -f conftest.er1
10850   cat conftest.err >&5
10851   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10852   (exit $ac_status); } &&
10853          { ac_try='test -z "$ac_c_werror_flag"
10854                          || test ! -s conftest.err'
10855   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10856   (eval $ac_try) 2>&5
10857   ac_status=$?
10858   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10859   (exit $ac_status); }; } &&
10860          { ac_try='test -s conftest$ac_exeext'
10861   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10862   (eval $ac_try) 2>&5
10863   ac_status=$?
10864   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10865   (exit $ac_status); }; }; then
10866   ac_cv_lib_m_acosf=yes
10867 else
10868   echo "$as_me: failed program was:" >&5
10869 sed 's/^/| /' conftest.$ac_ext >&5
10870
10871 ac_cv_lib_m_acosf=no
10872 fi
10873 rm -f conftest.err conftest.$ac_objext \
10874       conftest$ac_exeext conftest.$ac_ext
10875 LIBS=$ac_check_lib_save_LIBS
10876 fi
10877 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosf" >&5
10878 echo "${ECHO_T}$ac_cv_lib_m_acosf" >&6
10879 if test $ac_cv_lib_m_acosf = yes; then
10880
10881 cat >>confdefs.h <<\_ACEOF
10882 #define HAVE_ACOSF 1
10883 _ACEOF
10884
10885 fi
10886
10887 echo "$as_me:$LINENO: checking for acos in -lm" >&5
10888 echo $ECHO_N "checking for acos in -lm... $ECHO_C" >&6
10889 if test "${ac_cv_lib_m_acos+set}" = set; then
10890   echo $ECHO_N "(cached) $ECHO_C" >&6
10891 else
10892   ac_check_lib_save_LIBS=$LIBS
10893 LIBS="-lm  $LIBS"
10894 if test x$gcc_no_link = xyes; then
10895   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10896 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10897    { (exit 1); exit 1; }; }
10898 fi
10899 cat >conftest.$ac_ext <<_ACEOF
10900 /* confdefs.h.  */
10901 _ACEOF
10902 cat confdefs.h >>conftest.$ac_ext
10903 cat >>conftest.$ac_ext <<_ACEOF
10904 /* end confdefs.h.  */
10905
10906 /* Override any gcc2 internal prototype to avoid an error.  */
10907 #ifdef __cplusplus
10908 extern "C"
10909 #endif
10910 /* We use char because int might match the return type of a gcc2
10911    builtin and then its argument prototype would still apply.  */
10912 char acos ();
10913 int
10914 main ()
10915 {
10916 acos ();
10917   ;
10918   return 0;
10919 }
10920 _ACEOF
10921 rm -f conftest.$ac_objext conftest$ac_exeext
10922 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10923   (eval $ac_link) 2>conftest.er1
10924   ac_status=$?
10925   grep -v '^ *+' conftest.er1 >conftest.err
10926   rm -f conftest.er1
10927   cat conftest.err >&5
10928   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10929   (exit $ac_status); } &&
10930          { ac_try='test -z "$ac_c_werror_flag"
10931                          || test ! -s conftest.err'
10932   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10933   (eval $ac_try) 2>&5
10934   ac_status=$?
10935   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10936   (exit $ac_status); }; } &&
10937          { ac_try='test -s conftest$ac_exeext'
10938   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10939   (eval $ac_try) 2>&5
10940   ac_status=$?
10941   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10942   (exit $ac_status); }; }; then
10943   ac_cv_lib_m_acos=yes
10944 else
10945   echo "$as_me: failed program was:" >&5
10946 sed 's/^/| /' conftest.$ac_ext >&5
10947
10948 ac_cv_lib_m_acos=no
10949 fi
10950 rm -f conftest.err conftest.$ac_objext \
10951       conftest$ac_exeext conftest.$ac_ext
10952 LIBS=$ac_check_lib_save_LIBS
10953 fi
10954 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acos" >&5
10955 echo "${ECHO_T}$ac_cv_lib_m_acos" >&6
10956 if test $ac_cv_lib_m_acos = yes; then
10957
10958 cat >>confdefs.h <<\_ACEOF
10959 #define HAVE_ACOS 1
10960 _ACEOF
10961
10962 fi
10963
10964 echo "$as_me:$LINENO: checking for acosl in -lm" >&5
10965 echo $ECHO_N "checking for acosl in -lm... $ECHO_C" >&6
10966 if test "${ac_cv_lib_m_acosl+set}" = set; then
10967   echo $ECHO_N "(cached) $ECHO_C" >&6
10968 else
10969   ac_check_lib_save_LIBS=$LIBS
10970 LIBS="-lm  $LIBS"
10971 if test x$gcc_no_link = xyes; then
10972   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10973 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10974    { (exit 1); exit 1; }; }
10975 fi
10976 cat >conftest.$ac_ext <<_ACEOF
10977 /* confdefs.h.  */
10978 _ACEOF
10979 cat confdefs.h >>conftest.$ac_ext
10980 cat >>conftest.$ac_ext <<_ACEOF
10981 /* end confdefs.h.  */
10982
10983 /* Override any gcc2 internal prototype to avoid an error.  */
10984 #ifdef __cplusplus
10985 extern "C"
10986 #endif
10987 /* We use char because int might match the return type of a gcc2
10988    builtin and then its argument prototype would still apply.  */
10989 char acosl ();
10990 int
10991 main ()
10992 {
10993 acosl ();
10994   ;
10995   return 0;
10996 }
10997 _ACEOF
10998 rm -f conftest.$ac_objext conftest$ac_exeext
10999 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11000   (eval $ac_link) 2>conftest.er1
11001   ac_status=$?
11002   grep -v '^ *+' conftest.er1 >conftest.err
11003   rm -f conftest.er1
11004   cat conftest.err >&5
11005   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11006   (exit $ac_status); } &&
11007          { ac_try='test -z "$ac_c_werror_flag"
11008                          || test ! -s conftest.err'
11009   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11010   (eval $ac_try) 2>&5
11011   ac_status=$?
11012   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11013   (exit $ac_status); }; } &&
11014          { ac_try='test -s conftest$ac_exeext'
11015   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11016   (eval $ac_try) 2>&5
11017   ac_status=$?
11018   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11019   (exit $ac_status); }; }; then
11020   ac_cv_lib_m_acosl=yes
11021 else
11022   echo "$as_me: failed program was:" >&5
11023 sed 's/^/| /' conftest.$ac_ext >&5
11024
11025 ac_cv_lib_m_acosl=no
11026 fi
11027 rm -f conftest.err conftest.$ac_objext \
11028       conftest$ac_exeext conftest.$ac_ext
11029 LIBS=$ac_check_lib_save_LIBS
11030 fi
11031 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosl" >&5
11032 echo "${ECHO_T}$ac_cv_lib_m_acosl" >&6
11033 if test $ac_cv_lib_m_acosl = yes; then
11034
11035 cat >>confdefs.h <<\_ACEOF
11036 #define HAVE_ACOSL 1
11037 _ACEOF
11038
11039 fi
11040
11041 echo "$as_me:$LINENO: checking for acoshf in -lm" >&5
11042 echo $ECHO_N "checking for acoshf in -lm... $ECHO_C" >&6
11043 if test "${ac_cv_lib_m_acoshf+set}" = set; then
11044   echo $ECHO_N "(cached) $ECHO_C" >&6
11045 else
11046   ac_check_lib_save_LIBS=$LIBS
11047 LIBS="-lm  $LIBS"
11048 if test x$gcc_no_link = xyes; then
11049   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11050 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11051    { (exit 1); exit 1; }; }
11052 fi
11053 cat >conftest.$ac_ext <<_ACEOF
11054 /* confdefs.h.  */
11055 _ACEOF
11056 cat confdefs.h >>conftest.$ac_ext
11057 cat >>conftest.$ac_ext <<_ACEOF
11058 /* end confdefs.h.  */
11059
11060 /* Override any gcc2 internal prototype to avoid an error.  */
11061 #ifdef __cplusplus
11062 extern "C"
11063 #endif
11064 /* We use char because int might match the return type of a gcc2
11065    builtin and then its argument prototype would still apply.  */
11066 char acoshf ();
11067 int
11068 main ()
11069 {
11070 acoshf ();
11071   ;
11072   return 0;
11073 }
11074 _ACEOF
11075 rm -f conftest.$ac_objext conftest$ac_exeext
11076 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11077   (eval $ac_link) 2>conftest.er1
11078   ac_status=$?
11079   grep -v '^ *+' conftest.er1 >conftest.err
11080   rm -f conftest.er1
11081   cat conftest.err >&5
11082   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11083   (exit $ac_status); } &&
11084          { ac_try='test -z "$ac_c_werror_flag"
11085                          || test ! -s conftest.err'
11086   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11087   (eval $ac_try) 2>&5
11088   ac_status=$?
11089   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11090   (exit $ac_status); }; } &&
11091          { ac_try='test -s conftest$ac_exeext'
11092   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11093   (eval $ac_try) 2>&5
11094   ac_status=$?
11095   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11096   (exit $ac_status); }; }; then
11097   ac_cv_lib_m_acoshf=yes
11098 else
11099   echo "$as_me: failed program was:" >&5
11100 sed 's/^/| /' conftest.$ac_ext >&5
11101
11102 ac_cv_lib_m_acoshf=no
11103 fi
11104 rm -f conftest.err conftest.$ac_objext \
11105       conftest$ac_exeext conftest.$ac_ext
11106 LIBS=$ac_check_lib_save_LIBS
11107 fi
11108 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acoshf" >&5
11109 echo "${ECHO_T}$ac_cv_lib_m_acoshf" >&6
11110 if test $ac_cv_lib_m_acoshf = yes; then
11111
11112 cat >>confdefs.h <<\_ACEOF
11113 #define HAVE_ACOSHF 1
11114 _ACEOF
11115
11116 fi
11117
11118 echo "$as_me:$LINENO: checking for acosh in -lm" >&5
11119 echo $ECHO_N "checking for acosh in -lm... $ECHO_C" >&6
11120 if test "${ac_cv_lib_m_acosh+set}" = set; then
11121   echo $ECHO_N "(cached) $ECHO_C" >&6
11122 else
11123   ac_check_lib_save_LIBS=$LIBS
11124 LIBS="-lm  $LIBS"
11125 if test x$gcc_no_link = xyes; then
11126   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11127 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11128    { (exit 1); exit 1; }; }
11129 fi
11130 cat >conftest.$ac_ext <<_ACEOF
11131 /* confdefs.h.  */
11132 _ACEOF
11133 cat confdefs.h >>conftest.$ac_ext
11134 cat >>conftest.$ac_ext <<_ACEOF
11135 /* end confdefs.h.  */
11136
11137 /* Override any gcc2 internal prototype to avoid an error.  */
11138 #ifdef __cplusplus
11139 extern "C"
11140 #endif
11141 /* We use char because int might match the return type of a gcc2
11142    builtin and then its argument prototype would still apply.  */
11143 char acosh ();
11144 int
11145 main ()
11146 {
11147 acosh ();
11148   ;
11149   return 0;
11150 }
11151 _ACEOF
11152 rm -f conftest.$ac_objext conftest$ac_exeext
11153 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11154   (eval $ac_link) 2>conftest.er1
11155   ac_status=$?
11156   grep -v '^ *+' conftest.er1 >conftest.err
11157   rm -f conftest.er1
11158   cat conftest.err >&5
11159   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11160   (exit $ac_status); } &&
11161          { ac_try='test -z "$ac_c_werror_flag"
11162                          || test ! -s conftest.err'
11163   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11164   (eval $ac_try) 2>&5
11165   ac_status=$?
11166   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11167   (exit $ac_status); }; } &&
11168          { ac_try='test -s conftest$ac_exeext'
11169   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11170   (eval $ac_try) 2>&5
11171   ac_status=$?
11172   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11173   (exit $ac_status); }; }; then
11174   ac_cv_lib_m_acosh=yes
11175 else
11176   echo "$as_me: failed program was:" >&5
11177 sed 's/^/| /' conftest.$ac_ext >&5
11178
11179 ac_cv_lib_m_acosh=no
11180 fi
11181 rm -f conftest.err conftest.$ac_objext \
11182       conftest$ac_exeext conftest.$ac_ext
11183 LIBS=$ac_check_lib_save_LIBS
11184 fi
11185 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosh" >&5
11186 echo "${ECHO_T}$ac_cv_lib_m_acosh" >&6
11187 if test $ac_cv_lib_m_acosh = yes; then
11188
11189 cat >>confdefs.h <<\_ACEOF
11190 #define HAVE_ACOSH 1
11191 _ACEOF
11192
11193 fi
11194
11195 echo "$as_me:$LINENO: checking for acoshl in -lm" >&5
11196 echo $ECHO_N "checking for acoshl in -lm... $ECHO_C" >&6
11197 if test "${ac_cv_lib_m_acoshl+set}" = set; then
11198   echo $ECHO_N "(cached) $ECHO_C" >&6
11199 else
11200   ac_check_lib_save_LIBS=$LIBS
11201 LIBS="-lm  $LIBS"
11202 if test x$gcc_no_link = xyes; then
11203   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11204 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11205    { (exit 1); exit 1; }; }
11206 fi
11207 cat >conftest.$ac_ext <<_ACEOF
11208 /* confdefs.h.  */
11209 _ACEOF
11210 cat confdefs.h >>conftest.$ac_ext
11211 cat >>conftest.$ac_ext <<_ACEOF
11212 /* end confdefs.h.  */
11213
11214 /* Override any gcc2 internal prototype to avoid an error.  */
11215 #ifdef __cplusplus
11216 extern "C"
11217 #endif
11218 /* We use char because int might match the return type of a gcc2
11219    builtin and then its argument prototype would still apply.  */
11220 char acoshl ();
11221 int
11222 main ()
11223 {
11224 acoshl ();
11225   ;
11226   return 0;
11227 }
11228 _ACEOF
11229 rm -f conftest.$ac_objext conftest$ac_exeext
11230 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11231   (eval $ac_link) 2>conftest.er1
11232   ac_status=$?
11233   grep -v '^ *+' conftest.er1 >conftest.err
11234   rm -f conftest.er1
11235   cat conftest.err >&5
11236   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11237   (exit $ac_status); } &&
11238          { ac_try='test -z "$ac_c_werror_flag"
11239                          || test ! -s conftest.err'
11240   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11241   (eval $ac_try) 2>&5
11242   ac_status=$?
11243   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11244   (exit $ac_status); }; } &&
11245          { ac_try='test -s conftest$ac_exeext'
11246   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11247   (eval $ac_try) 2>&5
11248   ac_status=$?
11249   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11250   (exit $ac_status); }; }; then
11251   ac_cv_lib_m_acoshl=yes
11252 else
11253   echo "$as_me: failed program was:" >&5
11254 sed 's/^/| /' conftest.$ac_ext >&5
11255
11256 ac_cv_lib_m_acoshl=no
11257 fi
11258 rm -f conftest.err conftest.$ac_objext \
11259       conftest$ac_exeext conftest.$ac_ext
11260 LIBS=$ac_check_lib_save_LIBS
11261 fi
11262 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acoshl" >&5
11263 echo "${ECHO_T}$ac_cv_lib_m_acoshl" >&6
11264 if test $ac_cv_lib_m_acoshl = yes; then
11265
11266 cat >>confdefs.h <<\_ACEOF
11267 #define HAVE_ACOSHL 1
11268 _ACEOF
11269
11270 fi
11271
11272 echo "$as_me:$LINENO: checking for asinf in -lm" >&5
11273 echo $ECHO_N "checking for asinf in -lm... $ECHO_C" >&6
11274 if test "${ac_cv_lib_m_asinf+set}" = set; then
11275   echo $ECHO_N "(cached) $ECHO_C" >&6
11276 else
11277   ac_check_lib_save_LIBS=$LIBS
11278 LIBS="-lm  $LIBS"
11279 if test x$gcc_no_link = xyes; then
11280   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11281 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11282    { (exit 1); exit 1; }; }
11283 fi
11284 cat >conftest.$ac_ext <<_ACEOF
11285 /* confdefs.h.  */
11286 _ACEOF
11287 cat confdefs.h >>conftest.$ac_ext
11288 cat >>conftest.$ac_ext <<_ACEOF
11289 /* end confdefs.h.  */
11290
11291 /* Override any gcc2 internal prototype to avoid an error.  */
11292 #ifdef __cplusplus
11293 extern "C"
11294 #endif
11295 /* We use char because int might match the return type of a gcc2
11296    builtin and then its argument prototype would still apply.  */
11297 char asinf ();
11298 int
11299 main ()
11300 {
11301 asinf ();
11302   ;
11303   return 0;
11304 }
11305 _ACEOF
11306 rm -f conftest.$ac_objext conftest$ac_exeext
11307 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11308   (eval $ac_link) 2>conftest.er1
11309   ac_status=$?
11310   grep -v '^ *+' conftest.er1 >conftest.err
11311   rm -f conftest.er1
11312   cat conftest.err >&5
11313   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11314   (exit $ac_status); } &&
11315          { ac_try='test -z "$ac_c_werror_flag"
11316                          || test ! -s conftest.err'
11317   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11318   (eval $ac_try) 2>&5
11319   ac_status=$?
11320   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11321   (exit $ac_status); }; } &&
11322          { ac_try='test -s conftest$ac_exeext'
11323   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11324   (eval $ac_try) 2>&5
11325   ac_status=$?
11326   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11327   (exit $ac_status); }; }; then
11328   ac_cv_lib_m_asinf=yes
11329 else
11330   echo "$as_me: failed program was:" >&5
11331 sed 's/^/| /' conftest.$ac_ext >&5
11332
11333 ac_cv_lib_m_asinf=no
11334 fi
11335 rm -f conftest.err conftest.$ac_objext \
11336       conftest$ac_exeext conftest.$ac_ext
11337 LIBS=$ac_check_lib_save_LIBS
11338 fi
11339 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinf" >&5
11340 echo "${ECHO_T}$ac_cv_lib_m_asinf" >&6
11341 if test $ac_cv_lib_m_asinf = yes; then
11342
11343 cat >>confdefs.h <<\_ACEOF
11344 #define HAVE_ASINF 1
11345 _ACEOF
11346
11347 fi
11348
11349 echo "$as_me:$LINENO: checking for asin in -lm" >&5
11350 echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
11351 if test "${ac_cv_lib_m_asin+set}" = set; then
11352   echo $ECHO_N "(cached) $ECHO_C" >&6
11353 else
11354   ac_check_lib_save_LIBS=$LIBS
11355 LIBS="-lm  $LIBS"
11356 if test x$gcc_no_link = xyes; then
11357   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11358 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11359    { (exit 1); exit 1; }; }
11360 fi
11361 cat >conftest.$ac_ext <<_ACEOF
11362 /* confdefs.h.  */
11363 _ACEOF
11364 cat confdefs.h >>conftest.$ac_ext
11365 cat >>conftest.$ac_ext <<_ACEOF
11366 /* end confdefs.h.  */
11367
11368 /* Override any gcc2 internal prototype to avoid an error.  */
11369 #ifdef __cplusplus
11370 extern "C"
11371 #endif
11372 /* We use char because int might match the return type of a gcc2
11373    builtin and then its argument prototype would still apply.  */
11374 char asin ();
11375 int
11376 main ()
11377 {
11378 asin ();
11379   ;
11380   return 0;
11381 }
11382 _ACEOF
11383 rm -f conftest.$ac_objext conftest$ac_exeext
11384 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11385   (eval $ac_link) 2>conftest.er1
11386   ac_status=$?
11387   grep -v '^ *+' conftest.er1 >conftest.err
11388   rm -f conftest.er1
11389   cat conftest.err >&5
11390   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11391   (exit $ac_status); } &&
11392          { ac_try='test -z "$ac_c_werror_flag"
11393                          || test ! -s conftest.err'
11394   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11395   (eval $ac_try) 2>&5
11396   ac_status=$?
11397   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11398   (exit $ac_status); }; } &&
11399          { ac_try='test -s conftest$ac_exeext'
11400   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11401   (eval $ac_try) 2>&5
11402   ac_status=$?
11403   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11404   (exit $ac_status); }; }; then
11405   ac_cv_lib_m_asin=yes
11406 else
11407   echo "$as_me: failed program was:" >&5
11408 sed 's/^/| /' conftest.$ac_ext >&5
11409
11410 ac_cv_lib_m_asin=no
11411 fi
11412 rm -f conftest.err conftest.$ac_objext \
11413       conftest$ac_exeext conftest.$ac_ext
11414 LIBS=$ac_check_lib_save_LIBS
11415 fi
11416 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
11417 echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
11418 if test $ac_cv_lib_m_asin = yes; then
11419
11420 cat >>confdefs.h <<\_ACEOF
11421 #define HAVE_ASIN 1
11422 _ACEOF
11423
11424 fi
11425
11426 echo "$as_me:$LINENO: checking for asinl in -lm" >&5
11427 echo $ECHO_N "checking for asinl in -lm... $ECHO_C" >&6
11428 if test "${ac_cv_lib_m_asinl+set}" = set; then
11429   echo $ECHO_N "(cached) $ECHO_C" >&6
11430 else
11431   ac_check_lib_save_LIBS=$LIBS
11432 LIBS="-lm  $LIBS"
11433 if test x$gcc_no_link = xyes; then
11434   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11435 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11436    { (exit 1); exit 1; }; }
11437 fi
11438 cat >conftest.$ac_ext <<_ACEOF
11439 /* confdefs.h.  */
11440 _ACEOF
11441 cat confdefs.h >>conftest.$ac_ext
11442 cat >>conftest.$ac_ext <<_ACEOF
11443 /* end confdefs.h.  */
11444
11445 /* Override any gcc2 internal prototype to avoid an error.  */
11446 #ifdef __cplusplus
11447 extern "C"
11448 #endif
11449 /* We use char because int might match the return type of a gcc2
11450    builtin and then its argument prototype would still apply.  */
11451 char asinl ();
11452 int
11453 main ()
11454 {
11455 asinl ();
11456   ;
11457   return 0;
11458 }
11459 _ACEOF
11460 rm -f conftest.$ac_objext conftest$ac_exeext
11461 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11462   (eval $ac_link) 2>conftest.er1
11463   ac_status=$?
11464   grep -v '^ *+' conftest.er1 >conftest.err
11465   rm -f conftest.er1
11466   cat conftest.err >&5
11467   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11468   (exit $ac_status); } &&
11469          { ac_try='test -z "$ac_c_werror_flag"
11470                          || test ! -s conftest.err'
11471   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11472   (eval $ac_try) 2>&5
11473   ac_status=$?
11474   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11475   (exit $ac_status); }; } &&
11476          { ac_try='test -s conftest$ac_exeext'
11477   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11478   (eval $ac_try) 2>&5
11479   ac_status=$?
11480   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11481   (exit $ac_status); }; }; then
11482   ac_cv_lib_m_asinl=yes
11483 else
11484   echo "$as_me: failed program was:" >&5
11485 sed 's/^/| /' conftest.$ac_ext >&5
11486
11487 ac_cv_lib_m_asinl=no
11488 fi
11489 rm -f conftest.err conftest.$ac_objext \
11490       conftest$ac_exeext conftest.$ac_ext
11491 LIBS=$ac_check_lib_save_LIBS
11492 fi
11493 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinl" >&5
11494 echo "${ECHO_T}$ac_cv_lib_m_asinl" >&6
11495 if test $ac_cv_lib_m_asinl = yes; then
11496
11497 cat >>confdefs.h <<\_ACEOF
11498 #define HAVE_ASINL 1
11499 _ACEOF
11500
11501 fi
11502
11503 echo "$as_me:$LINENO: checking for asinhf in -lm" >&5
11504 echo $ECHO_N "checking for asinhf in -lm... $ECHO_C" >&6
11505 if test "${ac_cv_lib_m_asinhf+set}" = set; then
11506   echo $ECHO_N "(cached) $ECHO_C" >&6
11507 else
11508   ac_check_lib_save_LIBS=$LIBS
11509 LIBS="-lm  $LIBS"
11510 if test x$gcc_no_link = xyes; then
11511   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11512 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11513    { (exit 1); exit 1; }; }
11514 fi
11515 cat >conftest.$ac_ext <<_ACEOF
11516 /* confdefs.h.  */
11517 _ACEOF
11518 cat confdefs.h >>conftest.$ac_ext
11519 cat >>conftest.$ac_ext <<_ACEOF
11520 /* end confdefs.h.  */
11521
11522 /* Override any gcc2 internal prototype to avoid an error.  */
11523 #ifdef __cplusplus
11524 extern "C"
11525 #endif
11526 /* We use char because int might match the return type of a gcc2
11527    builtin and then its argument prototype would still apply.  */
11528 char asinhf ();
11529 int
11530 main ()
11531 {
11532 asinhf ();
11533   ;
11534   return 0;
11535 }
11536 _ACEOF
11537 rm -f conftest.$ac_objext conftest$ac_exeext
11538 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11539   (eval $ac_link) 2>conftest.er1
11540   ac_status=$?
11541   grep -v '^ *+' conftest.er1 >conftest.err
11542   rm -f conftest.er1
11543   cat conftest.err >&5
11544   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11545   (exit $ac_status); } &&
11546          { ac_try='test -z "$ac_c_werror_flag"
11547                          || test ! -s conftest.err'
11548   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11549   (eval $ac_try) 2>&5
11550   ac_status=$?
11551   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11552   (exit $ac_status); }; } &&
11553          { ac_try='test -s conftest$ac_exeext'
11554   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11555   (eval $ac_try) 2>&5
11556   ac_status=$?
11557   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11558   (exit $ac_status); }; }; then
11559   ac_cv_lib_m_asinhf=yes
11560 else
11561   echo "$as_me: failed program was:" >&5
11562 sed 's/^/| /' conftest.$ac_ext >&5
11563
11564 ac_cv_lib_m_asinhf=no
11565 fi
11566 rm -f conftest.err conftest.$ac_objext \
11567       conftest$ac_exeext conftest.$ac_ext
11568 LIBS=$ac_check_lib_save_LIBS
11569 fi
11570 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinhf" >&5
11571 echo "${ECHO_T}$ac_cv_lib_m_asinhf" >&6
11572 if test $ac_cv_lib_m_asinhf = yes; then
11573
11574 cat >>confdefs.h <<\_ACEOF
11575 #define HAVE_ASINHF 1
11576 _ACEOF
11577
11578 fi
11579
11580 echo "$as_me:$LINENO: checking for asinh in -lm" >&5
11581 echo $ECHO_N "checking for asinh in -lm... $ECHO_C" >&6
11582 if test "${ac_cv_lib_m_asinh+set}" = set; then
11583   echo $ECHO_N "(cached) $ECHO_C" >&6
11584 else
11585   ac_check_lib_save_LIBS=$LIBS
11586 LIBS="-lm  $LIBS"
11587 if test x$gcc_no_link = xyes; then
11588   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11589 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11590    { (exit 1); exit 1; }; }
11591 fi
11592 cat >conftest.$ac_ext <<_ACEOF
11593 /* confdefs.h.  */
11594 _ACEOF
11595 cat confdefs.h >>conftest.$ac_ext
11596 cat >>conftest.$ac_ext <<_ACEOF
11597 /* end confdefs.h.  */
11598
11599 /* Override any gcc2 internal prototype to avoid an error.  */
11600 #ifdef __cplusplus
11601 extern "C"
11602 #endif
11603 /* We use char because int might match the return type of a gcc2
11604    builtin and then its argument prototype would still apply.  */
11605 char asinh ();
11606 int
11607 main ()
11608 {
11609 asinh ();
11610   ;
11611   return 0;
11612 }
11613 _ACEOF
11614 rm -f conftest.$ac_objext conftest$ac_exeext
11615 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11616   (eval $ac_link) 2>conftest.er1
11617   ac_status=$?
11618   grep -v '^ *+' conftest.er1 >conftest.err
11619   rm -f conftest.er1
11620   cat conftest.err >&5
11621   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11622   (exit $ac_status); } &&
11623          { ac_try='test -z "$ac_c_werror_flag"
11624                          || test ! -s conftest.err'
11625   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11626   (eval $ac_try) 2>&5
11627   ac_status=$?
11628   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11629   (exit $ac_status); }; } &&
11630          { ac_try='test -s conftest$ac_exeext'
11631   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11632   (eval $ac_try) 2>&5
11633   ac_status=$?
11634   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11635   (exit $ac_status); }; }; then
11636   ac_cv_lib_m_asinh=yes
11637 else
11638   echo "$as_me: failed program was:" >&5
11639 sed 's/^/| /' conftest.$ac_ext >&5
11640
11641 ac_cv_lib_m_asinh=no
11642 fi
11643 rm -f conftest.err conftest.$ac_objext \
11644       conftest$ac_exeext conftest.$ac_ext
11645 LIBS=$ac_check_lib_save_LIBS
11646 fi
11647 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinh" >&5
11648 echo "${ECHO_T}$ac_cv_lib_m_asinh" >&6
11649 if test $ac_cv_lib_m_asinh = yes; then
11650
11651 cat >>confdefs.h <<\_ACEOF
11652 #define HAVE_ASINH 1
11653 _ACEOF
11654
11655 fi
11656
11657 echo "$as_me:$LINENO: checking for asinhl in -lm" >&5
11658 echo $ECHO_N "checking for asinhl in -lm... $ECHO_C" >&6
11659 if test "${ac_cv_lib_m_asinhl+set}" = set; then
11660   echo $ECHO_N "(cached) $ECHO_C" >&6
11661 else
11662   ac_check_lib_save_LIBS=$LIBS
11663 LIBS="-lm  $LIBS"
11664 if test x$gcc_no_link = xyes; then
11665   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11666 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11667    { (exit 1); exit 1; }; }
11668 fi
11669 cat >conftest.$ac_ext <<_ACEOF
11670 /* confdefs.h.  */
11671 _ACEOF
11672 cat confdefs.h >>conftest.$ac_ext
11673 cat >>conftest.$ac_ext <<_ACEOF
11674 /* end confdefs.h.  */
11675
11676 /* Override any gcc2 internal prototype to avoid an error.  */
11677 #ifdef __cplusplus
11678 extern "C"
11679 #endif
11680 /* We use char because int might match the return type of a gcc2
11681    builtin and then its argument prototype would still apply.  */
11682 char asinhl ();
11683 int
11684 main ()
11685 {
11686 asinhl ();
11687   ;
11688   return 0;
11689 }
11690 _ACEOF
11691 rm -f conftest.$ac_objext conftest$ac_exeext
11692 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11693   (eval $ac_link) 2>conftest.er1
11694   ac_status=$?
11695   grep -v '^ *+' conftest.er1 >conftest.err
11696   rm -f conftest.er1
11697   cat conftest.err >&5
11698   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11699   (exit $ac_status); } &&
11700          { ac_try='test -z "$ac_c_werror_flag"
11701                          || test ! -s conftest.err'
11702   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11703   (eval $ac_try) 2>&5
11704   ac_status=$?
11705   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11706   (exit $ac_status); }; } &&
11707          { ac_try='test -s conftest$ac_exeext'
11708   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11709   (eval $ac_try) 2>&5
11710   ac_status=$?
11711   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11712   (exit $ac_status); }; }; then
11713   ac_cv_lib_m_asinhl=yes
11714 else
11715   echo "$as_me: failed program was:" >&5
11716 sed 's/^/| /' conftest.$ac_ext >&5
11717
11718 ac_cv_lib_m_asinhl=no
11719 fi
11720 rm -f conftest.err conftest.$ac_objext \
11721       conftest$ac_exeext conftest.$ac_ext
11722 LIBS=$ac_check_lib_save_LIBS
11723 fi
11724 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinhl" >&5
11725 echo "${ECHO_T}$ac_cv_lib_m_asinhl" >&6
11726 if test $ac_cv_lib_m_asinhl = yes; then
11727
11728 cat >>confdefs.h <<\_ACEOF
11729 #define HAVE_ASINHL 1
11730 _ACEOF
11731
11732 fi
11733
11734 echo "$as_me:$LINENO: checking for atan2f in -lm" >&5
11735 echo $ECHO_N "checking for atan2f in -lm... $ECHO_C" >&6
11736 if test "${ac_cv_lib_m_atan2f+set}" = set; then
11737   echo $ECHO_N "(cached) $ECHO_C" >&6
11738 else
11739   ac_check_lib_save_LIBS=$LIBS
11740 LIBS="-lm  $LIBS"
11741 if test x$gcc_no_link = xyes; then
11742   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11743 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11744    { (exit 1); exit 1; }; }
11745 fi
11746 cat >conftest.$ac_ext <<_ACEOF
11747 /* confdefs.h.  */
11748 _ACEOF
11749 cat confdefs.h >>conftest.$ac_ext
11750 cat >>conftest.$ac_ext <<_ACEOF
11751 /* end confdefs.h.  */
11752
11753 /* Override any gcc2 internal prototype to avoid an error.  */
11754 #ifdef __cplusplus
11755 extern "C"
11756 #endif
11757 /* We use char because int might match the return type of a gcc2
11758    builtin and then its argument prototype would still apply.  */
11759 char atan2f ();
11760 int
11761 main ()
11762 {
11763 atan2f ();
11764   ;
11765   return 0;
11766 }
11767 _ACEOF
11768 rm -f conftest.$ac_objext conftest$ac_exeext
11769 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11770   (eval $ac_link) 2>conftest.er1
11771   ac_status=$?
11772   grep -v '^ *+' conftest.er1 >conftest.err
11773   rm -f conftest.er1
11774   cat conftest.err >&5
11775   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11776   (exit $ac_status); } &&
11777          { ac_try='test -z "$ac_c_werror_flag"
11778                          || test ! -s conftest.err'
11779   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11780   (eval $ac_try) 2>&5
11781   ac_status=$?
11782   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11783   (exit $ac_status); }; } &&
11784          { ac_try='test -s conftest$ac_exeext'
11785   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11786   (eval $ac_try) 2>&5
11787   ac_status=$?
11788   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11789   (exit $ac_status); }; }; then
11790   ac_cv_lib_m_atan2f=yes
11791 else
11792   echo "$as_me: failed program was:" >&5
11793 sed 's/^/| /' conftest.$ac_ext >&5
11794
11795 ac_cv_lib_m_atan2f=no
11796 fi
11797 rm -f conftest.err conftest.$ac_objext \
11798       conftest$ac_exeext conftest.$ac_ext
11799 LIBS=$ac_check_lib_save_LIBS
11800 fi
11801 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2f" >&5
11802 echo "${ECHO_T}$ac_cv_lib_m_atan2f" >&6
11803 if test $ac_cv_lib_m_atan2f = yes; then
11804
11805 cat >>confdefs.h <<\_ACEOF
11806 #define HAVE_ATAN2F 1
11807 _ACEOF
11808
11809 fi
11810
11811 echo "$as_me:$LINENO: checking for atan2 in -lm" >&5
11812 echo $ECHO_N "checking for atan2 in -lm... $ECHO_C" >&6
11813 if test "${ac_cv_lib_m_atan2+set}" = set; then
11814   echo $ECHO_N "(cached) $ECHO_C" >&6
11815 else
11816   ac_check_lib_save_LIBS=$LIBS
11817 LIBS="-lm  $LIBS"
11818 if test x$gcc_no_link = xyes; then
11819   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11820 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11821    { (exit 1); exit 1; }; }
11822 fi
11823 cat >conftest.$ac_ext <<_ACEOF
11824 /* confdefs.h.  */
11825 _ACEOF
11826 cat confdefs.h >>conftest.$ac_ext
11827 cat >>conftest.$ac_ext <<_ACEOF
11828 /* end confdefs.h.  */
11829
11830 /* Override any gcc2 internal prototype to avoid an error.  */
11831 #ifdef __cplusplus
11832 extern "C"
11833 #endif
11834 /* We use char because int might match the return type of a gcc2
11835    builtin and then its argument prototype would still apply.  */
11836 char atan2 ();
11837 int
11838 main ()
11839 {
11840 atan2 ();
11841   ;
11842   return 0;
11843 }
11844 _ACEOF
11845 rm -f conftest.$ac_objext conftest$ac_exeext
11846 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11847   (eval $ac_link) 2>conftest.er1
11848   ac_status=$?
11849   grep -v '^ *+' conftest.er1 >conftest.err
11850   rm -f conftest.er1
11851   cat conftest.err >&5
11852   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11853   (exit $ac_status); } &&
11854          { ac_try='test -z "$ac_c_werror_flag"
11855                          || test ! -s conftest.err'
11856   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11857   (eval $ac_try) 2>&5
11858   ac_status=$?
11859   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11860   (exit $ac_status); }; } &&
11861          { ac_try='test -s conftest$ac_exeext'
11862   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11863   (eval $ac_try) 2>&5
11864   ac_status=$?
11865   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11866   (exit $ac_status); }; }; then
11867   ac_cv_lib_m_atan2=yes
11868 else
11869   echo "$as_me: failed program was:" >&5
11870 sed 's/^/| /' conftest.$ac_ext >&5
11871
11872 ac_cv_lib_m_atan2=no
11873 fi
11874 rm -f conftest.err conftest.$ac_objext \
11875       conftest$ac_exeext conftest.$ac_ext
11876 LIBS=$ac_check_lib_save_LIBS
11877 fi
11878 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2" >&5
11879 echo "${ECHO_T}$ac_cv_lib_m_atan2" >&6
11880 if test $ac_cv_lib_m_atan2 = yes; then
11881
11882 cat >>confdefs.h <<\_ACEOF
11883 #define HAVE_ATAN2 1
11884 _ACEOF
11885
11886 fi
11887
11888 echo "$as_me:$LINENO: checking for atan2l in -lm" >&5
11889 echo $ECHO_N "checking for atan2l in -lm... $ECHO_C" >&6
11890 if test "${ac_cv_lib_m_atan2l+set}" = set; then
11891   echo $ECHO_N "(cached) $ECHO_C" >&6
11892 else
11893   ac_check_lib_save_LIBS=$LIBS
11894 LIBS="-lm  $LIBS"
11895 if test x$gcc_no_link = xyes; then
11896   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11897 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11898    { (exit 1); exit 1; }; }
11899 fi
11900 cat >conftest.$ac_ext <<_ACEOF
11901 /* confdefs.h.  */
11902 _ACEOF
11903 cat confdefs.h >>conftest.$ac_ext
11904 cat >>conftest.$ac_ext <<_ACEOF
11905 /* end confdefs.h.  */
11906
11907 /* Override any gcc2 internal prototype to avoid an error.  */
11908 #ifdef __cplusplus
11909 extern "C"
11910 #endif
11911 /* We use char because int might match the return type of a gcc2
11912    builtin and then its argument prototype would still apply.  */
11913 char atan2l ();
11914 int
11915 main ()
11916 {
11917 atan2l ();
11918   ;
11919   return 0;
11920 }
11921 _ACEOF
11922 rm -f conftest.$ac_objext conftest$ac_exeext
11923 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11924   (eval $ac_link) 2>conftest.er1
11925   ac_status=$?
11926   grep -v '^ *+' conftest.er1 >conftest.err
11927   rm -f conftest.er1
11928   cat conftest.err >&5
11929   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11930   (exit $ac_status); } &&
11931          { ac_try='test -z "$ac_c_werror_flag"
11932                          || test ! -s conftest.err'
11933   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11934   (eval $ac_try) 2>&5
11935   ac_status=$?
11936   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11937   (exit $ac_status); }; } &&
11938          { ac_try='test -s conftest$ac_exeext'
11939   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11940   (eval $ac_try) 2>&5
11941   ac_status=$?
11942   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11943   (exit $ac_status); }; }; then
11944   ac_cv_lib_m_atan2l=yes
11945 else
11946   echo "$as_me: failed program was:" >&5
11947 sed 's/^/| /' conftest.$ac_ext >&5
11948
11949 ac_cv_lib_m_atan2l=no
11950 fi
11951 rm -f conftest.err conftest.$ac_objext \
11952       conftest$ac_exeext conftest.$ac_ext
11953 LIBS=$ac_check_lib_save_LIBS
11954 fi
11955 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2l" >&5
11956 echo "${ECHO_T}$ac_cv_lib_m_atan2l" >&6
11957 if test $ac_cv_lib_m_atan2l = yes; then
11958
11959 cat >>confdefs.h <<\_ACEOF
11960 #define HAVE_ATAN2L 1
11961 _ACEOF
11962
11963 fi
11964
11965 echo "$as_me:$LINENO: checking for atanf in -lm" >&5
11966 echo $ECHO_N "checking for atanf in -lm... $ECHO_C" >&6
11967 if test "${ac_cv_lib_m_atanf+set}" = set; then
11968   echo $ECHO_N "(cached) $ECHO_C" >&6
11969 else
11970   ac_check_lib_save_LIBS=$LIBS
11971 LIBS="-lm  $LIBS"
11972 if test x$gcc_no_link = xyes; then
11973   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11974 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11975    { (exit 1); exit 1; }; }
11976 fi
11977 cat >conftest.$ac_ext <<_ACEOF
11978 /* confdefs.h.  */
11979 _ACEOF
11980 cat confdefs.h >>conftest.$ac_ext
11981 cat >>conftest.$ac_ext <<_ACEOF
11982 /* end confdefs.h.  */
11983
11984 /* Override any gcc2 internal prototype to avoid an error.  */
11985 #ifdef __cplusplus
11986 extern "C"
11987 #endif
11988 /* We use char because int might match the return type of a gcc2
11989    builtin and then its argument prototype would still apply.  */
11990 char atanf ();
11991 int
11992 main ()
11993 {
11994 atanf ();
11995   ;
11996   return 0;
11997 }
11998 _ACEOF
11999 rm -f conftest.$ac_objext conftest$ac_exeext
12000 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12001   (eval $ac_link) 2>conftest.er1
12002   ac_status=$?
12003   grep -v '^ *+' conftest.er1 >conftest.err
12004   rm -f conftest.er1
12005   cat conftest.err >&5
12006   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12007   (exit $ac_status); } &&
12008          { ac_try='test -z "$ac_c_werror_flag"
12009                          || test ! -s conftest.err'
12010   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12011   (eval $ac_try) 2>&5
12012   ac_status=$?
12013   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12014   (exit $ac_status); }; } &&
12015          { ac_try='test -s conftest$ac_exeext'
12016   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12017   (eval $ac_try) 2>&5
12018   ac_status=$?
12019   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12020   (exit $ac_status); }; }; then
12021   ac_cv_lib_m_atanf=yes
12022 else
12023   echo "$as_me: failed program was:" >&5
12024 sed 's/^/| /' conftest.$ac_ext >&5
12025
12026 ac_cv_lib_m_atanf=no
12027 fi
12028 rm -f conftest.err conftest.$ac_objext \
12029       conftest$ac_exeext conftest.$ac_ext
12030 LIBS=$ac_check_lib_save_LIBS
12031 fi
12032 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanf" >&5
12033 echo "${ECHO_T}$ac_cv_lib_m_atanf" >&6
12034 if test $ac_cv_lib_m_atanf = yes; then
12035
12036 cat >>confdefs.h <<\_ACEOF
12037 #define HAVE_ATANF 1
12038 _ACEOF
12039
12040 fi
12041
12042 echo "$as_me:$LINENO: checking for atan in -lm" >&5
12043 echo $ECHO_N "checking for atan in -lm... $ECHO_C" >&6
12044 if test "${ac_cv_lib_m_atan+set}" = set; then
12045   echo $ECHO_N "(cached) $ECHO_C" >&6
12046 else
12047   ac_check_lib_save_LIBS=$LIBS
12048 LIBS="-lm  $LIBS"
12049 if test x$gcc_no_link = xyes; then
12050   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12051 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12052    { (exit 1); exit 1; }; }
12053 fi
12054 cat >conftest.$ac_ext <<_ACEOF
12055 /* confdefs.h.  */
12056 _ACEOF
12057 cat confdefs.h >>conftest.$ac_ext
12058 cat >>conftest.$ac_ext <<_ACEOF
12059 /* end confdefs.h.  */
12060
12061 /* Override any gcc2 internal prototype to avoid an error.  */
12062 #ifdef __cplusplus
12063 extern "C"
12064 #endif
12065 /* We use char because int might match the return type of a gcc2
12066    builtin and then its argument prototype would still apply.  */
12067 char atan ();
12068 int
12069 main ()
12070 {
12071 atan ();
12072   ;
12073   return 0;
12074 }
12075 _ACEOF
12076 rm -f conftest.$ac_objext conftest$ac_exeext
12077 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12078   (eval $ac_link) 2>conftest.er1
12079   ac_status=$?
12080   grep -v '^ *+' conftest.er1 >conftest.err
12081   rm -f conftest.er1
12082   cat conftest.err >&5
12083   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12084   (exit $ac_status); } &&
12085          { ac_try='test -z "$ac_c_werror_flag"
12086                          || test ! -s conftest.err'
12087   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12088   (eval $ac_try) 2>&5
12089   ac_status=$?
12090   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12091   (exit $ac_status); }; } &&
12092          { ac_try='test -s conftest$ac_exeext'
12093   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12094   (eval $ac_try) 2>&5
12095   ac_status=$?
12096   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12097   (exit $ac_status); }; }; then
12098   ac_cv_lib_m_atan=yes
12099 else
12100   echo "$as_me: failed program was:" >&5
12101 sed 's/^/| /' conftest.$ac_ext >&5
12102
12103 ac_cv_lib_m_atan=no
12104 fi
12105 rm -f conftest.err conftest.$ac_objext \
12106       conftest$ac_exeext conftest.$ac_ext
12107 LIBS=$ac_check_lib_save_LIBS
12108 fi
12109 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan" >&5
12110 echo "${ECHO_T}$ac_cv_lib_m_atan" >&6
12111 if test $ac_cv_lib_m_atan = yes; then
12112
12113 cat >>confdefs.h <<\_ACEOF
12114 #define HAVE_ATAN 1
12115 _ACEOF
12116
12117 fi
12118
12119 echo "$as_me:$LINENO: checking for atanl in -lm" >&5
12120 echo $ECHO_N "checking for atanl in -lm... $ECHO_C" >&6
12121 if test "${ac_cv_lib_m_atanl+set}" = set; then
12122   echo $ECHO_N "(cached) $ECHO_C" >&6
12123 else
12124   ac_check_lib_save_LIBS=$LIBS
12125 LIBS="-lm  $LIBS"
12126 if test x$gcc_no_link = xyes; then
12127   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12128 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12129    { (exit 1); exit 1; }; }
12130 fi
12131 cat >conftest.$ac_ext <<_ACEOF
12132 /* confdefs.h.  */
12133 _ACEOF
12134 cat confdefs.h >>conftest.$ac_ext
12135 cat >>conftest.$ac_ext <<_ACEOF
12136 /* end confdefs.h.  */
12137
12138 /* Override any gcc2 internal prototype to avoid an error.  */
12139 #ifdef __cplusplus
12140 extern "C"
12141 #endif
12142 /* We use char because int might match the return type of a gcc2
12143    builtin and then its argument prototype would still apply.  */
12144 char atanl ();
12145 int
12146 main ()
12147 {
12148 atanl ();
12149   ;
12150   return 0;
12151 }
12152 _ACEOF
12153 rm -f conftest.$ac_objext conftest$ac_exeext
12154 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12155   (eval $ac_link) 2>conftest.er1
12156   ac_status=$?
12157   grep -v '^ *+' conftest.er1 >conftest.err
12158   rm -f conftest.er1
12159   cat conftest.err >&5
12160   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12161   (exit $ac_status); } &&
12162          { ac_try='test -z "$ac_c_werror_flag"
12163                          || test ! -s conftest.err'
12164   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12165   (eval $ac_try) 2>&5
12166   ac_status=$?
12167   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12168   (exit $ac_status); }; } &&
12169          { ac_try='test -s conftest$ac_exeext'
12170   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12171   (eval $ac_try) 2>&5
12172   ac_status=$?
12173   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12174   (exit $ac_status); }; }; then
12175   ac_cv_lib_m_atanl=yes
12176 else
12177   echo "$as_me: failed program was:" >&5
12178 sed 's/^/| /' conftest.$ac_ext >&5
12179
12180 ac_cv_lib_m_atanl=no
12181 fi
12182 rm -f conftest.err conftest.$ac_objext \
12183       conftest$ac_exeext conftest.$ac_ext
12184 LIBS=$ac_check_lib_save_LIBS
12185 fi
12186 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanl" >&5
12187 echo "${ECHO_T}$ac_cv_lib_m_atanl" >&6
12188 if test $ac_cv_lib_m_atanl = yes; then
12189
12190 cat >>confdefs.h <<\_ACEOF
12191 #define HAVE_ATANL 1
12192 _ACEOF
12193
12194 fi
12195
12196 echo "$as_me:$LINENO: checking for atanhf in -lm" >&5
12197 echo $ECHO_N "checking for atanhf in -lm... $ECHO_C" >&6
12198 if test "${ac_cv_lib_m_atanhf+set}" = set; then
12199   echo $ECHO_N "(cached) $ECHO_C" >&6
12200 else
12201   ac_check_lib_save_LIBS=$LIBS
12202 LIBS="-lm  $LIBS"
12203 if test x$gcc_no_link = xyes; then
12204   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12205 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12206    { (exit 1); exit 1; }; }
12207 fi
12208 cat >conftest.$ac_ext <<_ACEOF
12209 /* confdefs.h.  */
12210 _ACEOF
12211 cat confdefs.h >>conftest.$ac_ext
12212 cat >>conftest.$ac_ext <<_ACEOF
12213 /* end confdefs.h.  */
12214
12215 /* Override any gcc2 internal prototype to avoid an error.  */
12216 #ifdef __cplusplus
12217 extern "C"
12218 #endif
12219 /* We use char because int might match the return type of a gcc2
12220    builtin and then its argument prototype would still apply.  */
12221 char atanhf ();
12222 int
12223 main ()
12224 {
12225 atanhf ();
12226   ;
12227   return 0;
12228 }
12229 _ACEOF
12230 rm -f conftest.$ac_objext conftest$ac_exeext
12231 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12232   (eval $ac_link) 2>conftest.er1
12233   ac_status=$?
12234   grep -v '^ *+' conftest.er1 >conftest.err
12235   rm -f conftest.er1
12236   cat conftest.err >&5
12237   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12238   (exit $ac_status); } &&
12239          { ac_try='test -z "$ac_c_werror_flag"
12240                          || test ! -s conftest.err'
12241   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12242   (eval $ac_try) 2>&5
12243   ac_status=$?
12244   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12245   (exit $ac_status); }; } &&
12246          { ac_try='test -s conftest$ac_exeext'
12247   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12248   (eval $ac_try) 2>&5
12249   ac_status=$?
12250   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12251   (exit $ac_status); }; }; then
12252   ac_cv_lib_m_atanhf=yes
12253 else
12254   echo "$as_me: failed program was:" >&5
12255 sed 's/^/| /' conftest.$ac_ext >&5
12256
12257 ac_cv_lib_m_atanhf=no
12258 fi
12259 rm -f conftest.err conftest.$ac_objext \
12260       conftest$ac_exeext conftest.$ac_ext
12261 LIBS=$ac_check_lib_save_LIBS
12262 fi
12263 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanhf" >&5
12264 echo "${ECHO_T}$ac_cv_lib_m_atanhf" >&6
12265 if test $ac_cv_lib_m_atanhf = yes; then
12266
12267 cat >>confdefs.h <<\_ACEOF
12268 #define HAVE_ATANHF 1
12269 _ACEOF
12270
12271 fi
12272
12273 echo "$as_me:$LINENO: checking for atanh in -lm" >&5
12274 echo $ECHO_N "checking for atanh in -lm... $ECHO_C" >&6
12275 if test "${ac_cv_lib_m_atanh+set}" = set; then
12276   echo $ECHO_N "(cached) $ECHO_C" >&6
12277 else
12278   ac_check_lib_save_LIBS=$LIBS
12279 LIBS="-lm  $LIBS"
12280 if test x$gcc_no_link = xyes; then
12281   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12282 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12283    { (exit 1); exit 1; }; }
12284 fi
12285 cat >conftest.$ac_ext <<_ACEOF
12286 /* confdefs.h.  */
12287 _ACEOF
12288 cat confdefs.h >>conftest.$ac_ext
12289 cat >>conftest.$ac_ext <<_ACEOF
12290 /* end confdefs.h.  */
12291
12292 /* Override any gcc2 internal prototype to avoid an error.  */
12293 #ifdef __cplusplus
12294 extern "C"
12295 #endif
12296 /* We use char because int might match the return type of a gcc2
12297    builtin and then its argument prototype would still apply.  */
12298 char atanh ();
12299 int
12300 main ()
12301 {
12302 atanh ();
12303   ;
12304   return 0;
12305 }
12306 _ACEOF
12307 rm -f conftest.$ac_objext conftest$ac_exeext
12308 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12309   (eval $ac_link) 2>conftest.er1
12310   ac_status=$?
12311   grep -v '^ *+' conftest.er1 >conftest.err
12312   rm -f conftest.er1
12313   cat conftest.err >&5
12314   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12315   (exit $ac_status); } &&
12316          { ac_try='test -z "$ac_c_werror_flag"
12317                          || test ! -s conftest.err'
12318   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12319   (eval $ac_try) 2>&5
12320   ac_status=$?
12321   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12322   (exit $ac_status); }; } &&
12323          { ac_try='test -s conftest$ac_exeext'
12324   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12325   (eval $ac_try) 2>&5
12326   ac_status=$?
12327   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12328   (exit $ac_status); }; }; then
12329   ac_cv_lib_m_atanh=yes
12330 else
12331   echo "$as_me: failed program was:" >&5
12332 sed 's/^/| /' conftest.$ac_ext >&5
12333
12334 ac_cv_lib_m_atanh=no
12335 fi
12336 rm -f conftest.err conftest.$ac_objext \
12337       conftest$ac_exeext conftest.$ac_ext
12338 LIBS=$ac_check_lib_save_LIBS
12339 fi
12340 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanh" >&5
12341 echo "${ECHO_T}$ac_cv_lib_m_atanh" >&6
12342 if test $ac_cv_lib_m_atanh = yes; then
12343
12344 cat >>confdefs.h <<\_ACEOF
12345 #define HAVE_ATANH 1
12346 _ACEOF
12347
12348 fi
12349
12350 echo "$as_me:$LINENO: checking for atanhl in -lm" >&5
12351 echo $ECHO_N "checking for atanhl in -lm... $ECHO_C" >&6
12352 if test "${ac_cv_lib_m_atanhl+set}" = set; then
12353   echo $ECHO_N "(cached) $ECHO_C" >&6
12354 else
12355   ac_check_lib_save_LIBS=$LIBS
12356 LIBS="-lm  $LIBS"
12357 if test x$gcc_no_link = xyes; then
12358   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12359 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12360    { (exit 1); exit 1; }; }
12361 fi
12362 cat >conftest.$ac_ext <<_ACEOF
12363 /* confdefs.h.  */
12364 _ACEOF
12365 cat confdefs.h >>conftest.$ac_ext
12366 cat >>conftest.$ac_ext <<_ACEOF
12367 /* end confdefs.h.  */
12368
12369 /* Override any gcc2 internal prototype to avoid an error.  */
12370 #ifdef __cplusplus
12371 extern "C"
12372 #endif
12373 /* We use char because int might match the return type of a gcc2
12374    builtin and then its argument prototype would still apply.  */
12375 char atanhl ();
12376 int
12377 main ()
12378 {
12379 atanhl ();
12380   ;
12381   return 0;
12382 }
12383 _ACEOF
12384 rm -f conftest.$ac_objext conftest$ac_exeext
12385 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12386   (eval $ac_link) 2>conftest.er1
12387   ac_status=$?
12388   grep -v '^ *+' conftest.er1 >conftest.err
12389   rm -f conftest.er1
12390   cat conftest.err >&5
12391   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12392   (exit $ac_status); } &&
12393          { ac_try='test -z "$ac_c_werror_flag"
12394                          || test ! -s conftest.err'
12395   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12396   (eval $ac_try) 2>&5
12397   ac_status=$?
12398   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12399   (exit $ac_status); }; } &&
12400          { ac_try='test -s conftest$ac_exeext'
12401   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12402   (eval $ac_try) 2>&5
12403   ac_status=$?
12404   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12405   (exit $ac_status); }; }; then
12406   ac_cv_lib_m_atanhl=yes
12407 else
12408   echo "$as_me: failed program was:" >&5
12409 sed 's/^/| /' conftest.$ac_ext >&5
12410
12411 ac_cv_lib_m_atanhl=no
12412 fi
12413 rm -f conftest.err conftest.$ac_objext \
12414       conftest$ac_exeext conftest.$ac_ext
12415 LIBS=$ac_check_lib_save_LIBS
12416 fi
12417 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanhl" >&5
12418 echo "${ECHO_T}$ac_cv_lib_m_atanhl" >&6
12419 if test $ac_cv_lib_m_atanhl = yes; then
12420
12421 cat >>confdefs.h <<\_ACEOF
12422 #define HAVE_ATANHL 1
12423 _ACEOF
12424
12425 fi
12426
12427 echo "$as_me:$LINENO: checking for cargf in -lm" >&5
12428 echo $ECHO_N "checking for cargf in -lm... $ECHO_C" >&6
12429 if test "${ac_cv_lib_m_cargf+set}" = set; then
12430   echo $ECHO_N "(cached) $ECHO_C" >&6
12431 else
12432   ac_check_lib_save_LIBS=$LIBS
12433 LIBS="-lm  $LIBS"
12434 if test x$gcc_no_link = xyes; then
12435   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12436 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12437    { (exit 1); exit 1; }; }
12438 fi
12439 cat >conftest.$ac_ext <<_ACEOF
12440 /* confdefs.h.  */
12441 _ACEOF
12442 cat confdefs.h >>conftest.$ac_ext
12443 cat >>conftest.$ac_ext <<_ACEOF
12444 /* end confdefs.h.  */
12445
12446 /* Override any gcc2 internal prototype to avoid an error.  */
12447 #ifdef __cplusplus
12448 extern "C"
12449 #endif
12450 /* We use char because int might match the return type of a gcc2
12451    builtin and then its argument prototype would still apply.  */
12452 char cargf ();
12453 int
12454 main ()
12455 {
12456 cargf ();
12457   ;
12458   return 0;
12459 }
12460 _ACEOF
12461 rm -f conftest.$ac_objext conftest$ac_exeext
12462 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12463   (eval $ac_link) 2>conftest.er1
12464   ac_status=$?
12465   grep -v '^ *+' conftest.er1 >conftest.err
12466   rm -f conftest.er1
12467   cat conftest.err >&5
12468   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12469   (exit $ac_status); } &&
12470          { ac_try='test -z "$ac_c_werror_flag"
12471                          || test ! -s conftest.err'
12472   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12473   (eval $ac_try) 2>&5
12474   ac_status=$?
12475   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12476   (exit $ac_status); }; } &&
12477          { ac_try='test -s conftest$ac_exeext'
12478   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12479   (eval $ac_try) 2>&5
12480   ac_status=$?
12481   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12482   (exit $ac_status); }; }; then
12483   ac_cv_lib_m_cargf=yes
12484 else
12485   echo "$as_me: failed program was:" >&5
12486 sed 's/^/| /' conftest.$ac_ext >&5
12487
12488 ac_cv_lib_m_cargf=no
12489 fi
12490 rm -f conftest.err conftest.$ac_objext \
12491       conftest$ac_exeext conftest.$ac_ext
12492 LIBS=$ac_check_lib_save_LIBS
12493 fi
12494 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cargf" >&5
12495 echo "${ECHO_T}$ac_cv_lib_m_cargf" >&6
12496 if test $ac_cv_lib_m_cargf = yes; then
12497
12498 cat >>confdefs.h <<\_ACEOF
12499 #define HAVE_CARGF 1
12500 _ACEOF
12501
12502 fi
12503
12504 echo "$as_me:$LINENO: checking for carg in -lm" >&5
12505 echo $ECHO_N "checking for carg in -lm... $ECHO_C" >&6
12506 if test "${ac_cv_lib_m_carg+set}" = set; then
12507   echo $ECHO_N "(cached) $ECHO_C" >&6
12508 else
12509   ac_check_lib_save_LIBS=$LIBS
12510 LIBS="-lm  $LIBS"
12511 if test x$gcc_no_link = xyes; then
12512   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12513 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12514    { (exit 1); exit 1; }; }
12515 fi
12516 cat >conftest.$ac_ext <<_ACEOF
12517 /* confdefs.h.  */
12518 _ACEOF
12519 cat confdefs.h >>conftest.$ac_ext
12520 cat >>conftest.$ac_ext <<_ACEOF
12521 /* end confdefs.h.  */
12522
12523 /* Override any gcc2 internal prototype to avoid an error.  */
12524 #ifdef __cplusplus
12525 extern "C"
12526 #endif
12527 /* We use char because int might match the return type of a gcc2
12528    builtin and then its argument prototype would still apply.  */
12529 char carg ();
12530 int
12531 main ()
12532 {
12533 carg ();
12534   ;
12535   return 0;
12536 }
12537 _ACEOF
12538 rm -f conftest.$ac_objext conftest$ac_exeext
12539 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12540   (eval $ac_link) 2>conftest.er1
12541   ac_status=$?
12542   grep -v '^ *+' conftest.er1 >conftest.err
12543   rm -f conftest.er1
12544   cat conftest.err >&5
12545   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12546   (exit $ac_status); } &&
12547          { ac_try='test -z "$ac_c_werror_flag"
12548                          || test ! -s conftest.err'
12549   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12550   (eval $ac_try) 2>&5
12551   ac_status=$?
12552   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12553   (exit $ac_status); }; } &&
12554          { ac_try='test -s conftest$ac_exeext'
12555   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12556   (eval $ac_try) 2>&5
12557   ac_status=$?
12558   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12559   (exit $ac_status); }; }; then
12560   ac_cv_lib_m_carg=yes
12561 else
12562   echo "$as_me: failed program was:" >&5
12563 sed 's/^/| /' conftest.$ac_ext >&5
12564
12565 ac_cv_lib_m_carg=no
12566 fi
12567 rm -f conftest.err conftest.$ac_objext \
12568       conftest$ac_exeext conftest.$ac_ext
12569 LIBS=$ac_check_lib_save_LIBS
12570 fi
12571 echo "$as_me:$LINENO: result: $ac_cv_lib_m_carg" >&5
12572 echo "${ECHO_T}$ac_cv_lib_m_carg" >&6
12573 if test $ac_cv_lib_m_carg = yes; then
12574
12575 cat >>confdefs.h <<\_ACEOF
12576 #define HAVE_CARG 1
12577 _ACEOF
12578
12579 fi
12580
12581 echo "$as_me:$LINENO: checking for cargl in -lm" >&5
12582 echo $ECHO_N "checking for cargl in -lm... $ECHO_C" >&6
12583 if test "${ac_cv_lib_m_cargl+set}" = set; then
12584   echo $ECHO_N "(cached) $ECHO_C" >&6
12585 else
12586   ac_check_lib_save_LIBS=$LIBS
12587 LIBS="-lm  $LIBS"
12588 if test x$gcc_no_link = xyes; then
12589   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12590 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12591    { (exit 1); exit 1; }; }
12592 fi
12593 cat >conftest.$ac_ext <<_ACEOF
12594 /* confdefs.h.  */
12595 _ACEOF
12596 cat confdefs.h >>conftest.$ac_ext
12597 cat >>conftest.$ac_ext <<_ACEOF
12598 /* end confdefs.h.  */
12599
12600 /* Override any gcc2 internal prototype to avoid an error.  */
12601 #ifdef __cplusplus
12602 extern "C"
12603 #endif
12604 /* We use char because int might match the return type of a gcc2
12605    builtin and then its argument prototype would still apply.  */
12606 char cargl ();
12607 int
12608 main ()
12609 {
12610 cargl ();
12611   ;
12612   return 0;
12613 }
12614 _ACEOF
12615 rm -f conftest.$ac_objext conftest$ac_exeext
12616 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12617   (eval $ac_link) 2>conftest.er1
12618   ac_status=$?
12619   grep -v '^ *+' conftest.er1 >conftest.err
12620   rm -f conftest.er1
12621   cat conftest.err >&5
12622   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12623   (exit $ac_status); } &&
12624          { ac_try='test -z "$ac_c_werror_flag"
12625                          || test ! -s conftest.err'
12626   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12627   (eval $ac_try) 2>&5
12628   ac_status=$?
12629   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12630   (exit $ac_status); }; } &&
12631          { ac_try='test -s conftest$ac_exeext'
12632   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12633   (eval $ac_try) 2>&5
12634   ac_status=$?
12635   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12636   (exit $ac_status); }; }; then
12637   ac_cv_lib_m_cargl=yes
12638 else
12639   echo "$as_me: failed program was:" >&5
12640 sed 's/^/| /' conftest.$ac_ext >&5
12641
12642 ac_cv_lib_m_cargl=no
12643 fi
12644 rm -f conftest.err conftest.$ac_objext \
12645       conftest$ac_exeext conftest.$ac_ext
12646 LIBS=$ac_check_lib_save_LIBS
12647 fi
12648 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cargl" >&5
12649 echo "${ECHO_T}$ac_cv_lib_m_cargl" >&6
12650 if test $ac_cv_lib_m_cargl = yes; then
12651
12652 cat >>confdefs.h <<\_ACEOF
12653 #define HAVE_CARGL 1
12654 _ACEOF
12655
12656 fi
12657
12658 echo "$as_me:$LINENO: checking for ceilf in -lm" >&5
12659 echo $ECHO_N "checking for ceilf in -lm... $ECHO_C" >&6
12660 if test "${ac_cv_lib_m_ceilf+set}" = set; then
12661   echo $ECHO_N "(cached) $ECHO_C" >&6
12662 else
12663   ac_check_lib_save_LIBS=$LIBS
12664 LIBS="-lm  $LIBS"
12665 if test x$gcc_no_link = xyes; then
12666   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12667 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12668    { (exit 1); exit 1; }; }
12669 fi
12670 cat >conftest.$ac_ext <<_ACEOF
12671 /* confdefs.h.  */
12672 _ACEOF
12673 cat confdefs.h >>conftest.$ac_ext
12674 cat >>conftest.$ac_ext <<_ACEOF
12675 /* end confdefs.h.  */
12676
12677 /* Override any gcc2 internal prototype to avoid an error.  */
12678 #ifdef __cplusplus
12679 extern "C"
12680 #endif
12681 /* We use char because int might match the return type of a gcc2
12682    builtin and then its argument prototype would still apply.  */
12683 char ceilf ();
12684 int
12685 main ()
12686 {
12687 ceilf ();
12688   ;
12689   return 0;
12690 }
12691 _ACEOF
12692 rm -f conftest.$ac_objext conftest$ac_exeext
12693 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12694   (eval $ac_link) 2>conftest.er1
12695   ac_status=$?
12696   grep -v '^ *+' conftest.er1 >conftest.err
12697   rm -f conftest.er1
12698   cat conftest.err >&5
12699   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12700   (exit $ac_status); } &&
12701          { ac_try='test -z "$ac_c_werror_flag"
12702                          || test ! -s conftest.err'
12703   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12704   (eval $ac_try) 2>&5
12705   ac_status=$?
12706   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12707   (exit $ac_status); }; } &&
12708          { ac_try='test -s conftest$ac_exeext'
12709   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12710   (eval $ac_try) 2>&5
12711   ac_status=$?
12712   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12713   (exit $ac_status); }; }; then
12714   ac_cv_lib_m_ceilf=yes
12715 else
12716   echo "$as_me: failed program was:" >&5
12717 sed 's/^/| /' conftest.$ac_ext >&5
12718
12719 ac_cv_lib_m_ceilf=no
12720 fi
12721 rm -f conftest.err conftest.$ac_objext \
12722       conftest$ac_exeext conftest.$ac_ext
12723 LIBS=$ac_check_lib_save_LIBS
12724 fi
12725 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceilf" >&5
12726 echo "${ECHO_T}$ac_cv_lib_m_ceilf" >&6
12727 if test $ac_cv_lib_m_ceilf = yes; then
12728
12729 cat >>confdefs.h <<\_ACEOF
12730 #define HAVE_CEILF 1
12731 _ACEOF
12732
12733 fi
12734
12735 echo "$as_me:$LINENO: checking for ceil in -lm" >&5
12736 echo $ECHO_N "checking for ceil in -lm... $ECHO_C" >&6
12737 if test "${ac_cv_lib_m_ceil+set}" = set; then
12738   echo $ECHO_N "(cached) $ECHO_C" >&6
12739 else
12740   ac_check_lib_save_LIBS=$LIBS
12741 LIBS="-lm  $LIBS"
12742 if test x$gcc_no_link = xyes; then
12743   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12744 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12745    { (exit 1); exit 1; }; }
12746 fi
12747 cat >conftest.$ac_ext <<_ACEOF
12748 /* confdefs.h.  */
12749 _ACEOF
12750 cat confdefs.h >>conftest.$ac_ext
12751 cat >>conftest.$ac_ext <<_ACEOF
12752 /* end confdefs.h.  */
12753
12754 /* Override any gcc2 internal prototype to avoid an error.  */
12755 #ifdef __cplusplus
12756 extern "C"
12757 #endif
12758 /* We use char because int might match the return type of a gcc2
12759    builtin and then its argument prototype would still apply.  */
12760 char ceil ();
12761 int
12762 main ()
12763 {
12764 ceil ();
12765   ;
12766   return 0;
12767 }
12768 _ACEOF
12769 rm -f conftest.$ac_objext conftest$ac_exeext
12770 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12771   (eval $ac_link) 2>conftest.er1
12772   ac_status=$?
12773   grep -v '^ *+' conftest.er1 >conftest.err
12774   rm -f conftest.er1
12775   cat conftest.err >&5
12776   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12777   (exit $ac_status); } &&
12778          { ac_try='test -z "$ac_c_werror_flag"
12779                          || test ! -s conftest.err'
12780   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12781   (eval $ac_try) 2>&5
12782   ac_status=$?
12783   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12784   (exit $ac_status); }; } &&
12785          { ac_try='test -s conftest$ac_exeext'
12786   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12787   (eval $ac_try) 2>&5
12788   ac_status=$?
12789   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12790   (exit $ac_status); }; }; then
12791   ac_cv_lib_m_ceil=yes
12792 else
12793   echo "$as_me: failed program was:" >&5
12794 sed 's/^/| /' conftest.$ac_ext >&5
12795
12796 ac_cv_lib_m_ceil=no
12797 fi
12798 rm -f conftest.err conftest.$ac_objext \
12799       conftest$ac_exeext conftest.$ac_ext
12800 LIBS=$ac_check_lib_save_LIBS
12801 fi
12802 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceil" >&5
12803 echo "${ECHO_T}$ac_cv_lib_m_ceil" >&6
12804 if test $ac_cv_lib_m_ceil = yes; then
12805
12806 cat >>confdefs.h <<\_ACEOF
12807 #define HAVE_CEIL 1
12808 _ACEOF
12809
12810 fi
12811
12812 echo "$as_me:$LINENO: checking for ceill in -lm" >&5
12813 echo $ECHO_N "checking for ceill in -lm... $ECHO_C" >&6
12814 if test "${ac_cv_lib_m_ceill+set}" = set; then
12815   echo $ECHO_N "(cached) $ECHO_C" >&6
12816 else
12817   ac_check_lib_save_LIBS=$LIBS
12818 LIBS="-lm  $LIBS"
12819 if test x$gcc_no_link = xyes; then
12820   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12821 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12822    { (exit 1); exit 1; }; }
12823 fi
12824 cat >conftest.$ac_ext <<_ACEOF
12825 /* confdefs.h.  */
12826 _ACEOF
12827 cat confdefs.h >>conftest.$ac_ext
12828 cat >>conftest.$ac_ext <<_ACEOF
12829 /* end confdefs.h.  */
12830
12831 /* Override any gcc2 internal prototype to avoid an error.  */
12832 #ifdef __cplusplus
12833 extern "C"
12834 #endif
12835 /* We use char because int might match the return type of a gcc2
12836    builtin and then its argument prototype would still apply.  */
12837 char ceill ();
12838 int
12839 main ()
12840 {
12841 ceill ();
12842   ;
12843   return 0;
12844 }
12845 _ACEOF
12846 rm -f conftest.$ac_objext conftest$ac_exeext
12847 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12848   (eval $ac_link) 2>conftest.er1
12849   ac_status=$?
12850   grep -v '^ *+' conftest.er1 >conftest.err
12851   rm -f conftest.er1
12852   cat conftest.err >&5
12853   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12854   (exit $ac_status); } &&
12855          { ac_try='test -z "$ac_c_werror_flag"
12856                          || test ! -s conftest.err'
12857   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12858   (eval $ac_try) 2>&5
12859   ac_status=$?
12860   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12861   (exit $ac_status); }; } &&
12862          { ac_try='test -s conftest$ac_exeext'
12863   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12864   (eval $ac_try) 2>&5
12865   ac_status=$?
12866   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12867   (exit $ac_status); }; }; then
12868   ac_cv_lib_m_ceill=yes
12869 else
12870   echo "$as_me: failed program was:" >&5
12871 sed 's/^/| /' conftest.$ac_ext >&5
12872
12873 ac_cv_lib_m_ceill=no
12874 fi
12875 rm -f conftest.err conftest.$ac_objext \
12876       conftest$ac_exeext conftest.$ac_ext
12877 LIBS=$ac_check_lib_save_LIBS
12878 fi
12879 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceill" >&5
12880 echo "${ECHO_T}$ac_cv_lib_m_ceill" >&6
12881 if test $ac_cv_lib_m_ceill = yes; then
12882
12883 cat >>confdefs.h <<\_ACEOF
12884 #define HAVE_CEILL 1
12885 _ACEOF
12886
12887 fi
12888
12889 echo "$as_me:$LINENO: checking for copysignf in -lm" >&5
12890 echo $ECHO_N "checking for copysignf in -lm... $ECHO_C" >&6
12891 if test "${ac_cv_lib_m_copysignf+set}" = set; then
12892   echo $ECHO_N "(cached) $ECHO_C" >&6
12893 else
12894   ac_check_lib_save_LIBS=$LIBS
12895 LIBS="-lm  $LIBS"
12896 if test x$gcc_no_link = xyes; then
12897   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12898 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12899    { (exit 1); exit 1; }; }
12900 fi
12901 cat >conftest.$ac_ext <<_ACEOF
12902 /* confdefs.h.  */
12903 _ACEOF
12904 cat confdefs.h >>conftest.$ac_ext
12905 cat >>conftest.$ac_ext <<_ACEOF
12906 /* end confdefs.h.  */
12907
12908 /* Override any gcc2 internal prototype to avoid an error.  */
12909 #ifdef __cplusplus
12910 extern "C"
12911 #endif
12912 /* We use char because int might match the return type of a gcc2
12913    builtin and then its argument prototype would still apply.  */
12914 char copysignf ();
12915 int
12916 main ()
12917 {
12918 copysignf ();
12919   ;
12920   return 0;
12921 }
12922 _ACEOF
12923 rm -f conftest.$ac_objext conftest$ac_exeext
12924 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12925   (eval $ac_link) 2>conftest.er1
12926   ac_status=$?
12927   grep -v '^ *+' conftest.er1 >conftest.err
12928   rm -f conftest.er1
12929   cat conftest.err >&5
12930   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12931   (exit $ac_status); } &&
12932          { ac_try='test -z "$ac_c_werror_flag"
12933                          || test ! -s conftest.err'
12934   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12935   (eval $ac_try) 2>&5
12936   ac_status=$?
12937   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12938   (exit $ac_status); }; } &&
12939          { ac_try='test -s conftest$ac_exeext'
12940   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12941   (eval $ac_try) 2>&5
12942   ac_status=$?
12943   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12944   (exit $ac_status); }; }; then
12945   ac_cv_lib_m_copysignf=yes
12946 else
12947   echo "$as_me: failed program was:" >&5
12948 sed 's/^/| /' conftest.$ac_ext >&5
12949
12950 ac_cv_lib_m_copysignf=no
12951 fi
12952 rm -f conftest.err conftest.$ac_objext \
12953       conftest$ac_exeext conftest.$ac_ext
12954 LIBS=$ac_check_lib_save_LIBS
12955 fi
12956 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysignf" >&5
12957 echo "${ECHO_T}$ac_cv_lib_m_copysignf" >&6
12958 if test $ac_cv_lib_m_copysignf = yes; then
12959
12960 cat >>confdefs.h <<\_ACEOF
12961 #define HAVE_COPYSIGNF 1
12962 _ACEOF
12963
12964 fi
12965
12966 echo "$as_me:$LINENO: checking for copysign in -lm" >&5
12967 echo $ECHO_N "checking for copysign in -lm... $ECHO_C" >&6
12968 if test "${ac_cv_lib_m_copysign+set}" = set; then
12969   echo $ECHO_N "(cached) $ECHO_C" >&6
12970 else
12971   ac_check_lib_save_LIBS=$LIBS
12972 LIBS="-lm  $LIBS"
12973 if test x$gcc_no_link = xyes; then
12974   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12975 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12976    { (exit 1); exit 1; }; }
12977 fi
12978 cat >conftest.$ac_ext <<_ACEOF
12979 /* confdefs.h.  */
12980 _ACEOF
12981 cat confdefs.h >>conftest.$ac_ext
12982 cat >>conftest.$ac_ext <<_ACEOF
12983 /* end confdefs.h.  */
12984
12985 /* Override any gcc2 internal prototype to avoid an error.  */
12986 #ifdef __cplusplus
12987 extern "C"
12988 #endif
12989 /* We use char because int might match the return type of a gcc2
12990    builtin and then its argument prototype would still apply.  */
12991 char copysign ();
12992 int
12993 main ()
12994 {
12995 copysign ();
12996   ;
12997   return 0;
12998 }
12999 _ACEOF
13000 rm -f conftest.$ac_objext conftest$ac_exeext
13001 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13002   (eval $ac_link) 2>conftest.er1
13003   ac_status=$?
13004   grep -v '^ *+' conftest.er1 >conftest.err
13005   rm -f conftest.er1
13006   cat conftest.err >&5
13007   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13008   (exit $ac_status); } &&
13009          { ac_try='test -z "$ac_c_werror_flag"
13010                          || test ! -s conftest.err'
13011   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13012   (eval $ac_try) 2>&5
13013   ac_status=$?
13014   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13015   (exit $ac_status); }; } &&
13016          { ac_try='test -s conftest$ac_exeext'
13017   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13018   (eval $ac_try) 2>&5
13019   ac_status=$?
13020   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13021   (exit $ac_status); }; }; then
13022   ac_cv_lib_m_copysign=yes
13023 else
13024   echo "$as_me: failed program was:" >&5
13025 sed 's/^/| /' conftest.$ac_ext >&5
13026
13027 ac_cv_lib_m_copysign=no
13028 fi
13029 rm -f conftest.err conftest.$ac_objext \
13030       conftest$ac_exeext conftest.$ac_ext
13031 LIBS=$ac_check_lib_save_LIBS
13032 fi
13033 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysign" >&5
13034 echo "${ECHO_T}$ac_cv_lib_m_copysign" >&6
13035 if test $ac_cv_lib_m_copysign = yes; then
13036
13037 cat >>confdefs.h <<\_ACEOF
13038 #define HAVE_COPYSIGN 1
13039 _ACEOF
13040
13041 fi
13042
13043 echo "$as_me:$LINENO: checking for copysignl in -lm" >&5
13044 echo $ECHO_N "checking for copysignl in -lm... $ECHO_C" >&6
13045 if test "${ac_cv_lib_m_copysignl+set}" = set; then
13046   echo $ECHO_N "(cached) $ECHO_C" >&6
13047 else
13048   ac_check_lib_save_LIBS=$LIBS
13049 LIBS="-lm  $LIBS"
13050 if test x$gcc_no_link = xyes; then
13051   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13052 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13053    { (exit 1); exit 1; }; }
13054 fi
13055 cat >conftest.$ac_ext <<_ACEOF
13056 /* confdefs.h.  */
13057 _ACEOF
13058 cat confdefs.h >>conftest.$ac_ext
13059 cat >>conftest.$ac_ext <<_ACEOF
13060 /* end confdefs.h.  */
13061
13062 /* Override any gcc2 internal prototype to avoid an error.  */
13063 #ifdef __cplusplus
13064 extern "C"
13065 #endif
13066 /* We use char because int might match the return type of a gcc2
13067    builtin and then its argument prototype would still apply.  */
13068 char copysignl ();
13069 int
13070 main ()
13071 {
13072 copysignl ();
13073   ;
13074   return 0;
13075 }
13076 _ACEOF
13077 rm -f conftest.$ac_objext conftest$ac_exeext
13078 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13079   (eval $ac_link) 2>conftest.er1
13080   ac_status=$?
13081   grep -v '^ *+' conftest.er1 >conftest.err
13082   rm -f conftest.er1
13083   cat conftest.err >&5
13084   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13085   (exit $ac_status); } &&
13086          { ac_try='test -z "$ac_c_werror_flag"
13087                          || test ! -s conftest.err'
13088   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13089   (eval $ac_try) 2>&5
13090   ac_status=$?
13091   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13092   (exit $ac_status); }; } &&
13093          { ac_try='test -s conftest$ac_exeext'
13094   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13095   (eval $ac_try) 2>&5
13096   ac_status=$?
13097   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13098   (exit $ac_status); }; }; then
13099   ac_cv_lib_m_copysignl=yes
13100 else
13101   echo "$as_me: failed program was:" >&5
13102 sed 's/^/| /' conftest.$ac_ext >&5
13103
13104 ac_cv_lib_m_copysignl=no
13105 fi
13106 rm -f conftest.err conftest.$ac_objext \
13107       conftest$ac_exeext conftest.$ac_ext
13108 LIBS=$ac_check_lib_save_LIBS
13109 fi
13110 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysignl" >&5
13111 echo "${ECHO_T}$ac_cv_lib_m_copysignl" >&6
13112 if test $ac_cv_lib_m_copysignl = yes; then
13113
13114 cat >>confdefs.h <<\_ACEOF
13115 #define HAVE_COPYSIGNL 1
13116 _ACEOF
13117
13118 fi
13119
13120 echo "$as_me:$LINENO: checking for cosf in -lm" >&5
13121 echo $ECHO_N "checking for cosf in -lm... $ECHO_C" >&6
13122 if test "${ac_cv_lib_m_cosf+set}" = set; then
13123   echo $ECHO_N "(cached) $ECHO_C" >&6
13124 else
13125   ac_check_lib_save_LIBS=$LIBS
13126 LIBS="-lm  $LIBS"
13127 if test x$gcc_no_link = xyes; then
13128   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13129 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13130    { (exit 1); exit 1; }; }
13131 fi
13132 cat >conftest.$ac_ext <<_ACEOF
13133 /* confdefs.h.  */
13134 _ACEOF
13135 cat confdefs.h >>conftest.$ac_ext
13136 cat >>conftest.$ac_ext <<_ACEOF
13137 /* end confdefs.h.  */
13138
13139 /* Override any gcc2 internal prototype to avoid an error.  */
13140 #ifdef __cplusplus
13141 extern "C"
13142 #endif
13143 /* We use char because int might match the return type of a gcc2
13144    builtin and then its argument prototype would still apply.  */
13145 char cosf ();
13146 int
13147 main ()
13148 {
13149 cosf ();
13150   ;
13151   return 0;
13152 }
13153 _ACEOF
13154 rm -f conftest.$ac_objext conftest$ac_exeext
13155 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13156   (eval $ac_link) 2>conftest.er1
13157   ac_status=$?
13158   grep -v '^ *+' conftest.er1 >conftest.err
13159   rm -f conftest.er1
13160   cat conftest.err >&5
13161   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13162   (exit $ac_status); } &&
13163          { ac_try='test -z "$ac_c_werror_flag"
13164                          || test ! -s conftest.err'
13165   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13166   (eval $ac_try) 2>&5
13167   ac_status=$?
13168   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13169   (exit $ac_status); }; } &&
13170          { ac_try='test -s conftest$ac_exeext'
13171   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13172   (eval $ac_try) 2>&5
13173   ac_status=$?
13174   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13175   (exit $ac_status); }; }; then
13176   ac_cv_lib_m_cosf=yes
13177 else
13178   echo "$as_me: failed program was:" >&5
13179 sed 's/^/| /' conftest.$ac_ext >&5
13180
13181 ac_cv_lib_m_cosf=no
13182 fi
13183 rm -f conftest.err conftest.$ac_objext \
13184       conftest$ac_exeext conftest.$ac_ext
13185 LIBS=$ac_check_lib_save_LIBS
13186 fi
13187 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosf" >&5
13188 echo "${ECHO_T}$ac_cv_lib_m_cosf" >&6
13189 if test $ac_cv_lib_m_cosf = yes; then
13190
13191 cat >>confdefs.h <<\_ACEOF
13192 #define HAVE_COSF 1
13193 _ACEOF
13194
13195 fi
13196
13197 echo "$as_me:$LINENO: checking for cos in -lm" >&5
13198 echo $ECHO_N "checking for cos in -lm... $ECHO_C" >&6
13199 if test "${ac_cv_lib_m_cos+set}" = set; then
13200   echo $ECHO_N "(cached) $ECHO_C" >&6
13201 else
13202   ac_check_lib_save_LIBS=$LIBS
13203 LIBS="-lm  $LIBS"
13204 if test x$gcc_no_link = xyes; then
13205   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13206 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13207    { (exit 1); exit 1; }; }
13208 fi
13209 cat >conftest.$ac_ext <<_ACEOF
13210 /* confdefs.h.  */
13211 _ACEOF
13212 cat confdefs.h >>conftest.$ac_ext
13213 cat >>conftest.$ac_ext <<_ACEOF
13214 /* end confdefs.h.  */
13215
13216 /* Override any gcc2 internal prototype to avoid an error.  */
13217 #ifdef __cplusplus
13218 extern "C"
13219 #endif
13220 /* We use char because int might match the return type of a gcc2
13221    builtin and then its argument prototype would still apply.  */
13222 char cos ();
13223 int
13224 main ()
13225 {
13226 cos ();
13227   ;
13228   return 0;
13229 }
13230 _ACEOF
13231 rm -f conftest.$ac_objext conftest$ac_exeext
13232 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13233   (eval $ac_link) 2>conftest.er1
13234   ac_status=$?
13235   grep -v '^ *+' conftest.er1 >conftest.err
13236   rm -f conftest.er1
13237   cat conftest.err >&5
13238   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13239   (exit $ac_status); } &&
13240          { ac_try='test -z "$ac_c_werror_flag"
13241                          || test ! -s conftest.err'
13242   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13243   (eval $ac_try) 2>&5
13244   ac_status=$?
13245   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13246   (exit $ac_status); }; } &&
13247          { ac_try='test -s conftest$ac_exeext'
13248   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13249   (eval $ac_try) 2>&5
13250   ac_status=$?
13251   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13252   (exit $ac_status); }; }; then
13253   ac_cv_lib_m_cos=yes
13254 else
13255   echo "$as_me: failed program was:" >&5
13256 sed 's/^/| /' conftest.$ac_ext >&5
13257
13258 ac_cv_lib_m_cos=no
13259 fi
13260 rm -f conftest.err conftest.$ac_objext \
13261       conftest$ac_exeext conftest.$ac_ext
13262 LIBS=$ac_check_lib_save_LIBS
13263 fi
13264 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cos" >&5
13265 echo "${ECHO_T}$ac_cv_lib_m_cos" >&6
13266 if test $ac_cv_lib_m_cos = yes; then
13267
13268 cat >>confdefs.h <<\_ACEOF
13269 #define HAVE_COS 1
13270 _ACEOF
13271
13272 fi
13273
13274 echo "$as_me:$LINENO: checking for cosl in -lm" >&5
13275 echo $ECHO_N "checking for cosl in -lm... $ECHO_C" >&6
13276 if test "${ac_cv_lib_m_cosl+set}" = set; then
13277   echo $ECHO_N "(cached) $ECHO_C" >&6
13278 else
13279   ac_check_lib_save_LIBS=$LIBS
13280 LIBS="-lm  $LIBS"
13281 if test x$gcc_no_link = xyes; then
13282   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13283 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13284    { (exit 1); exit 1; }; }
13285 fi
13286 cat >conftest.$ac_ext <<_ACEOF
13287 /* confdefs.h.  */
13288 _ACEOF
13289 cat confdefs.h >>conftest.$ac_ext
13290 cat >>conftest.$ac_ext <<_ACEOF
13291 /* end confdefs.h.  */
13292
13293 /* Override any gcc2 internal prototype to avoid an error.  */
13294 #ifdef __cplusplus
13295 extern "C"
13296 #endif
13297 /* We use char because int might match the return type of a gcc2
13298    builtin and then its argument prototype would still apply.  */
13299 char cosl ();
13300 int
13301 main ()
13302 {
13303 cosl ();
13304   ;
13305   return 0;
13306 }
13307 _ACEOF
13308 rm -f conftest.$ac_objext conftest$ac_exeext
13309 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13310   (eval $ac_link) 2>conftest.er1
13311   ac_status=$?
13312   grep -v '^ *+' conftest.er1 >conftest.err
13313   rm -f conftest.er1
13314   cat conftest.err >&5
13315   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13316   (exit $ac_status); } &&
13317          { ac_try='test -z "$ac_c_werror_flag"
13318                          || test ! -s conftest.err'
13319   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13320   (eval $ac_try) 2>&5
13321   ac_status=$?
13322   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13323   (exit $ac_status); }; } &&
13324          { ac_try='test -s conftest$ac_exeext'
13325   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13326   (eval $ac_try) 2>&5
13327   ac_status=$?
13328   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13329   (exit $ac_status); }; }; then
13330   ac_cv_lib_m_cosl=yes
13331 else
13332   echo "$as_me: failed program was:" >&5
13333 sed 's/^/| /' conftest.$ac_ext >&5
13334
13335 ac_cv_lib_m_cosl=no
13336 fi
13337 rm -f conftest.err conftest.$ac_objext \
13338       conftest$ac_exeext conftest.$ac_ext
13339 LIBS=$ac_check_lib_save_LIBS
13340 fi
13341 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosl" >&5
13342 echo "${ECHO_T}$ac_cv_lib_m_cosl" >&6
13343 if test $ac_cv_lib_m_cosl = yes; then
13344
13345 cat >>confdefs.h <<\_ACEOF
13346 #define HAVE_COSL 1
13347 _ACEOF
13348
13349 fi
13350
13351 echo "$as_me:$LINENO: checking for ccosf in -lm" >&5
13352 echo $ECHO_N "checking for ccosf in -lm... $ECHO_C" >&6
13353 if test "${ac_cv_lib_m_ccosf+set}" = set; then
13354   echo $ECHO_N "(cached) $ECHO_C" >&6
13355 else
13356   ac_check_lib_save_LIBS=$LIBS
13357 LIBS="-lm  $LIBS"
13358 if test x$gcc_no_link = xyes; then
13359   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13360 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13361    { (exit 1); exit 1; }; }
13362 fi
13363 cat >conftest.$ac_ext <<_ACEOF
13364 /* confdefs.h.  */
13365 _ACEOF
13366 cat confdefs.h >>conftest.$ac_ext
13367 cat >>conftest.$ac_ext <<_ACEOF
13368 /* end confdefs.h.  */
13369
13370 /* Override any gcc2 internal prototype to avoid an error.  */
13371 #ifdef __cplusplus
13372 extern "C"
13373 #endif
13374 /* We use char because int might match the return type of a gcc2
13375    builtin and then its argument prototype would still apply.  */
13376 char ccosf ();
13377 int
13378 main ()
13379 {
13380 ccosf ();
13381   ;
13382   return 0;
13383 }
13384 _ACEOF
13385 rm -f conftest.$ac_objext conftest$ac_exeext
13386 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13387   (eval $ac_link) 2>conftest.er1
13388   ac_status=$?
13389   grep -v '^ *+' conftest.er1 >conftest.err
13390   rm -f conftest.er1
13391   cat conftest.err >&5
13392   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13393   (exit $ac_status); } &&
13394          { ac_try='test -z "$ac_c_werror_flag"
13395                          || test ! -s conftest.err'
13396   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13397   (eval $ac_try) 2>&5
13398   ac_status=$?
13399   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13400   (exit $ac_status); }; } &&
13401          { ac_try='test -s conftest$ac_exeext'
13402   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13403   (eval $ac_try) 2>&5
13404   ac_status=$?
13405   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13406   (exit $ac_status); }; }; then
13407   ac_cv_lib_m_ccosf=yes
13408 else
13409   echo "$as_me: failed program was:" >&5
13410 sed 's/^/| /' conftest.$ac_ext >&5
13411
13412 ac_cv_lib_m_ccosf=no
13413 fi
13414 rm -f conftest.err conftest.$ac_objext \
13415       conftest$ac_exeext conftest.$ac_ext
13416 LIBS=$ac_check_lib_save_LIBS
13417 fi
13418 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosf" >&5
13419 echo "${ECHO_T}$ac_cv_lib_m_ccosf" >&6
13420 if test $ac_cv_lib_m_ccosf = yes; then
13421
13422 cat >>confdefs.h <<\_ACEOF
13423 #define HAVE_CCOSF 1
13424 _ACEOF
13425
13426 fi
13427
13428 echo "$as_me:$LINENO: checking for ccos in -lm" >&5
13429 echo $ECHO_N "checking for ccos in -lm... $ECHO_C" >&6
13430 if test "${ac_cv_lib_m_ccos+set}" = set; then
13431   echo $ECHO_N "(cached) $ECHO_C" >&6
13432 else
13433   ac_check_lib_save_LIBS=$LIBS
13434 LIBS="-lm  $LIBS"
13435 if test x$gcc_no_link = xyes; then
13436   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13437 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13438    { (exit 1); exit 1; }; }
13439 fi
13440 cat >conftest.$ac_ext <<_ACEOF
13441 /* confdefs.h.  */
13442 _ACEOF
13443 cat confdefs.h >>conftest.$ac_ext
13444 cat >>conftest.$ac_ext <<_ACEOF
13445 /* end confdefs.h.  */
13446
13447 /* Override any gcc2 internal prototype to avoid an error.  */
13448 #ifdef __cplusplus
13449 extern "C"
13450 #endif
13451 /* We use char because int might match the return type of a gcc2
13452    builtin and then its argument prototype would still apply.  */
13453 char ccos ();
13454 int
13455 main ()
13456 {
13457 ccos ();
13458   ;
13459   return 0;
13460 }
13461 _ACEOF
13462 rm -f conftest.$ac_objext conftest$ac_exeext
13463 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13464   (eval $ac_link) 2>conftest.er1
13465   ac_status=$?
13466   grep -v '^ *+' conftest.er1 >conftest.err
13467   rm -f conftest.er1
13468   cat conftest.err >&5
13469   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13470   (exit $ac_status); } &&
13471          { ac_try='test -z "$ac_c_werror_flag"
13472                          || test ! -s conftest.err'
13473   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13474   (eval $ac_try) 2>&5
13475   ac_status=$?
13476   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13477   (exit $ac_status); }; } &&
13478          { ac_try='test -s conftest$ac_exeext'
13479   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13480   (eval $ac_try) 2>&5
13481   ac_status=$?
13482   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13483   (exit $ac_status); }; }; then
13484   ac_cv_lib_m_ccos=yes
13485 else
13486   echo "$as_me: failed program was:" >&5
13487 sed 's/^/| /' conftest.$ac_ext >&5
13488
13489 ac_cv_lib_m_ccos=no
13490 fi
13491 rm -f conftest.err conftest.$ac_objext \
13492       conftest$ac_exeext conftest.$ac_ext
13493 LIBS=$ac_check_lib_save_LIBS
13494 fi
13495 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccos" >&5
13496 echo "${ECHO_T}$ac_cv_lib_m_ccos" >&6
13497 if test $ac_cv_lib_m_ccos = yes; then
13498
13499 cat >>confdefs.h <<\_ACEOF
13500 #define HAVE_CCOS 1
13501 _ACEOF
13502
13503 fi
13504
13505 echo "$as_me:$LINENO: checking for ccosl in -lm" >&5
13506 echo $ECHO_N "checking for ccosl in -lm... $ECHO_C" >&6
13507 if test "${ac_cv_lib_m_ccosl+set}" = set; then
13508   echo $ECHO_N "(cached) $ECHO_C" >&6
13509 else
13510   ac_check_lib_save_LIBS=$LIBS
13511 LIBS="-lm  $LIBS"
13512 if test x$gcc_no_link = xyes; then
13513   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13514 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13515    { (exit 1); exit 1; }; }
13516 fi
13517 cat >conftest.$ac_ext <<_ACEOF
13518 /* confdefs.h.  */
13519 _ACEOF
13520 cat confdefs.h >>conftest.$ac_ext
13521 cat >>conftest.$ac_ext <<_ACEOF
13522 /* end confdefs.h.  */
13523
13524 /* Override any gcc2 internal prototype to avoid an error.  */
13525 #ifdef __cplusplus
13526 extern "C"
13527 #endif
13528 /* We use char because int might match the return type of a gcc2
13529    builtin and then its argument prototype would still apply.  */
13530 char ccosl ();
13531 int
13532 main ()
13533 {
13534 ccosl ();
13535   ;
13536   return 0;
13537 }
13538 _ACEOF
13539 rm -f conftest.$ac_objext conftest$ac_exeext
13540 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13541   (eval $ac_link) 2>conftest.er1
13542   ac_status=$?
13543   grep -v '^ *+' conftest.er1 >conftest.err
13544   rm -f conftest.er1
13545   cat conftest.err >&5
13546   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13547   (exit $ac_status); } &&
13548          { ac_try='test -z "$ac_c_werror_flag"
13549                          || test ! -s conftest.err'
13550   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13551   (eval $ac_try) 2>&5
13552   ac_status=$?
13553   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13554   (exit $ac_status); }; } &&
13555          { ac_try='test -s conftest$ac_exeext'
13556   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13557   (eval $ac_try) 2>&5
13558   ac_status=$?
13559   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13560   (exit $ac_status); }; }; then
13561   ac_cv_lib_m_ccosl=yes
13562 else
13563   echo "$as_me: failed program was:" >&5
13564 sed 's/^/| /' conftest.$ac_ext >&5
13565
13566 ac_cv_lib_m_ccosl=no
13567 fi
13568 rm -f conftest.err conftest.$ac_objext \
13569       conftest$ac_exeext conftest.$ac_ext
13570 LIBS=$ac_check_lib_save_LIBS
13571 fi
13572 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosl" >&5
13573 echo "${ECHO_T}$ac_cv_lib_m_ccosl" >&6
13574 if test $ac_cv_lib_m_ccosl = yes; then
13575
13576 cat >>confdefs.h <<\_ACEOF
13577 #define HAVE_CCOSL 1
13578 _ACEOF
13579
13580 fi
13581
13582 echo "$as_me:$LINENO: checking for coshf in -lm" >&5
13583 echo $ECHO_N "checking for coshf in -lm... $ECHO_C" >&6
13584 if test "${ac_cv_lib_m_coshf+set}" = set; then
13585   echo $ECHO_N "(cached) $ECHO_C" >&6
13586 else
13587   ac_check_lib_save_LIBS=$LIBS
13588 LIBS="-lm  $LIBS"
13589 if test x$gcc_no_link = xyes; then
13590   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13591 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13592    { (exit 1); exit 1; }; }
13593 fi
13594 cat >conftest.$ac_ext <<_ACEOF
13595 /* confdefs.h.  */
13596 _ACEOF
13597 cat confdefs.h >>conftest.$ac_ext
13598 cat >>conftest.$ac_ext <<_ACEOF
13599 /* end confdefs.h.  */
13600
13601 /* Override any gcc2 internal prototype to avoid an error.  */
13602 #ifdef __cplusplus
13603 extern "C"
13604 #endif
13605 /* We use char because int might match the return type of a gcc2
13606    builtin and then its argument prototype would still apply.  */
13607 char coshf ();
13608 int
13609 main ()
13610 {
13611 coshf ();
13612   ;
13613   return 0;
13614 }
13615 _ACEOF
13616 rm -f conftest.$ac_objext conftest$ac_exeext
13617 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13618   (eval $ac_link) 2>conftest.er1
13619   ac_status=$?
13620   grep -v '^ *+' conftest.er1 >conftest.err
13621   rm -f conftest.er1
13622   cat conftest.err >&5
13623   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13624   (exit $ac_status); } &&
13625          { ac_try='test -z "$ac_c_werror_flag"
13626                          || test ! -s conftest.err'
13627   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13628   (eval $ac_try) 2>&5
13629   ac_status=$?
13630   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13631   (exit $ac_status); }; } &&
13632          { ac_try='test -s conftest$ac_exeext'
13633   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13634   (eval $ac_try) 2>&5
13635   ac_status=$?
13636   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13637   (exit $ac_status); }; }; then
13638   ac_cv_lib_m_coshf=yes
13639 else
13640   echo "$as_me: failed program was:" >&5
13641 sed 's/^/| /' conftest.$ac_ext >&5
13642
13643 ac_cv_lib_m_coshf=no
13644 fi
13645 rm -f conftest.err conftest.$ac_objext \
13646       conftest$ac_exeext conftest.$ac_ext
13647 LIBS=$ac_check_lib_save_LIBS
13648 fi
13649 echo "$as_me:$LINENO: result: $ac_cv_lib_m_coshf" >&5
13650 echo "${ECHO_T}$ac_cv_lib_m_coshf" >&6
13651 if test $ac_cv_lib_m_coshf = yes; then
13652
13653 cat >>confdefs.h <<\_ACEOF
13654 #define HAVE_COSHF 1
13655 _ACEOF
13656
13657 fi
13658
13659 echo "$as_me:$LINENO: checking for cosh in -lm" >&5
13660 echo $ECHO_N "checking for cosh in -lm... $ECHO_C" >&6
13661 if test "${ac_cv_lib_m_cosh+set}" = set; then
13662   echo $ECHO_N "(cached) $ECHO_C" >&6
13663 else
13664   ac_check_lib_save_LIBS=$LIBS
13665 LIBS="-lm  $LIBS"
13666 if test x$gcc_no_link = xyes; then
13667   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13668 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13669    { (exit 1); exit 1; }; }
13670 fi
13671 cat >conftest.$ac_ext <<_ACEOF
13672 /* confdefs.h.  */
13673 _ACEOF
13674 cat confdefs.h >>conftest.$ac_ext
13675 cat >>conftest.$ac_ext <<_ACEOF
13676 /* end confdefs.h.  */
13677
13678 /* Override any gcc2 internal prototype to avoid an error.  */
13679 #ifdef __cplusplus
13680 extern "C"
13681 #endif
13682 /* We use char because int might match the return type of a gcc2
13683    builtin and then its argument prototype would still apply.  */
13684 char cosh ();
13685 int
13686 main ()
13687 {
13688 cosh ();
13689   ;
13690   return 0;
13691 }
13692 _ACEOF
13693 rm -f conftest.$ac_objext conftest$ac_exeext
13694 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13695   (eval $ac_link) 2>conftest.er1
13696   ac_status=$?
13697   grep -v '^ *+' conftest.er1 >conftest.err
13698   rm -f conftest.er1
13699   cat conftest.err >&5
13700   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13701   (exit $ac_status); } &&
13702          { ac_try='test -z "$ac_c_werror_flag"
13703                          || test ! -s conftest.err'
13704   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13705   (eval $ac_try) 2>&5
13706   ac_status=$?
13707   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13708   (exit $ac_status); }; } &&
13709          { ac_try='test -s conftest$ac_exeext'
13710   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13711   (eval $ac_try) 2>&5
13712   ac_status=$?
13713   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13714   (exit $ac_status); }; }; then
13715   ac_cv_lib_m_cosh=yes
13716 else
13717   echo "$as_me: failed program was:" >&5
13718 sed 's/^/| /' conftest.$ac_ext >&5
13719
13720 ac_cv_lib_m_cosh=no
13721 fi
13722 rm -f conftest.err conftest.$ac_objext \
13723       conftest$ac_exeext conftest.$ac_ext
13724 LIBS=$ac_check_lib_save_LIBS
13725 fi
13726 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosh" >&5
13727 echo "${ECHO_T}$ac_cv_lib_m_cosh" >&6
13728 if test $ac_cv_lib_m_cosh = yes; then
13729
13730 cat >>confdefs.h <<\_ACEOF
13731 #define HAVE_COSH 1
13732 _ACEOF
13733
13734 fi
13735
13736 echo "$as_me:$LINENO: checking for coshl in -lm" >&5
13737 echo $ECHO_N "checking for coshl in -lm... $ECHO_C" >&6
13738 if test "${ac_cv_lib_m_coshl+set}" = set; then
13739   echo $ECHO_N "(cached) $ECHO_C" >&6
13740 else
13741   ac_check_lib_save_LIBS=$LIBS
13742 LIBS="-lm  $LIBS"
13743 if test x$gcc_no_link = xyes; then
13744   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13745 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13746    { (exit 1); exit 1; }; }
13747 fi
13748 cat >conftest.$ac_ext <<_ACEOF
13749 /* confdefs.h.  */
13750 _ACEOF
13751 cat confdefs.h >>conftest.$ac_ext
13752 cat >>conftest.$ac_ext <<_ACEOF
13753 /* end confdefs.h.  */
13754
13755 /* Override any gcc2 internal prototype to avoid an error.  */
13756 #ifdef __cplusplus
13757 extern "C"
13758 #endif
13759 /* We use char because int might match the return type of a gcc2
13760    builtin and then its argument prototype would still apply.  */
13761 char coshl ();
13762 int
13763 main ()
13764 {
13765 coshl ();
13766   ;
13767   return 0;
13768 }
13769 _ACEOF
13770 rm -f conftest.$ac_objext conftest$ac_exeext
13771 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13772   (eval $ac_link) 2>conftest.er1
13773   ac_status=$?
13774   grep -v '^ *+' conftest.er1 >conftest.err
13775   rm -f conftest.er1
13776   cat conftest.err >&5
13777   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13778   (exit $ac_status); } &&
13779          { ac_try='test -z "$ac_c_werror_flag"
13780                          || test ! -s conftest.err'
13781   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13782   (eval $ac_try) 2>&5
13783   ac_status=$?
13784   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13785   (exit $ac_status); }; } &&
13786          { ac_try='test -s conftest$ac_exeext'
13787   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13788   (eval $ac_try) 2>&5
13789   ac_status=$?
13790   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13791   (exit $ac_status); }; }; then
13792   ac_cv_lib_m_coshl=yes
13793 else
13794   echo "$as_me: failed program was:" >&5
13795 sed 's/^/| /' conftest.$ac_ext >&5
13796
13797 ac_cv_lib_m_coshl=no
13798 fi
13799 rm -f conftest.err conftest.$ac_objext \
13800       conftest$ac_exeext conftest.$ac_ext
13801 LIBS=$ac_check_lib_save_LIBS
13802 fi
13803 echo "$as_me:$LINENO: result: $ac_cv_lib_m_coshl" >&5
13804 echo "${ECHO_T}$ac_cv_lib_m_coshl" >&6
13805 if test $ac_cv_lib_m_coshl = yes; then
13806
13807 cat >>confdefs.h <<\_ACEOF
13808 #define HAVE_COSHL 1
13809 _ACEOF
13810
13811 fi
13812
13813 echo "$as_me:$LINENO: checking for ccoshf in -lm" >&5
13814 echo $ECHO_N "checking for ccoshf in -lm... $ECHO_C" >&6
13815 if test "${ac_cv_lib_m_ccoshf+set}" = set; then
13816   echo $ECHO_N "(cached) $ECHO_C" >&6
13817 else
13818   ac_check_lib_save_LIBS=$LIBS
13819 LIBS="-lm  $LIBS"
13820 if test x$gcc_no_link = xyes; then
13821   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13822 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13823    { (exit 1); exit 1; }; }
13824 fi
13825 cat >conftest.$ac_ext <<_ACEOF
13826 /* confdefs.h.  */
13827 _ACEOF
13828 cat confdefs.h >>conftest.$ac_ext
13829 cat >>conftest.$ac_ext <<_ACEOF
13830 /* end confdefs.h.  */
13831
13832 /* Override any gcc2 internal prototype to avoid an error.  */
13833 #ifdef __cplusplus
13834 extern "C"
13835 #endif
13836 /* We use char because int might match the return type of a gcc2
13837    builtin and then its argument prototype would still apply.  */
13838 char ccoshf ();
13839 int
13840 main ()
13841 {
13842 ccoshf ();
13843   ;
13844   return 0;
13845 }
13846 _ACEOF
13847 rm -f conftest.$ac_objext conftest$ac_exeext
13848 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13849   (eval $ac_link) 2>conftest.er1
13850   ac_status=$?
13851   grep -v '^ *+' conftest.er1 >conftest.err
13852   rm -f conftest.er1
13853   cat conftest.err >&5
13854   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13855   (exit $ac_status); } &&
13856          { ac_try='test -z "$ac_c_werror_flag"
13857                          || test ! -s conftest.err'
13858   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13859   (eval $ac_try) 2>&5
13860   ac_status=$?
13861   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13862   (exit $ac_status); }; } &&
13863          { ac_try='test -s conftest$ac_exeext'
13864   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13865   (eval $ac_try) 2>&5
13866   ac_status=$?
13867   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13868   (exit $ac_status); }; }; then
13869   ac_cv_lib_m_ccoshf=yes
13870 else
13871   echo "$as_me: failed program was:" >&5
13872 sed 's/^/| /' conftest.$ac_ext >&5
13873
13874 ac_cv_lib_m_ccoshf=no
13875 fi
13876 rm -f conftest.err conftest.$ac_objext \
13877       conftest$ac_exeext conftest.$ac_ext
13878 LIBS=$ac_check_lib_save_LIBS
13879 fi
13880 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccoshf" >&5
13881 echo "${ECHO_T}$ac_cv_lib_m_ccoshf" >&6
13882 if test $ac_cv_lib_m_ccoshf = yes; then
13883
13884 cat >>confdefs.h <<\_ACEOF
13885 #define HAVE_CCOSHF 1
13886 _ACEOF
13887
13888 fi
13889
13890 echo "$as_me:$LINENO: checking for ccosh in -lm" >&5
13891 echo $ECHO_N "checking for ccosh in -lm... $ECHO_C" >&6
13892 if test "${ac_cv_lib_m_ccosh+set}" = set; then
13893   echo $ECHO_N "(cached) $ECHO_C" >&6
13894 else
13895   ac_check_lib_save_LIBS=$LIBS
13896 LIBS="-lm  $LIBS"
13897 if test x$gcc_no_link = xyes; then
13898   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13899 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13900    { (exit 1); exit 1; }; }
13901 fi
13902 cat >conftest.$ac_ext <<_ACEOF
13903 /* confdefs.h.  */
13904 _ACEOF
13905 cat confdefs.h >>conftest.$ac_ext
13906 cat >>conftest.$ac_ext <<_ACEOF
13907 /* end confdefs.h.  */
13908
13909 /* Override any gcc2 internal prototype to avoid an error.  */
13910 #ifdef __cplusplus
13911 extern "C"
13912 #endif
13913 /* We use char because int might match the return type of a gcc2
13914    builtin and then its argument prototype would still apply.  */
13915 char ccosh ();
13916 int
13917 main ()
13918 {
13919 ccosh ();
13920   ;
13921   return 0;
13922 }
13923 _ACEOF
13924 rm -f conftest.$ac_objext conftest$ac_exeext
13925 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13926   (eval $ac_link) 2>conftest.er1
13927   ac_status=$?
13928   grep -v '^ *+' conftest.er1 >conftest.err
13929   rm -f conftest.er1
13930   cat conftest.err >&5
13931   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13932   (exit $ac_status); } &&
13933          { ac_try='test -z "$ac_c_werror_flag"
13934                          || test ! -s conftest.err'
13935   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13936   (eval $ac_try) 2>&5
13937   ac_status=$?
13938   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13939   (exit $ac_status); }; } &&
13940          { ac_try='test -s conftest$ac_exeext'
13941   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13942   (eval $ac_try) 2>&5
13943   ac_status=$?
13944   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13945   (exit $ac_status); }; }; then
13946   ac_cv_lib_m_ccosh=yes
13947 else
13948   echo "$as_me: failed program was:" >&5
13949 sed 's/^/| /' conftest.$ac_ext >&5
13950
13951 ac_cv_lib_m_ccosh=no
13952 fi
13953 rm -f conftest.err conftest.$ac_objext \
13954       conftest$ac_exeext conftest.$ac_ext
13955 LIBS=$ac_check_lib_save_LIBS
13956 fi
13957 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosh" >&5
13958 echo "${ECHO_T}$ac_cv_lib_m_ccosh" >&6
13959 if test $ac_cv_lib_m_ccosh = yes; then
13960
13961 cat >>confdefs.h <<\_ACEOF
13962 #define HAVE_CCOSH 1
13963 _ACEOF
13964
13965 fi
13966
13967 echo "$as_me:$LINENO: checking for ccoshl in -lm" >&5
13968 echo $ECHO_N "checking for ccoshl in -lm... $ECHO_C" >&6
13969 if test "${ac_cv_lib_m_ccoshl+set}" = set; then
13970   echo $ECHO_N "(cached) $ECHO_C" >&6
13971 else
13972   ac_check_lib_save_LIBS=$LIBS
13973 LIBS="-lm  $LIBS"
13974 if test x$gcc_no_link = xyes; then
13975   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13976 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13977    { (exit 1); exit 1; }; }
13978 fi
13979 cat >conftest.$ac_ext <<_ACEOF
13980 /* confdefs.h.  */
13981 _ACEOF
13982 cat confdefs.h >>conftest.$ac_ext
13983 cat >>conftest.$ac_ext <<_ACEOF
13984 /* end confdefs.h.  */
13985
13986 /* Override any gcc2 internal prototype to avoid an error.  */
13987 #ifdef __cplusplus
13988 extern "C"
13989 #endif
13990 /* We use char because int might match the return type of a gcc2
13991    builtin and then its argument prototype would still apply.  */
13992 char ccoshl ();
13993 int
13994 main ()
13995 {
13996 ccoshl ();
13997   ;
13998   return 0;
13999 }
14000 _ACEOF
14001 rm -f conftest.$ac_objext conftest$ac_exeext
14002 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14003   (eval $ac_link) 2>conftest.er1
14004   ac_status=$?
14005   grep -v '^ *+' conftest.er1 >conftest.err
14006   rm -f conftest.er1
14007   cat conftest.err >&5
14008   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14009   (exit $ac_status); } &&
14010          { ac_try='test -z "$ac_c_werror_flag"
14011                          || test ! -s conftest.err'
14012   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14013   (eval $ac_try) 2>&5
14014   ac_status=$?
14015   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14016   (exit $ac_status); }; } &&
14017          { ac_try='test -s conftest$ac_exeext'
14018   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14019   (eval $ac_try) 2>&5
14020   ac_status=$?
14021   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14022   (exit $ac_status); }; }; then
14023   ac_cv_lib_m_ccoshl=yes
14024 else
14025   echo "$as_me: failed program was:" >&5
14026 sed 's/^/| /' conftest.$ac_ext >&5
14027
14028 ac_cv_lib_m_ccoshl=no
14029 fi
14030 rm -f conftest.err conftest.$ac_objext \
14031       conftest$ac_exeext conftest.$ac_ext
14032 LIBS=$ac_check_lib_save_LIBS
14033 fi
14034 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccoshl" >&5
14035 echo "${ECHO_T}$ac_cv_lib_m_ccoshl" >&6
14036 if test $ac_cv_lib_m_ccoshl = yes; then
14037
14038 cat >>confdefs.h <<\_ACEOF
14039 #define HAVE_CCOSHL 1
14040 _ACEOF
14041
14042 fi
14043
14044 echo "$as_me:$LINENO: checking for expf in -lm" >&5
14045 echo $ECHO_N "checking for expf in -lm... $ECHO_C" >&6
14046 if test "${ac_cv_lib_m_expf+set}" = set; then
14047   echo $ECHO_N "(cached) $ECHO_C" >&6
14048 else
14049   ac_check_lib_save_LIBS=$LIBS
14050 LIBS="-lm  $LIBS"
14051 if test x$gcc_no_link = xyes; then
14052   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14053 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14054    { (exit 1); exit 1; }; }
14055 fi
14056 cat >conftest.$ac_ext <<_ACEOF
14057 /* confdefs.h.  */
14058 _ACEOF
14059 cat confdefs.h >>conftest.$ac_ext
14060 cat >>conftest.$ac_ext <<_ACEOF
14061 /* end confdefs.h.  */
14062
14063 /* Override any gcc2 internal prototype to avoid an error.  */
14064 #ifdef __cplusplus
14065 extern "C"
14066 #endif
14067 /* We use char because int might match the return type of a gcc2
14068    builtin and then its argument prototype would still apply.  */
14069 char expf ();
14070 int
14071 main ()
14072 {
14073 expf ();
14074   ;
14075   return 0;
14076 }
14077 _ACEOF
14078 rm -f conftest.$ac_objext conftest$ac_exeext
14079 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14080   (eval $ac_link) 2>conftest.er1
14081   ac_status=$?
14082   grep -v '^ *+' conftest.er1 >conftest.err
14083   rm -f conftest.er1
14084   cat conftest.err >&5
14085   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14086   (exit $ac_status); } &&
14087          { ac_try='test -z "$ac_c_werror_flag"
14088                          || test ! -s conftest.err'
14089   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14090   (eval $ac_try) 2>&5
14091   ac_status=$?
14092   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14093   (exit $ac_status); }; } &&
14094          { ac_try='test -s conftest$ac_exeext'
14095   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14096   (eval $ac_try) 2>&5
14097   ac_status=$?
14098   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14099   (exit $ac_status); }; }; then
14100   ac_cv_lib_m_expf=yes
14101 else
14102   echo "$as_me: failed program was:" >&5
14103 sed 's/^/| /' conftest.$ac_ext >&5
14104
14105 ac_cv_lib_m_expf=no
14106 fi
14107 rm -f conftest.err conftest.$ac_objext \
14108       conftest$ac_exeext conftest.$ac_ext
14109 LIBS=$ac_check_lib_save_LIBS
14110 fi
14111 echo "$as_me:$LINENO: result: $ac_cv_lib_m_expf" >&5
14112 echo "${ECHO_T}$ac_cv_lib_m_expf" >&6
14113 if test $ac_cv_lib_m_expf = yes; then
14114
14115 cat >>confdefs.h <<\_ACEOF
14116 #define HAVE_EXPF 1
14117 _ACEOF
14118
14119 fi
14120
14121 echo "$as_me:$LINENO: checking for exp in -lm" >&5
14122 echo $ECHO_N "checking for exp in -lm... $ECHO_C" >&6
14123 if test "${ac_cv_lib_m_exp+set}" = set; then
14124   echo $ECHO_N "(cached) $ECHO_C" >&6
14125 else
14126   ac_check_lib_save_LIBS=$LIBS
14127 LIBS="-lm  $LIBS"
14128 if test x$gcc_no_link = xyes; then
14129   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14130 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14131    { (exit 1); exit 1; }; }
14132 fi
14133 cat >conftest.$ac_ext <<_ACEOF
14134 /* confdefs.h.  */
14135 _ACEOF
14136 cat confdefs.h >>conftest.$ac_ext
14137 cat >>conftest.$ac_ext <<_ACEOF
14138 /* end confdefs.h.  */
14139
14140 /* Override any gcc2 internal prototype to avoid an error.  */
14141 #ifdef __cplusplus
14142 extern "C"
14143 #endif
14144 /* We use char because int might match the return type of a gcc2
14145    builtin and then its argument prototype would still apply.  */
14146 char exp ();
14147 int
14148 main ()
14149 {
14150 exp ();
14151   ;
14152   return 0;
14153 }
14154 _ACEOF
14155 rm -f conftest.$ac_objext conftest$ac_exeext
14156 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14157   (eval $ac_link) 2>conftest.er1
14158   ac_status=$?
14159   grep -v '^ *+' conftest.er1 >conftest.err
14160   rm -f conftest.er1
14161   cat conftest.err >&5
14162   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14163   (exit $ac_status); } &&
14164          { ac_try='test -z "$ac_c_werror_flag"
14165                          || test ! -s conftest.err'
14166   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14167   (eval $ac_try) 2>&5
14168   ac_status=$?
14169   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14170   (exit $ac_status); }; } &&
14171          { ac_try='test -s conftest$ac_exeext'
14172   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14173   (eval $ac_try) 2>&5
14174   ac_status=$?
14175   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14176   (exit $ac_status); }; }; then
14177   ac_cv_lib_m_exp=yes
14178 else
14179   echo "$as_me: failed program was:" >&5
14180 sed 's/^/| /' conftest.$ac_ext >&5
14181
14182 ac_cv_lib_m_exp=no
14183 fi
14184 rm -f conftest.err conftest.$ac_objext \
14185       conftest$ac_exeext conftest.$ac_ext
14186 LIBS=$ac_check_lib_save_LIBS
14187 fi
14188 echo "$as_me:$LINENO: result: $ac_cv_lib_m_exp" >&5
14189 echo "${ECHO_T}$ac_cv_lib_m_exp" >&6
14190 if test $ac_cv_lib_m_exp = yes; then
14191
14192 cat >>confdefs.h <<\_ACEOF
14193 #define HAVE_EXP 1
14194 _ACEOF
14195
14196 fi
14197
14198 echo "$as_me:$LINENO: checking for expl in -lm" >&5
14199 echo $ECHO_N "checking for expl in -lm... $ECHO_C" >&6
14200 if test "${ac_cv_lib_m_expl+set}" = set; then
14201   echo $ECHO_N "(cached) $ECHO_C" >&6
14202 else
14203   ac_check_lib_save_LIBS=$LIBS
14204 LIBS="-lm  $LIBS"
14205 if test x$gcc_no_link = xyes; then
14206   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14207 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14208    { (exit 1); exit 1; }; }
14209 fi
14210 cat >conftest.$ac_ext <<_ACEOF
14211 /* confdefs.h.  */
14212 _ACEOF
14213 cat confdefs.h >>conftest.$ac_ext
14214 cat >>conftest.$ac_ext <<_ACEOF
14215 /* end confdefs.h.  */
14216
14217 /* Override any gcc2 internal prototype to avoid an error.  */
14218 #ifdef __cplusplus
14219 extern "C"
14220 #endif
14221 /* We use char because int might match the return type of a gcc2
14222    builtin and then its argument prototype would still apply.  */
14223 char expl ();
14224 int
14225 main ()
14226 {
14227 expl ();
14228   ;
14229   return 0;
14230 }
14231 _ACEOF
14232 rm -f conftest.$ac_objext conftest$ac_exeext
14233 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14234   (eval $ac_link) 2>conftest.er1
14235   ac_status=$?
14236   grep -v '^ *+' conftest.er1 >conftest.err
14237   rm -f conftest.er1
14238   cat conftest.err >&5
14239   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14240   (exit $ac_status); } &&
14241          { ac_try='test -z "$ac_c_werror_flag"
14242                          || test ! -s conftest.err'
14243   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14244   (eval $ac_try) 2>&5
14245   ac_status=$?
14246   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14247   (exit $ac_status); }; } &&
14248          { ac_try='test -s conftest$ac_exeext'
14249   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14250   (eval $ac_try) 2>&5
14251   ac_status=$?
14252   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14253   (exit $ac_status); }; }; then
14254   ac_cv_lib_m_expl=yes
14255 else
14256   echo "$as_me: failed program was:" >&5
14257 sed 's/^/| /' conftest.$ac_ext >&5
14258
14259 ac_cv_lib_m_expl=no
14260 fi
14261 rm -f conftest.err conftest.$ac_objext \
14262       conftest$ac_exeext conftest.$ac_ext
14263 LIBS=$ac_check_lib_save_LIBS
14264 fi
14265 echo "$as_me:$LINENO: result: $ac_cv_lib_m_expl" >&5
14266 echo "${ECHO_T}$ac_cv_lib_m_expl" >&6
14267 if test $ac_cv_lib_m_expl = yes; then
14268
14269 cat >>confdefs.h <<\_ACEOF
14270 #define HAVE_EXPL 1
14271 _ACEOF
14272
14273 fi
14274
14275 echo "$as_me:$LINENO: checking for cexpf in -lm" >&5
14276 echo $ECHO_N "checking for cexpf in -lm... $ECHO_C" >&6
14277 if test "${ac_cv_lib_m_cexpf+set}" = set; then
14278   echo $ECHO_N "(cached) $ECHO_C" >&6
14279 else
14280   ac_check_lib_save_LIBS=$LIBS
14281 LIBS="-lm  $LIBS"
14282 if test x$gcc_no_link = xyes; then
14283   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14284 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14285    { (exit 1); exit 1; }; }
14286 fi
14287 cat >conftest.$ac_ext <<_ACEOF
14288 /* confdefs.h.  */
14289 _ACEOF
14290 cat confdefs.h >>conftest.$ac_ext
14291 cat >>conftest.$ac_ext <<_ACEOF
14292 /* end confdefs.h.  */
14293
14294 /* Override any gcc2 internal prototype to avoid an error.  */
14295 #ifdef __cplusplus
14296 extern "C"
14297 #endif
14298 /* We use char because int might match the return type of a gcc2
14299    builtin and then its argument prototype would still apply.  */
14300 char cexpf ();
14301 int
14302 main ()
14303 {
14304 cexpf ();
14305   ;
14306   return 0;
14307 }
14308 _ACEOF
14309 rm -f conftest.$ac_objext conftest$ac_exeext
14310 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14311   (eval $ac_link) 2>conftest.er1
14312   ac_status=$?
14313   grep -v '^ *+' conftest.er1 >conftest.err
14314   rm -f conftest.er1
14315   cat conftest.err >&5
14316   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14317   (exit $ac_status); } &&
14318          { ac_try='test -z "$ac_c_werror_flag"
14319                          || test ! -s conftest.err'
14320   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14321   (eval $ac_try) 2>&5
14322   ac_status=$?
14323   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14324   (exit $ac_status); }; } &&
14325          { ac_try='test -s conftest$ac_exeext'
14326   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14327   (eval $ac_try) 2>&5
14328   ac_status=$?
14329   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14330   (exit $ac_status); }; }; then
14331   ac_cv_lib_m_cexpf=yes
14332 else
14333   echo "$as_me: failed program was:" >&5
14334 sed 's/^/| /' conftest.$ac_ext >&5
14335
14336 ac_cv_lib_m_cexpf=no
14337 fi
14338 rm -f conftest.err conftest.$ac_objext \
14339       conftest$ac_exeext conftest.$ac_ext
14340 LIBS=$ac_check_lib_save_LIBS
14341 fi
14342 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexpf" >&5
14343 echo "${ECHO_T}$ac_cv_lib_m_cexpf" >&6
14344 if test $ac_cv_lib_m_cexpf = yes; then
14345
14346 cat >>confdefs.h <<\_ACEOF
14347 #define HAVE_CEXPF 1
14348 _ACEOF
14349
14350 fi
14351
14352 echo "$as_me:$LINENO: checking for cexp in -lm" >&5
14353 echo $ECHO_N "checking for cexp in -lm... $ECHO_C" >&6
14354 if test "${ac_cv_lib_m_cexp+set}" = set; then
14355   echo $ECHO_N "(cached) $ECHO_C" >&6
14356 else
14357   ac_check_lib_save_LIBS=$LIBS
14358 LIBS="-lm  $LIBS"
14359 if test x$gcc_no_link = xyes; then
14360   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14361 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14362    { (exit 1); exit 1; }; }
14363 fi
14364 cat >conftest.$ac_ext <<_ACEOF
14365 /* confdefs.h.  */
14366 _ACEOF
14367 cat confdefs.h >>conftest.$ac_ext
14368 cat >>conftest.$ac_ext <<_ACEOF
14369 /* end confdefs.h.  */
14370
14371 /* Override any gcc2 internal prototype to avoid an error.  */
14372 #ifdef __cplusplus
14373 extern "C"
14374 #endif
14375 /* We use char because int might match the return type of a gcc2
14376    builtin and then its argument prototype would still apply.  */
14377 char cexp ();
14378 int
14379 main ()
14380 {
14381 cexp ();
14382   ;
14383   return 0;
14384 }
14385 _ACEOF
14386 rm -f conftest.$ac_objext conftest$ac_exeext
14387 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14388   (eval $ac_link) 2>conftest.er1
14389   ac_status=$?
14390   grep -v '^ *+' conftest.er1 >conftest.err
14391   rm -f conftest.er1
14392   cat conftest.err >&5
14393   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14394   (exit $ac_status); } &&
14395          { ac_try='test -z "$ac_c_werror_flag"
14396                          || test ! -s conftest.err'
14397   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14398   (eval $ac_try) 2>&5
14399   ac_status=$?
14400   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14401   (exit $ac_status); }; } &&
14402          { ac_try='test -s conftest$ac_exeext'
14403   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14404   (eval $ac_try) 2>&5
14405   ac_status=$?
14406   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14407   (exit $ac_status); }; }; then
14408   ac_cv_lib_m_cexp=yes
14409 else
14410   echo "$as_me: failed program was:" >&5
14411 sed 's/^/| /' conftest.$ac_ext >&5
14412
14413 ac_cv_lib_m_cexp=no
14414 fi
14415 rm -f conftest.err conftest.$ac_objext \
14416       conftest$ac_exeext conftest.$ac_ext
14417 LIBS=$ac_check_lib_save_LIBS
14418 fi
14419 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexp" >&5
14420 echo "${ECHO_T}$ac_cv_lib_m_cexp" >&6
14421 if test $ac_cv_lib_m_cexp = yes; then
14422
14423 cat >>confdefs.h <<\_ACEOF
14424 #define HAVE_CEXP 1
14425 _ACEOF
14426
14427 fi
14428
14429 echo "$as_me:$LINENO: checking for cexpl in -lm" >&5
14430 echo $ECHO_N "checking for cexpl in -lm... $ECHO_C" >&6
14431 if test "${ac_cv_lib_m_cexpl+set}" = set; then
14432   echo $ECHO_N "(cached) $ECHO_C" >&6
14433 else
14434   ac_check_lib_save_LIBS=$LIBS
14435 LIBS="-lm  $LIBS"
14436 if test x$gcc_no_link = xyes; then
14437   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14438 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14439    { (exit 1); exit 1; }; }
14440 fi
14441 cat >conftest.$ac_ext <<_ACEOF
14442 /* confdefs.h.  */
14443 _ACEOF
14444 cat confdefs.h >>conftest.$ac_ext
14445 cat >>conftest.$ac_ext <<_ACEOF
14446 /* end confdefs.h.  */
14447
14448 /* Override any gcc2 internal prototype to avoid an error.  */
14449 #ifdef __cplusplus
14450 extern "C"
14451 #endif
14452 /* We use char because int might match the return type of a gcc2
14453    builtin and then its argument prototype would still apply.  */
14454 char cexpl ();
14455 int
14456 main ()
14457 {
14458 cexpl ();
14459   ;
14460   return 0;
14461 }
14462 _ACEOF
14463 rm -f conftest.$ac_objext conftest$ac_exeext
14464 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14465   (eval $ac_link) 2>conftest.er1
14466   ac_status=$?
14467   grep -v '^ *+' conftest.er1 >conftest.err
14468   rm -f conftest.er1
14469   cat conftest.err >&5
14470   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14471   (exit $ac_status); } &&
14472          { ac_try='test -z "$ac_c_werror_flag"
14473                          || test ! -s conftest.err'
14474   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14475   (eval $ac_try) 2>&5
14476   ac_status=$?
14477   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14478   (exit $ac_status); }; } &&
14479          { ac_try='test -s conftest$ac_exeext'
14480   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14481   (eval $ac_try) 2>&5
14482   ac_status=$?
14483   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14484   (exit $ac_status); }; }; then
14485   ac_cv_lib_m_cexpl=yes
14486 else
14487   echo "$as_me: failed program was:" >&5
14488 sed 's/^/| /' conftest.$ac_ext >&5
14489
14490 ac_cv_lib_m_cexpl=no
14491 fi
14492 rm -f conftest.err conftest.$ac_objext \
14493       conftest$ac_exeext conftest.$ac_ext
14494 LIBS=$ac_check_lib_save_LIBS
14495 fi
14496 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexpl" >&5
14497 echo "${ECHO_T}$ac_cv_lib_m_cexpl" >&6
14498 if test $ac_cv_lib_m_cexpl = yes; then
14499
14500 cat >>confdefs.h <<\_ACEOF
14501 #define HAVE_CEXPL 1
14502 _ACEOF
14503
14504 fi
14505
14506 echo "$as_me:$LINENO: checking for fabsf in -lm" >&5
14507 echo $ECHO_N "checking for fabsf in -lm... $ECHO_C" >&6
14508 if test "${ac_cv_lib_m_fabsf+set}" = set; then
14509   echo $ECHO_N "(cached) $ECHO_C" >&6
14510 else
14511   ac_check_lib_save_LIBS=$LIBS
14512 LIBS="-lm  $LIBS"
14513 if test x$gcc_no_link = xyes; then
14514   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14515 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14516    { (exit 1); exit 1; }; }
14517 fi
14518 cat >conftest.$ac_ext <<_ACEOF
14519 /* confdefs.h.  */
14520 _ACEOF
14521 cat confdefs.h >>conftest.$ac_ext
14522 cat >>conftest.$ac_ext <<_ACEOF
14523 /* end confdefs.h.  */
14524
14525 /* Override any gcc2 internal prototype to avoid an error.  */
14526 #ifdef __cplusplus
14527 extern "C"
14528 #endif
14529 /* We use char because int might match the return type of a gcc2
14530    builtin and then its argument prototype would still apply.  */
14531 char fabsf ();
14532 int
14533 main ()
14534 {
14535 fabsf ();
14536   ;
14537   return 0;
14538 }
14539 _ACEOF
14540 rm -f conftest.$ac_objext conftest$ac_exeext
14541 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14542   (eval $ac_link) 2>conftest.er1
14543   ac_status=$?
14544   grep -v '^ *+' conftest.er1 >conftest.err
14545   rm -f conftest.er1
14546   cat conftest.err >&5
14547   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14548   (exit $ac_status); } &&
14549          { ac_try='test -z "$ac_c_werror_flag"
14550                          || test ! -s conftest.err'
14551   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14552   (eval $ac_try) 2>&5
14553   ac_status=$?
14554   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14555   (exit $ac_status); }; } &&
14556          { ac_try='test -s conftest$ac_exeext'
14557   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14558   (eval $ac_try) 2>&5
14559   ac_status=$?
14560   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14561   (exit $ac_status); }; }; then
14562   ac_cv_lib_m_fabsf=yes
14563 else
14564   echo "$as_me: failed program was:" >&5
14565 sed 's/^/| /' conftest.$ac_ext >&5
14566
14567 ac_cv_lib_m_fabsf=no
14568 fi
14569 rm -f conftest.err conftest.$ac_objext \
14570       conftest$ac_exeext conftest.$ac_ext
14571 LIBS=$ac_check_lib_save_LIBS
14572 fi
14573 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabsf" >&5
14574 echo "${ECHO_T}$ac_cv_lib_m_fabsf" >&6
14575 if test $ac_cv_lib_m_fabsf = yes; then
14576
14577 cat >>confdefs.h <<\_ACEOF
14578 #define HAVE_FABSF 1
14579 _ACEOF
14580
14581 fi
14582
14583 echo "$as_me:$LINENO: checking for fabs in -lm" >&5
14584 echo $ECHO_N "checking for fabs in -lm... $ECHO_C" >&6
14585 if test "${ac_cv_lib_m_fabs+set}" = set; then
14586   echo $ECHO_N "(cached) $ECHO_C" >&6
14587 else
14588   ac_check_lib_save_LIBS=$LIBS
14589 LIBS="-lm  $LIBS"
14590 if test x$gcc_no_link = xyes; then
14591   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14592 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14593    { (exit 1); exit 1; }; }
14594 fi
14595 cat >conftest.$ac_ext <<_ACEOF
14596 /* confdefs.h.  */
14597 _ACEOF
14598 cat confdefs.h >>conftest.$ac_ext
14599 cat >>conftest.$ac_ext <<_ACEOF
14600 /* end confdefs.h.  */
14601
14602 /* Override any gcc2 internal prototype to avoid an error.  */
14603 #ifdef __cplusplus
14604 extern "C"
14605 #endif
14606 /* We use char because int might match the return type of a gcc2
14607    builtin and then its argument prototype would still apply.  */
14608 char fabs ();
14609 int
14610 main ()
14611 {
14612 fabs ();
14613   ;
14614   return 0;
14615 }
14616 _ACEOF
14617 rm -f conftest.$ac_objext conftest$ac_exeext
14618 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14619   (eval $ac_link) 2>conftest.er1
14620   ac_status=$?
14621   grep -v '^ *+' conftest.er1 >conftest.err
14622   rm -f conftest.er1
14623   cat conftest.err >&5
14624   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14625   (exit $ac_status); } &&
14626          { ac_try='test -z "$ac_c_werror_flag"
14627                          || test ! -s conftest.err'
14628   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14629   (eval $ac_try) 2>&5
14630   ac_status=$?
14631   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14632   (exit $ac_status); }; } &&
14633          { ac_try='test -s conftest$ac_exeext'
14634   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14635   (eval $ac_try) 2>&5
14636   ac_status=$?
14637   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14638   (exit $ac_status); }; }; then
14639   ac_cv_lib_m_fabs=yes
14640 else
14641   echo "$as_me: failed program was:" >&5
14642 sed 's/^/| /' conftest.$ac_ext >&5
14643
14644 ac_cv_lib_m_fabs=no
14645 fi
14646 rm -f conftest.err conftest.$ac_objext \
14647       conftest$ac_exeext conftest.$ac_ext
14648 LIBS=$ac_check_lib_save_LIBS
14649 fi
14650 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabs" >&5
14651 echo "${ECHO_T}$ac_cv_lib_m_fabs" >&6
14652 if test $ac_cv_lib_m_fabs = yes; then
14653
14654 cat >>confdefs.h <<\_ACEOF
14655 #define HAVE_FABS 1
14656 _ACEOF
14657
14658 fi
14659
14660 echo "$as_me:$LINENO: checking for fabsl in -lm" >&5
14661 echo $ECHO_N "checking for fabsl in -lm... $ECHO_C" >&6
14662 if test "${ac_cv_lib_m_fabsl+set}" = set; then
14663   echo $ECHO_N "(cached) $ECHO_C" >&6
14664 else
14665   ac_check_lib_save_LIBS=$LIBS
14666 LIBS="-lm  $LIBS"
14667 if test x$gcc_no_link = xyes; then
14668   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14669 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14670    { (exit 1); exit 1; }; }
14671 fi
14672 cat >conftest.$ac_ext <<_ACEOF
14673 /* confdefs.h.  */
14674 _ACEOF
14675 cat confdefs.h >>conftest.$ac_ext
14676 cat >>conftest.$ac_ext <<_ACEOF
14677 /* end confdefs.h.  */
14678
14679 /* Override any gcc2 internal prototype to avoid an error.  */
14680 #ifdef __cplusplus
14681 extern "C"
14682 #endif
14683 /* We use char because int might match the return type of a gcc2
14684    builtin and then its argument prototype would still apply.  */
14685 char fabsl ();
14686 int
14687 main ()
14688 {
14689 fabsl ();
14690   ;
14691   return 0;
14692 }
14693 _ACEOF
14694 rm -f conftest.$ac_objext conftest$ac_exeext
14695 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14696   (eval $ac_link) 2>conftest.er1
14697   ac_status=$?
14698   grep -v '^ *+' conftest.er1 >conftest.err
14699   rm -f conftest.er1
14700   cat conftest.err >&5
14701   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14702   (exit $ac_status); } &&
14703          { ac_try='test -z "$ac_c_werror_flag"
14704                          || test ! -s conftest.err'
14705   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14706   (eval $ac_try) 2>&5
14707   ac_status=$?
14708   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14709   (exit $ac_status); }; } &&
14710          { ac_try='test -s conftest$ac_exeext'
14711   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14712   (eval $ac_try) 2>&5
14713   ac_status=$?
14714   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14715   (exit $ac_status); }; }; then
14716   ac_cv_lib_m_fabsl=yes
14717 else
14718   echo "$as_me: failed program was:" >&5
14719 sed 's/^/| /' conftest.$ac_ext >&5
14720
14721 ac_cv_lib_m_fabsl=no
14722 fi
14723 rm -f conftest.err conftest.$ac_objext \
14724       conftest$ac_exeext conftest.$ac_ext
14725 LIBS=$ac_check_lib_save_LIBS
14726 fi
14727 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabsl" >&5
14728 echo "${ECHO_T}$ac_cv_lib_m_fabsl" >&6
14729 if test $ac_cv_lib_m_fabsl = yes; then
14730
14731 cat >>confdefs.h <<\_ACEOF
14732 #define HAVE_FABSL 1
14733 _ACEOF
14734
14735 fi
14736
14737 echo "$as_me:$LINENO: checking for cabsf in -lm" >&5
14738 echo $ECHO_N "checking for cabsf in -lm... $ECHO_C" >&6
14739 if test "${ac_cv_lib_m_cabsf+set}" = set; then
14740   echo $ECHO_N "(cached) $ECHO_C" >&6
14741 else
14742   ac_check_lib_save_LIBS=$LIBS
14743 LIBS="-lm  $LIBS"
14744 if test x$gcc_no_link = xyes; then
14745   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14746 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14747    { (exit 1); exit 1; }; }
14748 fi
14749 cat >conftest.$ac_ext <<_ACEOF
14750 /* confdefs.h.  */
14751 _ACEOF
14752 cat confdefs.h >>conftest.$ac_ext
14753 cat >>conftest.$ac_ext <<_ACEOF
14754 /* end confdefs.h.  */
14755
14756 /* Override any gcc2 internal prototype to avoid an error.  */
14757 #ifdef __cplusplus
14758 extern "C"
14759 #endif
14760 /* We use char because int might match the return type of a gcc2
14761    builtin and then its argument prototype would still apply.  */
14762 char cabsf ();
14763 int
14764 main ()
14765 {
14766 cabsf ();
14767   ;
14768   return 0;
14769 }
14770 _ACEOF
14771 rm -f conftest.$ac_objext conftest$ac_exeext
14772 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14773   (eval $ac_link) 2>conftest.er1
14774   ac_status=$?
14775   grep -v '^ *+' conftest.er1 >conftest.err
14776   rm -f conftest.er1
14777   cat conftest.err >&5
14778   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14779   (exit $ac_status); } &&
14780          { ac_try='test -z "$ac_c_werror_flag"
14781                          || test ! -s conftest.err'
14782   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14783   (eval $ac_try) 2>&5
14784   ac_status=$?
14785   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14786   (exit $ac_status); }; } &&
14787          { ac_try='test -s conftest$ac_exeext'
14788   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14789   (eval $ac_try) 2>&5
14790   ac_status=$?
14791   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14792   (exit $ac_status); }; }; then
14793   ac_cv_lib_m_cabsf=yes
14794 else
14795   echo "$as_me: failed program was:" >&5
14796 sed 's/^/| /' conftest.$ac_ext >&5
14797
14798 ac_cv_lib_m_cabsf=no
14799 fi
14800 rm -f conftest.err conftest.$ac_objext \
14801       conftest$ac_exeext conftest.$ac_ext
14802 LIBS=$ac_check_lib_save_LIBS
14803 fi
14804 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabsf" >&5
14805 echo "${ECHO_T}$ac_cv_lib_m_cabsf" >&6
14806 if test $ac_cv_lib_m_cabsf = yes; then
14807
14808 cat >>confdefs.h <<\_ACEOF
14809 #define HAVE_CABSF 1
14810 _ACEOF
14811
14812 fi
14813
14814 echo "$as_me:$LINENO: checking for cabs in -lm" >&5
14815 echo $ECHO_N "checking for cabs in -lm... $ECHO_C" >&6
14816 if test "${ac_cv_lib_m_cabs+set}" = set; then
14817   echo $ECHO_N "(cached) $ECHO_C" >&6
14818 else
14819   ac_check_lib_save_LIBS=$LIBS
14820 LIBS="-lm  $LIBS"
14821 if test x$gcc_no_link = xyes; then
14822   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14823 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14824    { (exit 1); exit 1; }; }
14825 fi
14826 cat >conftest.$ac_ext <<_ACEOF
14827 /* confdefs.h.  */
14828 _ACEOF
14829 cat confdefs.h >>conftest.$ac_ext
14830 cat >>conftest.$ac_ext <<_ACEOF
14831 /* end confdefs.h.  */
14832
14833 /* Override any gcc2 internal prototype to avoid an error.  */
14834 #ifdef __cplusplus
14835 extern "C"
14836 #endif
14837 /* We use char because int might match the return type of a gcc2
14838    builtin and then its argument prototype would still apply.  */
14839 char cabs ();
14840 int
14841 main ()
14842 {
14843 cabs ();
14844   ;
14845   return 0;
14846 }
14847 _ACEOF
14848 rm -f conftest.$ac_objext conftest$ac_exeext
14849 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14850   (eval $ac_link) 2>conftest.er1
14851   ac_status=$?
14852   grep -v '^ *+' conftest.er1 >conftest.err
14853   rm -f conftest.er1
14854   cat conftest.err >&5
14855   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14856   (exit $ac_status); } &&
14857          { ac_try='test -z "$ac_c_werror_flag"
14858                          || test ! -s conftest.err'
14859   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14860   (eval $ac_try) 2>&5
14861   ac_status=$?
14862   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14863   (exit $ac_status); }; } &&
14864          { ac_try='test -s conftest$ac_exeext'
14865   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14866   (eval $ac_try) 2>&5
14867   ac_status=$?
14868   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14869   (exit $ac_status); }; }; then
14870   ac_cv_lib_m_cabs=yes
14871 else
14872   echo "$as_me: failed program was:" >&5
14873 sed 's/^/| /' conftest.$ac_ext >&5
14874
14875 ac_cv_lib_m_cabs=no
14876 fi
14877 rm -f conftest.err conftest.$ac_objext \
14878       conftest$ac_exeext conftest.$ac_ext
14879 LIBS=$ac_check_lib_save_LIBS
14880 fi
14881 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabs" >&5
14882 echo "${ECHO_T}$ac_cv_lib_m_cabs" >&6
14883 if test $ac_cv_lib_m_cabs = yes; then
14884
14885 cat >>confdefs.h <<\_ACEOF
14886 #define HAVE_CABS 1
14887 _ACEOF
14888
14889 fi
14890
14891 echo "$as_me:$LINENO: checking for cabsl in -lm" >&5
14892 echo $ECHO_N "checking for cabsl in -lm... $ECHO_C" >&6
14893 if test "${ac_cv_lib_m_cabsl+set}" = set; then
14894   echo $ECHO_N "(cached) $ECHO_C" >&6
14895 else
14896   ac_check_lib_save_LIBS=$LIBS
14897 LIBS="-lm  $LIBS"
14898 if test x$gcc_no_link = xyes; then
14899   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14900 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14901    { (exit 1); exit 1; }; }
14902 fi
14903 cat >conftest.$ac_ext <<_ACEOF
14904 /* confdefs.h.  */
14905 _ACEOF
14906 cat confdefs.h >>conftest.$ac_ext
14907 cat >>conftest.$ac_ext <<_ACEOF
14908 /* end confdefs.h.  */
14909
14910 /* Override any gcc2 internal prototype to avoid an error.  */
14911 #ifdef __cplusplus
14912 extern "C"
14913 #endif
14914 /* We use char because int might match the return type of a gcc2
14915    builtin and then its argument prototype would still apply.  */
14916 char cabsl ();
14917 int
14918 main ()
14919 {
14920 cabsl ();
14921   ;
14922   return 0;
14923 }
14924 _ACEOF
14925 rm -f conftest.$ac_objext conftest$ac_exeext
14926 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14927   (eval $ac_link) 2>conftest.er1
14928   ac_status=$?
14929   grep -v '^ *+' conftest.er1 >conftest.err
14930   rm -f conftest.er1
14931   cat conftest.err >&5
14932   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14933   (exit $ac_status); } &&
14934          { ac_try='test -z "$ac_c_werror_flag"
14935                          || test ! -s conftest.err'
14936   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14937   (eval $ac_try) 2>&5
14938   ac_status=$?
14939   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14940   (exit $ac_status); }; } &&
14941          { ac_try='test -s conftest$ac_exeext'
14942   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14943   (eval $ac_try) 2>&5
14944   ac_status=$?
14945   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14946   (exit $ac_status); }; }; then
14947   ac_cv_lib_m_cabsl=yes
14948 else
14949   echo "$as_me: failed program was:" >&5
14950 sed 's/^/| /' conftest.$ac_ext >&5
14951
14952 ac_cv_lib_m_cabsl=no
14953 fi
14954 rm -f conftest.err conftest.$ac_objext \
14955       conftest$ac_exeext conftest.$ac_ext
14956 LIBS=$ac_check_lib_save_LIBS
14957 fi
14958 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabsl" >&5
14959 echo "${ECHO_T}$ac_cv_lib_m_cabsl" >&6
14960 if test $ac_cv_lib_m_cabsl = yes; then
14961
14962 cat >>confdefs.h <<\_ACEOF
14963 #define HAVE_CABSL 1
14964 _ACEOF
14965
14966 fi
14967
14968 echo "$as_me:$LINENO: checking for floorf in -lm" >&5
14969 echo $ECHO_N "checking for floorf in -lm... $ECHO_C" >&6
14970 if test "${ac_cv_lib_m_floorf+set}" = set; then
14971   echo $ECHO_N "(cached) $ECHO_C" >&6
14972 else
14973   ac_check_lib_save_LIBS=$LIBS
14974 LIBS="-lm  $LIBS"
14975 if test x$gcc_no_link = xyes; then
14976   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14977 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14978    { (exit 1); exit 1; }; }
14979 fi
14980 cat >conftest.$ac_ext <<_ACEOF
14981 /* confdefs.h.  */
14982 _ACEOF
14983 cat confdefs.h >>conftest.$ac_ext
14984 cat >>conftest.$ac_ext <<_ACEOF
14985 /* end confdefs.h.  */
14986
14987 /* Override any gcc2 internal prototype to avoid an error.  */
14988 #ifdef __cplusplus
14989 extern "C"
14990 #endif
14991 /* We use char because int might match the return type of a gcc2
14992    builtin and then its argument prototype would still apply.  */
14993 char floorf ();
14994 int
14995 main ()
14996 {
14997 floorf ();
14998   ;
14999   return 0;
15000 }
15001 _ACEOF
15002 rm -f conftest.$ac_objext conftest$ac_exeext
15003 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15004   (eval $ac_link) 2>conftest.er1
15005   ac_status=$?
15006   grep -v '^ *+' conftest.er1 >conftest.err
15007   rm -f conftest.er1
15008   cat conftest.err >&5
15009   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15010   (exit $ac_status); } &&
15011          { ac_try='test -z "$ac_c_werror_flag"
15012                          || test ! -s conftest.err'
15013   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15014   (eval $ac_try) 2>&5
15015   ac_status=$?
15016   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15017   (exit $ac_status); }; } &&
15018          { ac_try='test -s conftest$ac_exeext'
15019   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15020   (eval $ac_try) 2>&5
15021   ac_status=$?
15022   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15023   (exit $ac_status); }; }; then
15024   ac_cv_lib_m_floorf=yes
15025 else
15026   echo "$as_me: failed program was:" >&5
15027 sed 's/^/| /' conftest.$ac_ext >&5
15028
15029 ac_cv_lib_m_floorf=no
15030 fi
15031 rm -f conftest.err conftest.$ac_objext \
15032       conftest$ac_exeext conftest.$ac_ext
15033 LIBS=$ac_check_lib_save_LIBS
15034 fi
15035 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floorf" >&5
15036 echo "${ECHO_T}$ac_cv_lib_m_floorf" >&6
15037 if test $ac_cv_lib_m_floorf = yes; then
15038
15039 cat >>confdefs.h <<\_ACEOF
15040 #define HAVE_FLOORF 1
15041 _ACEOF
15042
15043 fi
15044
15045 echo "$as_me:$LINENO: checking for floor in -lm" >&5
15046 echo $ECHO_N "checking for floor in -lm... $ECHO_C" >&6
15047 if test "${ac_cv_lib_m_floor+set}" = set; then
15048   echo $ECHO_N "(cached) $ECHO_C" >&6
15049 else
15050   ac_check_lib_save_LIBS=$LIBS
15051 LIBS="-lm  $LIBS"
15052 if test x$gcc_no_link = xyes; then
15053   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15054 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15055    { (exit 1); exit 1; }; }
15056 fi
15057 cat >conftest.$ac_ext <<_ACEOF
15058 /* confdefs.h.  */
15059 _ACEOF
15060 cat confdefs.h >>conftest.$ac_ext
15061 cat >>conftest.$ac_ext <<_ACEOF
15062 /* end confdefs.h.  */
15063
15064 /* Override any gcc2 internal prototype to avoid an error.  */
15065 #ifdef __cplusplus
15066 extern "C"
15067 #endif
15068 /* We use char because int might match the return type of a gcc2
15069    builtin and then its argument prototype would still apply.  */
15070 char floor ();
15071 int
15072 main ()
15073 {
15074 floor ();
15075   ;
15076   return 0;
15077 }
15078 _ACEOF
15079 rm -f conftest.$ac_objext conftest$ac_exeext
15080 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15081   (eval $ac_link) 2>conftest.er1
15082   ac_status=$?
15083   grep -v '^ *+' conftest.er1 >conftest.err
15084   rm -f conftest.er1
15085   cat conftest.err >&5
15086   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15087   (exit $ac_status); } &&
15088          { ac_try='test -z "$ac_c_werror_flag"
15089                          || test ! -s conftest.err'
15090   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15091   (eval $ac_try) 2>&5
15092   ac_status=$?
15093   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15094   (exit $ac_status); }; } &&
15095          { ac_try='test -s conftest$ac_exeext'
15096   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15097   (eval $ac_try) 2>&5
15098   ac_status=$?
15099   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15100   (exit $ac_status); }; }; then
15101   ac_cv_lib_m_floor=yes
15102 else
15103   echo "$as_me: failed program was:" >&5
15104 sed 's/^/| /' conftest.$ac_ext >&5
15105
15106 ac_cv_lib_m_floor=no
15107 fi
15108 rm -f conftest.err conftest.$ac_objext \
15109       conftest$ac_exeext conftest.$ac_ext
15110 LIBS=$ac_check_lib_save_LIBS
15111 fi
15112 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floor" >&5
15113 echo "${ECHO_T}$ac_cv_lib_m_floor" >&6
15114 if test $ac_cv_lib_m_floor = yes; then
15115
15116 cat >>confdefs.h <<\_ACEOF
15117 #define HAVE_FLOOR 1
15118 _ACEOF
15119
15120 fi
15121
15122 echo "$as_me:$LINENO: checking for floorl in -lm" >&5
15123 echo $ECHO_N "checking for floorl in -lm... $ECHO_C" >&6
15124 if test "${ac_cv_lib_m_floorl+set}" = set; then
15125   echo $ECHO_N "(cached) $ECHO_C" >&6
15126 else
15127   ac_check_lib_save_LIBS=$LIBS
15128 LIBS="-lm  $LIBS"
15129 if test x$gcc_no_link = xyes; then
15130   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15131 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15132    { (exit 1); exit 1; }; }
15133 fi
15134 cat >conftest.$ac_ext <<_ACEOF
15135 /* confdefs.h.  */
15136 _ACEOF
15137 cat confdefs.h >>conftest.$ac_ext
15138 cat >>conftest.$ac_ext <<_ACEOF
15139 /* end confdefs.h.  */
15140
15141 /* Override any gcc2 internal prototype to avoid an error.  */
15142 #ifdef __cplusplus
15143 extern "C"
15144 #endif
15145 /* We use char because int might match the return type of a gcc2
15146    builtin and then its argument prototype would still apply.  */
15147 char floorl ();
15148 int
15149 main ()
15150 {
15151 floorl ();
15152   ;
15153   return 0;
15154 }
15155 _ACEOF
15156 rm -f conftest.$ac_objext conftest$ac_exeext
15157 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15158   (eval $ac_link) 2>conftest.er1
15159   ac_status=$?
15160   grep -v '^ *+' conftest.er1 >conftest.err
15161   rm -f conftest.er1
15162   cat conftest.err >&5
15163   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15164   (exit $ac_status); } &&
15165          { ac_try='test -z "$ac_c_werror_flag"
15166                          || test ! -s conftest.err'
15167   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15168   (eval $ac_try) 2>&5
15169   ac_status=$?
15170   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15171   (exit $ac_status); }; } &&
15172          { ac_try='test -s conftest$ac_exeext'
15173   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15174   (eval $ac_try) 2>&5
15175   ac_status=$?
15176   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15177   (exit $ac_status); }; }; then
15178   ac_cv_lib_m_floorl=yes
15179 else
15180   echo "$as_me: failed program was:" >&5
15181 sed 's/^/| /' conftest.$ac_ext >&5
15182
15183 ac_cv_lib_m_floorl=no
15184 fi
15185 rm -f conftest.err conftest.$ac_objext \
15186       conftest$ac_exeext conftest.$ac_ext
15187 LIBS=$ac_check_lib_save_LIBS
15188 fi
15189 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floorl" >&5
15190 echo "${ECHO_T}$ac_cv_lib_m_floorl" >&6
15191 if test $ac_cv_lib_m_floorl = yes; then
15192
15193 cat >>confdefs.h <<\_ACEOF
15194 #define HAVE_FLOORL 1
15195 _ACEOF
15196
15197 fi
15198
15199 echo "$as_me:$LINENO: checking for fmodf in -lm" >&5
15200 echo $ECHO_N "checking for fmodf in -lm... $ECHO_C" >&6
15201 if test "${ac_cv_lib_m_fmodf+set}" = set; then
15202   echo $ECHO_N "(cached) $ECHO_C" >&6
15203 else
15204   ac_check_lib_save_LIBS=$LIBS
15205 LIBS="-lm  $LIBS"
15206 if test x$gcc_no_link = xyes; then
15207   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15208 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15209    { (exit 1); exit 1; }; }
15210 fi
15211 cat >conftest.$ac_ext <<_ACEOF
15212 /* confdefs.h.  */
15213 _ACEOF
15214 cat confdefs.h >>conftest.$ac_ext
15215 cat >>conftest.$ac_ext <<_ACEOF
15216 /* end confdefs.h.  */
15217
15218 /* Override any gcc2 internal prototype to avoid an error.  */
15219 #ifdef __cplusplus
15220 extern "C"
15221 #endif
15222 /* We use char because int might match the return type of a gcc2
15223    builtin and then its argument prototype would still apply.  */
15224 char fmodf ();
15225 int
15226 main ()
15227 {
15228 fmodf ();
15229   ;
15230   return 0;
15231 }
15232 _ACEOF
15233 rm -f conftest.$ac_objext conftest$ac_exeext
15234 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15235   (eval $ac_link) 2>conftest.er1
15236   ac_status=$?
15237   grep -v '^ *+' conftest.er1 >conftest.err
15238   rm -f conftest.er1
15239   cat conftest.err >&5
15240   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15241   (exit $ac_status); } &&
15242          { ac_try='test -z "$ac_c_werror_flag"
15243                          || test ! -s conftest.err'
15244   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15245   (eval $ac_try) 2>&5
15246   ac_status=$?
15247   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15248   (exit $ac_status); }; } &&
15249          { ac_try='test -s conftest$ac_exeext'
15250   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15251   (eval $ac_try) 2>&5
15252   ac_status=$?
15253   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15254   (exit $ac_status); }; }; then
15255   ac_cv_lib_m_fmodf=yes
15256 else
15257   echo "$as_me: failed program was:" >&5
15258 sed 's/^/| /' conftest.$ac_ext >&5
15259
15260 ac_cv_lib_m_fmodf=no
15261 fi
15262 rm -f conftest.err conftest.$ac_objext \
15263       conftest$ac_exeext conftest.$ac_ext
15264 LIBS=$ac_check_lib_save_LIBS
15265 fi
15266 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fmodf" >&5
15267 echo "${ECHO_T}$ac_cv_lib_m_fmodf" >&6
15268 if test $ac_cv_lib_m_fmodf = yes; then
15269
15270 cat >>confdefs.h <<\_ACEOF
15271 #define HAVE_FMODF 1
15272 _ACEOF
15273
15274 fi
15275
15276 echo "$as_me:$LINENO: checking for fmod in -lm" >&5
15277 echo $ECHO_N "checking for fmod in -lm... $ECHO_C" >&6
15278 if test "${ac_cv_lib_m_fmod+set}" = set; then
15279   echo $ECHO_N "(cached) $ECHO_C" >&6
15280 else
15281   ac_check_lib_save_LIBS=$LIBS
15282 LIBS="-lm  $LIBS"
15283 if test x$gcc_no_link = xyes; then
15284   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15285 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15286    { (exit 1); exit 1; }; }
15287 fi
15288 cat >conftest.$ac_ext <<_ACEOF
15289 /* confdefs.h.  */
15290 _ACEOF
15291 cat confdefs.h >>conftest.$ac_ext
15292 cat >>conftest.$ac_ext <<_ACEOF
15293 /* end confdefs.h.  */
15294
15295 /* Override any gcc2 internal prototype to avoid an error.  */
15296 #ifdef __cplusplus
15297 extern "C"
15298 #endif
15299 /* We use char because int might match the return type of a gcc2
15300    builtin and then its argument prototype would still apply.  */
15301 char fmod ();
15302 int
15303 main ()
15304 {
15305 fmod ();
15306   ;
15307   return 0;
15308 }
15309 _ACEOF
15310 rm -f conftest.$ac_objext conftest$ac_exeext
15311 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15312   (eval $ac_link) 2>conftest.er1
15313   ac_status=$?
15314   grep -v '^ *+' conftest.er1 >conftest.err
15315   rm -f conftest.er1
15316   cat conftest.err >&5
15317   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15318   (exit $ac_status); } &&
15319          { ac_try='test -z "$ac_c_werror_flag"
15320                          || test ! -s conftest.err'
15321   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15322   (eval $ac_try) 2>&5
15323   ac_status=$?
15324   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15325   (exit $ac_status); }; } &&
15326          { ac_try='test -s conftest$ac_exeext'
15327   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15328   (eval $ac_try) 2>&5
15329   ac_status=$?
15330   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15331   (exit $ac_status); }; }; then
15332   ac_cv_lib_m_fmod=yes
15333 else
15334   echo "$as_me: failed program was:" >&5
15335 sed 's/^/| /' conftest.$ac_ext >&5
15336
15337 ac_cv_lib_m_fmod=no
15338 fi
15339 rm -f conftest.err conftest.$ac_objext \
15340       conftest$ac_exeext conftest.$ac_ext
15341 LIBS=$ac_check_lib_save_LIBS
15342 fi
15343 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fmod" >&5
15344 echo "${ECHO_T}$ac_cv_lib_m_fmod" >&6
15345 if test $ac_cv_lib_m_fmod = yes; then
15346
15347 cat >>confdefs.h <<\_ACEOF
15348 #define HAVE_FMOD 1
15349 _ACEOF
15350
15351 fi
15352
15353 echo "$as_me:$LINENO: checking for fmodl in -lm" >&5
15354 echo $ECHO_N "checking for fmodl in -lm... $ECHO_C" >&6
15355 if test "${ac_cv_lib_m_fmodl+set}" = set; then
15356   echo $ECHO_N "(cached) $ECHO_C" >&6
15357 else
15358   ac_check_lib_save_LIBS=$LIBS
15359 LIBS="-lm  $LIBS"
15360 if test x$gcc_no_link = xyes; then
15361   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15362 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15363    { (exit 1); exit 1; }; }
15364 fi
15365 cat >conftest.$ac_ext <<_ACEOF
15366 /* confdefs.h.  */
15367 _ACEOF
15368 cat confdefs.h >>conftest.$ac_ext
15369 cat >>conftest.$ac_ext <<_ACEOF
15370 /* end confdefs.h.  */
15371
15372 /* Override any gcc2 internal prototype to avoid an error.  */
15373 #ifdef __cplusplus
15374 extern "C"
15375 #endif
15376 /* We use char because int might match the return type of a gcc2
15377    builtin and then its argument prototype would still apply.  */
15378 char fmodl ();
15379 int
15380 main ()
15381 {
15382 fmodl ();
15383   ;
15384   return 0;
15385 }
15386 _ACEOF
15387 rm -f conftest.$ac_objext conftest$ac_exeext
15388 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15389   (eval $ac_link) 2>conftest.er1
15390   ac_status=$?
15391   grep -v '^ *+' conftest.er1 >conftest.err
15392   rm -f conftest.er1
15393   cat conftest.err >&5
15394   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15395   (exit $ac_status); } &&
15396          { ac_try='test -z "$ac_c_werror_flag"
15397                          || test ! -s conftest.err'
15398   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15399   (eval $ac_try) 2>&5
15400   ac_status=$?
15401   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15402   (exit $ac_status); }; } &&
15403          { ac_try='test -s conftest$ac_exeext'
15404   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15405   (eval $ac_try) 2>&5
15406   ac_status=$?
15407   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15408   (exit $ac_status); }; }; then
15409   ac_cv_lib_m_fmodl=yes
15410 else
15411   echo "$as_me: failed program was:" >&5
15412 sed 's/^/| /' conftest.$ac_ext >&5
15413
15414 ac_cv_lib_m_fmodl=no
15415 fi
15416 rm -f conftest.err conftest.$ac_objext \
15417       conftest$ac_exeext conftest.$ac_ext
15418 LIBS=$ac_check_lib_save_LIBS
15419 fi
15420 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fmodl" >&5
15421 echo "${ECHO_T}$ac_cv_lib_m_fmodl" >&6
15422 if test $ac_cv_lib_m_fmodl = yes; then
15423
15424 cat >>confdefs.h <<\_ACEOF
15425 #define HAVE_FMODL 1
15426 _ACEOF
15427
15428 fi
15429
15430 echo "$as_me:$LINENO: checking for frexpf in -lm" >&5
15431 echo $ECHO_N "checking for frexpf in -lm... $ECHO_C" >&6
15432 if test "${ac_cv_lib_m_frexpf+set}" = set; then
15433   echo $ECHO_N "(cached) $ECHO_C" >&6
15434 else
15435   ac_check_lib_save_LIBS=$LIBS
15436 LIBS="-lm  $LIBS"
15437 if test x$gcc_no_link = xyes; then
15438   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15439 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15440    { (exit 1); exit 1; }; }
15441 fi
15442 cat >conftest.$ac_ext <<_ACEOF
15443 /* confdefs.h.  */
15444 _ACEOF
15445 cat confdefs.h >>conftest.$ac_ext
15446 cat >>conftest.$ac_ext <<_ACEOF
15447 /* end confdefs.h.  */
15448
15449 /* Override any gcc2 internal prototype to avoid an error.  */
15450 #ifdef __cplusplus
15451 extern "C"
15452 #endif
15453 /* We use char because int might match the return type of a gcc2
15454    builtin and then its argument prototype would still apply.  */
15455 char frexpf ();
15456 int
15457 main ()
15458 {
15459 frexpf ();
15460   ;
15461   return 0;
15462 }
15463 _ACEOF
15464 rm -f conftest.$ac_objext conftest$ac_exeext
15465 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15466   (eval $ac_link) 2>conftest.er1
15467   ac_status=$?
15468   grep -v '^ *+' conftest.er1 >conftest.err
15469   rm -f conftest.er1
15470   cat conftest.err >&5
15471   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15472   (exit $ac_status); } &&
15473          { ac_try='test -z "$ac_c_werror_flag"
15474                          || test ! -s conftest.err'
15475   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15476   (eval $ac_try) 2>&5
15477   ac_status=$?
15478   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15479   (exit $ac_status); }; } &&
15480          { ac_try='test -s conftest$ac_exeext'
15481   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15482   (eval $ac_try) 2>&5
15483   ac_status=$?
15484   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15485   (exit $ac_status); }; }; then
15486   ac_cv_lib_m_frexpf=yes
15487 else
15488   echo "$as_me: failed program was:" >&5
15489 sed 's/^/| /' conftest.$ac_ext >&5
15490
15491 ac_cv_lib_m_frexpf=no
15492 fi
15493 rm -f conftest.err conftest.$ac_objext \
15494       conftest$ac_exeext conftest.$ac_ext
15495 LIBS=$ac_check_lib_save_LIBS
15496 fi
15497 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexpf" >&5
15498 echo "${ECHO_T}$ac_cv_lib_m_frexpf" >&6
15499 if test $ac_cv_lib_m_frexpf = yes; then
15500
15501 cat >>confdefs.h <<\_ACEOF
15502 #define HAVE_FREXPF 1
15503 _ACEOF
15504
15505 fi
15506
15507 echo "$as_me:$LINENO: checking for frexp in -lm" >&5
15508 echo $ECHO_N "checking for frexp in -lm... $ECHO_C" >&6
15509 if test "${ac_cv_lib_m_frexp+set}" = set; then
15510   echo $ECHO_N "(cached) $ECHO_C" >&6
15511 else
15512   ac_check_lib_save_LIBS=$LIBS
15513 LIBS="-lm  $LIBS"
15514 if test x$gcc_no_link = xyes; then
15515   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15516 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15517    { (exit 1); exit 1; }; }
15518 fi
15519 cat >conftest.$ac_ext <<_ACEOF
15520 /* confdefs.h.  */
15521 _ACEOF
15522 cat confdefs.h >>conftest.$ac_ext
15523 cat >>conftest.$ac_ext <<_ACEOF
15524 /* end confdefs.h.  */
15525
15526 /* Override any gcc2 internal prototype to avoid an error.  */
15527 #ifdef __cplusplus
15528 extern "C"
15529 #endif
15530 /* We use char because int might match the return type of a gcc2
15531    builtin and then its argument prototype would still apply.  */
15532 char frexp ();
15533 int
15534 main ()
15535 {
15536 frexp ();
15537   ;
15538   return 0;
15539 }
15540 _ACEOF
15541 rm -f conftest.$ac_objext conftest$ac_exeext
15542 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15543   (eval $ac_link) 2>conftest.er1
15544   ac_status=$?
15545   grep -v '^ *+' conftest.er1 >conftest.err
15546   rm -f conftest.er1
15547   cat conftest.err >&5
15548   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15549   (exit $ac_status); } &&
15550          { ac_try='test -z "$ac_c_werror_flag"
15551                          || test ! -s conftest.err'
15552   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15553   (eval $ac_try) 2>&5
15554   ac_status=$?
15555   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15556   (exit $ac_status); }; } &&
15557          { ac_try='test -s conftest$ac_exeext'
15558   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15559   (eval $ac_try) 2>&5
15560   ac_status=$?
15561   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15562   (exit $ac_status); }; }; then
15563   ac_cv_lib_m_frexp=yes
15564 else
15565   echo "$as_me: failed program was:" >&5
15566 sed 's/^/| /' conftest.$ac_ext >&5
15567
15568 ac_cv_lib_m_frexp=no
15569 fi
15570 rm -f conftest.err conftest.$ac_objext \
15571       conftest$ac_exeext conftest.$ac_ext
15572 LIBS=$ac_check_lib_save_LIBS
15573 fi
15574 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexp" >&5
15575 echo "${ECHO_T}$ac_cv_lib_m_frexp" >&6
15576 if test $ac_cv_lib_m_frexp = yes; then
15577
15578 cat >>confdefs.h <<\_ACEOF
15579 #define HAVE_FREXP 1
15580 _ACEOF
15581
15582 fi
15583
15584 echo "$as_me:$LINENO: checking for frexpl in -lm" >&5
15585 echo $ECHO_N "checking for frexpl in -lm... $ECHO_C" >&6
15586 if test "${ac_cv_lib_m_frexpl+set}" = set; then
15587   echo $ECHO_N "(cached) $ECHO_C" >&6
15588 else
15589   ac_check_lib_save_LIBS=$LIBS
15590 LIBS="-lm  $LIBS"
15591 if test x$gcc_no_link = xyes; then
15592   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15593 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15594    { (exit 1); exit 1; }; }
15595 fi
15596 cat >conftest.$ac_ext <<_ACEOF
15597 /* confdefs.h.  */
15598 _ACEOF
15599 cat confdefs.h >>conftest.$ac_ext
15600 cat >>conftest.$ac_ext <<_ACEOF
15601 /* end confdefs.h.  */
15602
15603 /* Override any gcc2 internal prototype to avoid an error.  */
15604 #ifdef __cplusplus
15605 extern "C"
15606 #endif
15607 /* We use char because int might match the return type of a gcc2
15608    builtin and then its argument prototype would still apply.  */
15609 char frexpl ();
15610 int
15611 main ()
15612 {
15613 frexpl ();
15614   ;
15615   return 0;
15616 }
15617 _ACEOF
15618 rm -f conftest.$ac_objext conftest$ac_exeext
15619 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15620   (eval $ac_link) 2>conftest.er1
15621   ac_status=$?
15622   grep -v '^ *+' conftest.er1 >conftest.err
15623   rm -f conftest.er1
15624   cat conftest.err >&5
15625   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15626   (exit $ac_status); } &&
15627          { ac_try='test -z "$ac_c_werror_flag"
15628                          || test ! -s conftest.err'
15629   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15630   (eval $ac_try) 2>&5
15631   ac_status=$?
15632   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15633   (exit $ac_status); }; } &&
15634          { ac_try='test -s conftest$ac_exeext'
15635   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15636   (eval $ac_try) 2>&5
15637   ac_status=$?
15638   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15639   (exit $ac_status); }; }; then
15640   ac_cv_lib_m_frexpl=yes
15641 else
15642   echo "$as_me: failed program was:" >&5
15643 sed 's/^/| /' conftest.$ac_ext >&5
15644
15645 ac_cv_lib_m_frexpl=no
15646 fi
15647 rm -f conftest.err conftest.$ac_objext \
15648       conftest$ac_exeext conftest.$ac_ext
15649 LIBS=$ac_check_lib_save_LIBS
15650 fi
15651 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexpl" >&5
15652 echo "${ECHO_T}$ac_cv_lib_m_frexpl" >&6
15653 if test $ac_cv_lib_m_frexpl = yes; then
15654
15655 cat >>confdefs.h <<\_ACEOF
15656 #define HAVE_FREXPL 1
15657 _ACEOF
15658
15659 fi
15660
15661 echo "$as_me:$LINENO: checking for hypotf in -lm" >&5
15662 echo $ECHO_N "checking for hypotf in -lm... $ECHO_C" >&6
15663 if test "${ac_cv_lib_m_hypotf+set}" = set; then
15664   echo $ECHO_N "(cached) $ECHO_C" >&6
15665 else
15666   ac_check_lib_save_LIBS=$LIBS
15667 LIBS="-lm  $LIBS"
15668 if test x$gcc_no_link = xyes; then
15669   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15670 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15671    { (exit 1); exit 1; }; }
15672 fi
15673 cat >conftest.$ac_ext <<_ACEOF
15674 /* confdefs.h.  */
15675 _ACEOF
15676 cat confdefs.h >>conftest.$ac_ext
15677 cat >>conftest.$ac_ext <<_ACEOF
15678 /* end confdefs.h.  */
15679
15680 /* Override any gcc2 internal prototype to avoid an error.  */
15681 #ifdef __cplusplus
15682 extern "C"
15683 #endif
15684 /* We use char because int might match the return type of a gcc2
15685    builtin and then its argument prototype would still apply.  */
15686 char hypotf ();
15687 int
15688 main ()
15689 {
15690 hypotf ();
15691   ;
15692   return 0;
15693 }
15694 _ACEOF
15695 rm -f conftest.$ac_objext conftest$ac_exeext
15696 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15697   (eval $ac_link) 2>conftest.er1
15698   ac_status=$?
15699   grep -v '^ *+' conftest.er1 >conftest.err
15700   rm -f conftest.er1
15701   cat conftest.err >&5
15702   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15703   (exit $ac_status); } &&
15704          { ac_try='test -z "$ac_c_werror_flag"
15705                          || test ! -s conftest.err'
15706   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15707   (eval $ac_try) 2>&5
15708   ac_status=$?
15709   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15710   (exit $ac_status); }; } &&
15711          { ac_try='test -s conftest$ac_exeext'
15712   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15713   (eval $ac_try) 2>&5
15714   ac_status=$?
15715   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15716   (exit $ac_status); }; }; then
15717   ac_cv_lib_m_hypotf=yes
15718 else
15719   echo "$as_me: failed program was:" >&5
15720 sed 's/^/| /' conftest.$ac_ext >&5
15721
15722 ac_cv_lib_m_hypotf=no
15723 fi
15724 rm -f conftest.err conftest.$ac_objext \
15725       conftest$ac_exeext conftest.$ac_ext
15726 LIBS=$ac_check_lib_save_LIBS
15727 fi
15728 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypotf" >&5
15729 echo "${ECHO_T}$ac_cv_lib_m_hypotf" >&6
15730 if test $ac_cv_lib_m_hypotf = yes; then
15731
15732 cat >>confdefs.h <<\_ACEOF
15733 #define HAVE_HYPOTF 1
15734 _ACEOF
15735
15736 fi
15737
15738 echo "$as_me:$LINENO: checking for hypot in -lm" >&5
15739 echo $ECHO_N "checking for hypot in -lm... $ECHO_C" >&6
15740 if test "${ac_cv_lib_m_hypot+set}" = set; then
15741   echo $ECHO_N "(cached) $ECHO_C" >&6
15742 else
15743   ac_check_lib_save_LIBS=$LIBS
15744 LIBS="-lm  $LIBS"
15745 if test x$gcc_no_link = xyes; then
15746   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15747 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15748    { (exit 1); exit 1; }; }
15749 fi
15750 cat >conftest.$ac_ext <<_ACEOF
15751 /* confdefs.h.  */
15752 _ACEOF
15753 cat confdefs.h >>conftest.$ac_ext
15754 cat >>conftest.$ac_ext <<_ACEOF
15755 /* end confdefs.h.  */
15756
15757 /* Override any gcc2 internal prototype to avoid an error.  */
15758 #ifdef __cplusplus
15759 extern "C"
15760 #endif
15761 /* We use char because int might match the return type of a gcc2
15762    builtin and then its argument prototype would still apply.  */
15763 char hypot ();
15764 int
15765 main ()
15766 {
15767 hypot ();
15768   ;
15769   return 0;
15770 }
15771 _ACEOF
15772 rm -f conftest.$ac_objext conftest$ac_exeext
15773 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15774   (eval $ac_link) 2>conftest.er1
15775   ac_status=$?
15776   grep -v '^ *+' conftest.er1 >conftest.err
15777   rm -f conftest.er1
15778   cat conftest.err >&5
15779   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15780   (exit $ac_status); } &&
15781          { ac_try='test -z "$ac_c_werror_flag"
15782                          || test ! -s conftest.err'
15783   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15784   (eval $ac_try) 2>&5
15785   ac_status=$?
15786   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15787   (exit $ac_status); }; } &&
15788          { ac_try='test -s conftest$ac_exeext'
15789   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15790   (eval $ac_try) 2>&5
15791   ac_status=$?
15792   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15793   (exit $ac_status); }; }; then
15794   ac_cv_lib_m_hypot=yes
15795 else
15796   echo "$as_me: failed program was:" >&5
15797 sed 's/^/| /' conftest.$ac_ext >&5
15798
15799 ac_cv_lib_m_hypot=no
15800 fi
15801 rm -f conftest.err conftest.$ac_objext \
15802       conftest$ac_exeext conftest.$ac_ext
15803 LIBS=$ac_check_lib_save_LIBS
15804 fi
15805 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypot" >&5
15806 echo "${ECHO_T}$ac_cv_lib_m_hypot" >&6
15807 if test $ac_cv_lib_m_hypot = yes; then
15808
15809 cat >>confdefs.h <<\_ACEOF
15810 #define HAVE_HYPOT 1
15811 _ACEOF
15812
15813 fi
15814
15815 echo "$as_me:$LINENO: checking for hypotl in -lm" >&5
15816 echo $ECHO_N "checking for hypotl in -lm... $ECHO_C" >&6
15817 if test "${ac_cv_lib_m_hypotl+set}" = set; then
15818   echo $ECHO_N "(cached) $ECHO_C" >&6
15819 else
15820   ac_check_lib_save_LIBS=$LIBS
15821 LIBS="-lm  $LIBS"
15822 if test x$gcc_no_link = xyes; then
15823   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15824 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15825    { (exit 1); exit 1; }; }
15826 fi
15827 cat >conftest.$ac_ext <<_ACEOF
15828 /* confdefs.h.  */
15829 _ACEOF
15830 cat confdefs.h >>conftest.$ac_ext
15831 cat >>conftest.$ac_ext <<_ACEOF
15832 /* end confdefs.h.  */
15833
15834 /* Override any gcc2 internal prototype to avoid an error.  */
15835 #ifdef __cplusplus
15836 extern "C"
15837 #endif
15838 /* We use char because int might match the return type of a gcc2
15839    builtin and then its argument prototype would still apply.  */
15840 char hypotl ();
15841 int
15842 main ()
15843 {
15844 hypotl ();
15845   ;
15846   return 0;
15847 }
15848 _ACEOF
15849 rm -f conftest.$ac_objext conftest$ac_exeext
15850 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15851   (eval $ac_link) 2>conftest.er1
15852   ac_status=$?
15853   grep -v '^ *+' conftest.er1 >conftest.err
15854   rm -f conftest.er1
15855   cat conftest.err >&5
15856   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15857   (exit $ac_status); } &&
15858          { ac_try='test -z "$ac_c_werror_flag"
15859                          || test ! -s conftest.err'
15860   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15861   (eval $ac_try) 2>&5
15862   ac_status=$?
15863   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15864   (exit $ac_status); }; } &&
15865          { ac_try='test -s conftest$ac_exeext'
15866   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15867   (eval $ac_try) 2>&5
15868   ac_status=$?
15869   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15870   (exit $ac_status); }; }; then
15871   ac_cv_lib_m_hypotl=yes
15872 else
15873   echo "$as_me: failed program was:" >&5
15874 sed 's/^/| /' conftest.$ac_ext >&5
15875
15876 ac_cv_lib_m_hypotl=no
15877 fi
15878 rm -f conftest.err conftest.$ac_objext \
15879       conftest$ac_exeext conftest.$ac_ext
15880 LIBS=$ac_check_lib_save_LIBS
15881 fi
15882 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypotl" >&5
15883 echo "${ECHO_T}$ac_cv_lib_m_hypotl" >&6
15884 if test $ac_cv_lib_m_hypotl = yes; then
15885
15886 cat >>confdefs.h <<\_ACEOF
15887 #define HAVE_HYPOTL 1
15888 _ACEOF
15889
15890 fi
15891
15892 echo "$as_me:$LINENO: checking for ldexpf in -lm" >&5
15893 echo $ECHO_N "checking for ldexpf in -lm... $ECHO_C" >&6
15894 if test "${ac_cv_lib_m_ldexpf+set}" = set; then
15895   echo $ECHO_N "(cached) $ECHO_C" >&6
15896 else
15897   ac_check_lib_save_LIBS=$LIBS
15898 LIBS="-lm  $LIBS"
15899 if test x$gcc_no_link = xyes; then
15900   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15901 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15902    { (exit 1); exit 1; }; }
15903 fi
15904 cat >conftest.$ac_ext <<_ACEOF
15905 /* confdefs.h.  */
15906 _ACEOF
15907 cat confdefs.h >>conftest.$ac_ext
15908 cat >>conftest.$ac_ext <<_ACEOF
15909 /* end confdefs.h.  */
15910
15911 /* Override any gcc2 internal prototype to avoid an error.  */
15912 #ifdef __cplusplus
15913 extern "C"
15914 #endif
15915 /* We use char because int might match the return type of a gcc2
15916    builtin and then its argument prototype would still apply.  */
15917 char ldexpf ();
15918 int
15919 main ()
15920 {
15921 ldexpf ();
15922   ;
15923   return 0;
15924 }
15925 _ACEOF
15926 rm -f conftest.$ac_objext conftest$ac_exeext
15927 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15928   (eval $ac_link) 2>conftest.er1
15929   ac_status=$?
15930   grep -v '^ *+' conftest.er1 >conftest.err
15931   rm -f conftest.er1
15932   cat conftest.err >&5
15933   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15934   (exit $ac_status); } &&
15935          { ac_try='test -z "$ac_c_werror_flag"
15936                          || test ! -s conftest.err'
15937   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15938   (eval $ac_try) 2>&5
15939   ac_status=$?
15940   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15941   (exit $ac_status); }; } &&
15942          { ac_try='test -s conftest$ac_exeext'
15943   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15944   (eval $ac_try) 2>&5
15945   ac_status=$?
15946   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15947   (exit $ac_status); }; }; then
15948   ac_cv_lib_m_ldexpf=yes
15949 else
15950   echo "$as_me: failed program was:" >&5
15951 sed 's/^/| /' conftest.$ac_ext >&5
15952
15953 ac_cv_lib_m_ldexpf=no
15954 fi
15955 rm -f conftest.err conftest.$ac_objext \
15956       conftest$ac_exeext conftest.$ac_ext
15957 LIBS=$ac_check_lib_save_LIBS
15958 fi
15959 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ldexpf" >&5
15960 echo "${ECHO_T}$ac_cv_lib_m_ldexpf" >&6
15961 if test $ac_cv_lib_m_ldexpf = yes; then
15962
15963 cat >>confdefs.h <<\_ACEOF
15964 #define HAVE_LDEXPF 1
15965 _ACEOF
15966
15967 fi
15968
15969 echo "$as_me:$LINENO: checking for ldexp in -lm" >&5
15970 echo $ECHO_N "checking for ldexp in -lm... $ECHO_C" >&6
15971 if test "${ac_cv_lib_m_ldexp+set}" = set; then
15972   echo $ECHO_N "(cached) $ECHO_C" >&6
15973 else
15974   ac_check_lib_save_LIBS=$LIBS
15975 LIBS="-lm  $LIBS"
15976 if test x$gcc_no_link = xyes; then
15977   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15978 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15979    { (exit 1); exit 1; }; }
15980 fi
15981 cat >conftest.$ac_ext <<_ACEOF
15982 /* confdefs.h.  */
15983 _ACEOF
15984 cat confdefs.h >>conftest.$ac_ext
15985 cat >>conftest.$ac_ext <<_ACEOF
15986 /* end confdefs.h.  */
15987
15988 /* Override any gcc2 internal prototype to avoid an error.  */
15989 #ifdef __cplusplus
15990 extern "C"
15991 #endif
15992 /* We use char because int might match the return type of a gcc2
15993    builtin and then its argument prototype would still apply.  */
15994 char ldexp ();
15995 int
15996 main ()
15997 {
15998 ldexp ();
15999   ;
16000   return 0;
16001 }
16002 _ACEOF
16003 rm -f conftest.$ac_objext conftest$ac_exeext
16004 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16005   (eval $ac_link) 2>conftest.er1
16006   ac_status=$?
16007   grep -v '^ *+' conftest.er1 >conftest.err
16008   rm -f conftest.er1
16009   cat conftest.err >&5
16010   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16011   (exit $ac_status); } &&
16012          { ac_try='test -z "$ac_c_werror_flag"
16013                          || test ! -s conftest.err'
16014   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16015   (eval $ac_try) 2>&5
16016   ac_status=$?
16017   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16018   (exit $ac_status); }; } &&
16019          { ac_try='test -s conftest$ac_exeext'
16020   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16021   (eval $ac_try) 2>&5
16022   ac_status=$?
16023   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16024   (exit $ac_status); }; }; then
16025   ac_cv_lib_m_ldexp=yes
16026 else
16027   echo "$as_me: failed program was:" >&5
16028 sed 's/^/| /' conftest.$ac_ext >&5
16029
16030 ac_cv_lib_m_ldexp=no
16031 fi
16032 rm -f conftest.err conftest.$ac_objext \
16033       conftest$ac_exeext conftest.$ac_ext
16034 LIBS=$ac_check_lib_save_LIBS
16035 fi
16036 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ldexp" >&5
16037 echo "${ECHO_T}$ac_cv_lib_m_ldexp" >&6
16038 if test $ac_cv_lib_m_ldexp = yes; then
16039
16040 cat >>confdefs.h <<\_ACEOF
16041 #define HAVE_LDEXP 1
16042 _ACEOF
16043
16044 fi
16045
16046 echo "$as_me:$LINENO: checking for ldexpl in -lm" >&5
16047 echo $ECHO_N "checking for ldexpl in -lm... $ECHO_C" >&6
16048 if test "${ac_cv_lib_m_ldexpl+set}" = set; then
16049   echo $ECHO_N "(cached) $ECHO_C" >&6
16050 else
16051   ac_check_lib_save_LIBS=$LIBS
16052 LIBS="-lm  $LIBS"
16053 if test x$gcc_no_link = xyes; then
16054   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16055 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16056    { (exit 1); exit 1; }; }
16057 fi
16058 cat >conftest.$ac_ext <<_ACEOF
16059 /* confdefs.h.  */
16060 _ACEOF
16061 cat confdefs.h >>conftest.$ac_ext
16062 cat >>conftest.$ac_ext <<_ACEOF
16063 /* end confdefs.h.  */
16064
16065 /* Override any gcc2 internal prototype to avoid an error.  */
16066 #ifdef __cplusplus
16067 extern "C"
16068 #endif
16069 /* We use char because int might match the return type of a gcc2
16070    builtin and then its argument prototype would still apply.  */
16071 char ldexpl ();
16072 int
16073 main ()
16074 {
16075 ldexpl ();
16076   ;
16077   return 0;
16078 }
16079 _ACEOF
16080 rm -f conftest.$ac_objext conftest$ac_exeext
16081 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16082   (eval $ac_link) 2>conftest.er1
16083   ac_status=$?
16084   grep -v '^ *+' conftest.er1 >conftest.err
16085   rm -f conftest.er1
16086   cat conftest.err >&5
16087   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16088   (exit $ac_status); } &&
16089          { ac_try='test -z "$ac_c_werror_flag"
16090                          || test ! -s conftest.err'
16091   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16092   (eval $ac_try) 2>&5
16093   ac_status=$?
16094   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16095   (exit $ac_status); }; } &&
16096          { ac_try='test -s conftest$ac_exeext'
16097   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16098   (eval $ac_try) 2>&5
16099   ac_status=$?
16100   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16101   (exit $ac_status); }; }; then
16102   ac_cv_lib_m_ldexpl=yes
16103 else
16104   echo "$as_me: failed program was:" >&5
16105 sed 's/^/| /' conftest.$ac_ext >&5
16106
16107 ac_cv_lib_m_ldexpl=no
16108 fi
16109 rm -f conftest.err conftest.$ac_objext \
16110       conftest$ac_exeext conftest.$ac_ext
16111 LIBS=$ac_check_lib_save_LIBS
16112 fi
16113 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ldexpl" >&5
16114 echo "${ECHO_T}$ac_cv_lib_m_ldexpl" >&6
16115 if test $ac_cv_lib_m_ldexpl = yes; then
16116
16117 cat >>confdefs.h <<\_ACEOF
16118 #define HAVE_LDEXPL 1
16119 _ACEOF
16120
16121 fi
16122
16123 echo "$as_me:$LINENO: checking for logf in -lm" >&5
16124 echo $ECHO_N "checking for logf in -lm... $ECHO_C" >&6
16125 if test "${ac_cv_lib_m_logf+set}" = set; then
16126   echo $ECHO_N "(cached) $ECHO_C" >&6
16127 else
16128   ac_check_lib_save_LIBS=$LIBS
16129 LIBS="-lm  $LIBS"
16130 if test x$gcc_no_link = xyes; then
16131   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16132 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16133    { (exit 1); exit 1; }; }
16134 fi
16135 cat >conftest.$ac_ext <<_ACEOF
16136 /* confdefs.h.  */
16137 _ACEOF
16138 cat confdefs.h >>conftest.$ac_ext
16139 cat >>conftest.$ac_ext <<_ACEOF
16140 /* end confdefs.h.  */
16141
16142 /* Override any gcc2 internal prototype to avoid an error.  */
16143 #ifdef __cplusplus
16144 extern "C"
16145 #endif
16146 /* We use char because int might match the return type of a gcc2
16147    builtin and then its argument prototype would still apply.  */
16148 char logf ();
16149 int
16150 main ()
16151 {
16152 logf ();
16153   ;
16154   return 0;
16155 }
16156 _ACEOF
16157 rm -f conftest.$ac_objext conftest$ac_exeext
16158 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16159   (eval $ac_link) 2>conftest.er1
16160   ac_status=$?
16161   grep -v '^ *+' conftest.er1 >conftest.err
16162   rm -f conftest.er1
16163   cat conftest.err >&5
16164   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16165   (exit $ac_status); } &&
16166          { ac_try='test -z "$ac_c_werror_flag"
16167                          || test ! -s conftest.err'
16168   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16169   (eval $ac_try) 2>&5
16170   ac_status=$?
16171   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16172   (exit $ac_status); }; } &&
16173          { ac_try='test -s conftest$ac_exeext'
16174   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16175   (eval $ac_try) 2>&5
16176   ac_status=$?
16177   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16178   (exit $ac_status); }; }; then
16179   ac_cv_lib_m_logf=yes
16180 else
16181   echo "$as_me: failed program was:" >&5
16182 sed 's/^/| /' conftest.$ac_ext >&5
16183
16184 ac_cv_lib_m_logf=no
16185 fi
16186 rm -f conftest.err conftest.$ac_objext \
16187       conftest$ac_exeext conftest.$ac_ext
16188 LIBS=$ac_check_lib_save_LIBS
16189 fi
16190 echo "$as_me:$LINENO: result: $ac_cv_lib_m_logf" >&5
16191 echo "${ECHO_T}$ac_cv_lib_m_logf" >&6
16192 if test $ac_cv_lib_m_logf = yes; then
16193
16194 cat >>confdefs.h <<\_ACEOF
16195 #define HAVE_LOGF 1
16196 _ACEOF
16197
16198 fi
16199
16200 echo "$as_me:$LINENO: checking for log in -lm" >&5
16201 echo $ECHO_N "checking for log in -lm... $ECHO_C" >&6
16202 if test "${ac_cv_lib_m_log+set}" = set; then
16203   echo $ECHO_N "(cached) $ECHO_C" >&6
16204 else
16205   ac_check_lib_save_LIBS=$LIBS
16206 LIBS="-lm  $LIBS"
16207 if test x$gcc_no_link = xyes; then
16208   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16209 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16210    { (exit 1); exit 1; }; }
16211 fi
16212 cat >conftest.$ac_ext <<_ACEOF
16213 /* confdefs.h.  */
16214 _ACEOF
16215 cat confdefs.h >>conftest.$ac_ext
16216 cat >>conftest.$ac_ext <<_ACEOF
16217 /* end confdefs.h.  */
16218
16219 /* Override any gcc2 internal prototype to avoid an error.  */
16220 #ifdef __cplusplus
16221 extern "C"
16222 #endif
16223 /* We use char because int might match the return type of a gcc2
16224    builtin and then its argument prototype would still apply.  */
16225 char log ();
16226 int
16227 main ()
16228 {
16229 log ();
16230   ;
16231   return 0;
16232 }
16233 _ACEOF
16234 rm -f conftest.$ac_objext conftest$ac_exeext
16235 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16236   (eval $ac_link) 2>conftest.er1
16237   ac_status=$?
16238   grep -v '^ *+' conftest.er1 >conftest.err
16239   rm -f conftest.er1
16240   cat conftest.err >&5
16241   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16242   (exit $ac_status); } &&
16243          { ac_try='test -z "$ac_c_werror_flag"
16244                          || test ! -s conftest.err'
16245   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16246   (eval $ac_try) 2>&5
16247   ac_status=$?
16248   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16249   (exit $ac_status); }; } &&
16250          { ac_try='test -s conftest$ac_exeext'
16251   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16252   (eval $ac_try) 2>&5
16253   ac_status=$?
16254   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16255   (exit $ac_status); }; }; then
16256   ac_cv_lib_m_log=yes
16257 else
16258   echo "$as_me: failed program was:" >&5
16259 sed 's/^/| /' conftest.$ac_ext >&5
16260
16261 ac_cv_lib_m_log=no
16262 fi
16263 rm -f conftest.err conftest.$ac_objext \
16264       conftest$ac_exeext conftest.$ac_ext
16265 LIBS=$ac_check_lib_save_LIBS
16266 fi
16267 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log" >&5
16268 echo "${ECHO_T}$ac_cv_lib_m_log" >&6
16269 if test $ac_cv_lib_m_log = yes; then
16270
16271 cat >>confdefs.h <<\_ACEOF
16272 #define HAVE_LOG 1
16273 _ACEOF
16274
16275 fi
16276
16277 echo "$as_me:$LINENO: checking for logl in -lm" >&5
16278 echo $ECHO_N "checking for logl in -lm... $ECHO_C" >&6
16279 if test "${ac_cv_lib_m_logl+set}" = set; then
16280   echo $ECHO_N "(cached) $ECHO_C" >&6
16281 else
16282   ac_check_lib_save_LIBS=$LIBS
16283 LIBS="-lm  $LIBS"
16284 if test x$gcc_no_link = xyes; then
16285   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16286 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16287    { (exit 1); exit 1; }; }
16288 fi
16289 cat >conftest.$ac_ext <<_ACEOF
16290 /* confdefs.h.  */
16291 _ACEOF
16292 cat confdefs.h >>conftest.$ac_ext
16293 cat >>conftest.$ac_ext <<_ACEOF
16294 /* end confdefs.h.  */
16295
16296 /* Override any gcc2 internal prototype to avoid an error.  */
16297 #ifdef __cplusplus
16298 extern "C"
16299 #endif
16300 /* We use char because int might match the return type of a gcc2
16301    builtin and then its argument prototype would still apply.  */
16302 char logl ();
16303 int
16304 main ()
16305 {
16306 logl ();
16307   ;
16308   return 0;
16309 }
16310 _ACEOF
16311 rm -f conftest.$ac_objext conftest$ac_exeext
16312 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16313   (eval $ac_link) 2>conftest.er1
16314   ac_status=$?
16315   grep -v '^ *+' conftest.er1 >conftest.err
16316   rm -f conftest.er1
16317   cat conftest.err >&5
16318   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16319   (exit $ac_status); } &&
16320          { ac_try='test -z "$ac_c_werror_flag"
16321                          || test ! -s conftest.err'
16322   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16323   (eval $ac_try) 2>&5
16324   ac_status=$?
16325   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16326   (exit $ac_status); }; } &&
16327          { ac_try='test -s conftest$ac_exeext'
16328   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16329   (eval $ac_try) 2>&5
16330   ac_status=$?
16331   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16332   (exit $ac_status); }; }; then
16333   ac_cv_lib_m_logl=yes
16334 else
16335   echo "$as_me: failed program was:" >&5
16336 sed 's/^/| /' conftest.$ac_ext >&5
16337
16338 ac_cv_lib_m_logl=no
16339 fi
16340 rm -f conftest.err conftest.$ac_objext \
16341       conftest$ac_exeext conftest.$ac_ext
16342 LIBS=$ac_check_lib_save_LIBS
16343 fi
16344 echo "$as_me:$LINENO: result: $ac_cv_lib_m_logl" >&5
16345 echo "${ECHO_T}$ac_cv_lib_m_logl" >&6
16346 if test $ac_cv_lib_m_logl = yes; then
16347
16348 cat >>confdefs.h <<\_ACEOF
16349 #define HAVE_LOGL 1
16350 _ACEOF
16351
16352 fi
16353
16354 echo "$as_me:$LINENO: checking for clogf in -lm" >&5
16355 echo $ECHO_N "checking for clogf in -lm... $ECHO_C" >&6
16356 if test "${ac_cv_lib_m_clogf+set}" = set; then
16357   echo $ECHO_N "(cached) $ECHO_C" >&6
16358 else
16359   ac_check_lib_save_LIBS=$LIBS
16360 LIBS="-lm  $LIBS"
16361 if test x$gcc_no_link = xyes; then
16362   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16363 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16364    { (exit 1); exit 1; }; }
16365 fi
16366 cat >conftest.$ac_ext <<_ACEOF
16367 /* confdefs.h.  */
16368 _ACEOF
16369 cat confdefs.h >>conftest.$ac_ext
16370 cat >>conftest.$ac_ext <<_ACEOF
16371 /* end confdefs.h.  */
16372
16373 /* Override any gcc2 internal prototype to avoid an error.  */
16374 #ifdef __cplusplus
16375 extern "C"
16376 #endif
16377 /* We use char because int might match the return type of a gcc2
16378    builtin and then its argument prototype would still apply.  */
16379 char clogf ();
16380 int
16381 main ()
16382 {
16383 clogf ();
16384   ;
16385   return 0;
16386 }
16387 _ACEOF
16388 rm -f conftest.$ac_objext conftest$ac_exeext
16389 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16390   (eval $ac_link) 2>conftest.er1
16391   ac_status=$?
16392   grep -v '^ *+' conftest.er1 >conftest.err
16393   rm -f conftest.er1
16394   cat conftest.err >&5
16395   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16396   (exit $ac_status); } &&
16397          { ac_try='test -z "$ac_c_werror_flag"
16398                          || test ! -s conftest.err'
16399   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16400   (eval $ac_try) 2>&5
16401   ac_status=$?
16402   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16403   (exit $ac_status); }; } &&
16404          { ac_try='test -s conftest$ac_exeext'
16405   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16406   (eval $ac_try) 2>&5
16407   ac_status=$?
16408   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16409   (exit $ac_status); }; }; then
16410   ac_cv_lib_m_clogf=yes
16411 else
16412   echo "$as_me: failed program was:" >&5
16413 sed 's/^/| /' conftest.$ac_ext >&5
16414
16415 ac_cv_lib_m_clogf=no
16416 fi
16417 rm -f conftest.err conftest.$ac_objext \
16418       conftest$ac_exeext conftest.$ac_ext
16419 LIBS=$ac_check_lib_save_LIBS
16420 fi
16421 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clogf" >&5
16422 echo "${ECHO_T}$ac_cv_lib_m_clogf" >&6
16423 if test $ac_cv_lib_m_clogf = yes; then
16424
16425 cat >>confdefs.h <<\_ACEOF
16426 #define HAVE_CLOGF 1
16427 _ACEOF
16428
16429 fi
16430
16431 echo "$as_me:$LINENO: checking for clog in -lm" >&5
16432 echo $ECHO_N "checking for clog in -lm... $ECHO_C" >&6
16433 if test "${ac_cv_lib_m_clog+set}" = set; then
16434   echo $ECHO_N "(cached) $ECHO_C" >&6
16435 else
16436   ac_check_lib_save_LIBS=$LIBS
16437 LIBS="-lm  $LIBS"
16438 if test x$gcc_no_link = xyes; then
16439   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16440 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16441    { (exit 1); exit 1; }; }
16442 fi
16443 cat >conftest.$ac_ext <<_ACEOF
16444 /* confdefs.h.  */
16445 _ACEOF
16446 cat confdefs.h >>conftest.$ac_ext
16447 cat >>conftest.$ac_ext <<_ACEOF
16448 /* end confdefs.h.  */
16449
16450 /* Override any gcc2 internal prototype to avoid an error.  */
16451 #ifdef __cplusplus
16452 extern "C"
16453 #endif
16454 /* We use char because int might match the return type of a gcc2
16455    builtin and then its argument prototype would still apply.  */
16456 char clog ();
16457 int
16458 main ()
16459 {
16460 clog ();
16461   ;
16462   return 0;
16463 }
16464 _ACEOF
16465 rm -f conftest.$ac_objext conftest$ac_exeext
16466 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16467   (eval $ac_link) 2>conftest.er1
16468   ac_status=$?
16469   grep -v '^ *+' conftest.er1 >conftest.err
16470   rm -f conftest.er1
16471   cat conftest.err >&5
16472   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16473   (exit $ac_status); } &&
16474          { ac_try='test -z "$ac_c_werror_flag"
16475                          || test ! -s conftest.err'
16476   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16477   (eval $ac_try) 2>&5
16478   ac_status=$?
16479   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16480   (exit $ac_status); }; } &&
16481          { ac_try='test -s conftest$ac_exeext'
16482   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16483   (eval $ac_try) 2>&5
16484   ac_status=$?
16485   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16486   (exit $ac_status); }; }; then
16487   ac_cv_lib_m_clog=yes
16488 else
16489   echo "$as_me: failed program was:" >&5
16490 sed 's/^/| /' conftest.$ac_ext >&5
16491
16492 ac_cv_lib_m_clog=no
16493 fi
16494 rm -f conftest.err conftest.$ac_objext \
16495       conftest$ac_exeext conftest.$ac_ext
16496 LIBS=$ac_check_lib_save_LIBS
16497 fi
16498 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog" >&5
16499 echo "${ECHO_T}$ac_cv_lib_m_clog" >&6
16500 if test $ac_cv_lib_m_clog = yes; then
16501
16502 cat >>confdefs.h <<\_ACEOF
16503 #define HAVE_CLOG 1
16504 _ACEOF
16505
16506 fi
16507
16508 echo "$as_me:$LINENO: checking for clogl in -lm" >&5
16509 echo $ECHO_N "checking for clogl in -lm... $ECHO_C" >&6
16510 if test "${ac_cv_lib_m_clogl+set}" = set; then
16511   echo $ECHO_N "(cached) $ECHO_C" >&6
16512 else
16513   ac_check_lib_save_LIBS=$LIBS
16514 LIBS="-lm  $LIBS"
16515 if test x$gcc_no_link = xyes; then
16516   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16517 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16518    { (exit 1); exit 1; }; }
16519 fi
16520 cat >conftest.$ac_ext <<_ACEOF
16521 /* confdefs.h.  */
16522 _ACEOF
16523 cat confdefs.h >>conftest.$ac_ext
16524 cat >>conftest.$ac_ext <<_ACEOF
16525 /* end confdefs.h.  */
16526
16527 /* Override any gcc2 internal prototype to avoid an error.  */
16528 #ifdef __cplusplus
16529 extern "C"
16530 #endif
16531 /* We use char because int might match the return type of a gcc2
16532    builtin and then its argument prototype would still apply.  */
16533 char clogl ();
16534 int
16535 main ()
16536 {
16537 clogl ();
16538   ;
16539   return 0;
16540 }
16541 _ACEOF
16542 rm -f conftest.$ac_objext conftest$ac_exeext
16543 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16544   (eval $ac_link) 2>conftest.er1
16545   ac_status=$?
16546   grep -v '^ *+' conftest.er1 >conftest.err
16547   rm -f conftest.er1
16548   cat conftest.err >&5
16549   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16550   (exit $ac_status); } &&
16551          { ac_try='test -z "$ac_c_werror_flag"
16552                          || test ! -s conftest.err'
16553   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16554   (eval $ac_try) 2>&5
16555   ac_status=$?
16556   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16557   (exit $ac_status); }; } &&
16558          { ac_try='test -s conftest$ac_exeext'
16559   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16560   (eval $ac_try) 2>&5
16561   ac_status=$?
16562   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16563   (exit $ac_status); }; }; then
16564   ac_cv_lib_m_clogl=yes
16565 else
16566   echo "$as_me: failed program was:" >&5
16567 sed 's/^/| /' conftest.$ac_ext >&5
16568
16569 ac_cv_lib_m_clogl=no
16570 fi
16571 rm -f conftest.err conftest.$ac_objext \
16572       conftest$ac_exeext conftest.$ac_ext
16573 LIBS=$ac_check_lib_save_LIBS
16574 fi
16575 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clogl" >&5
16576 echo "${ECHO_T}$ac_cv_lib_m_clogl" >&6
16577 if test $ac_cv_lib_m_clogl = yes; then
16578
16579 cat >>confdefs.h <<\_ACEOF
16580 #define HAVE_CLOGL 1
16581 _ACEOF
16582
16583 fi
16584
16585 echo "$as_me:$LINENO: checking for log10f in -lm" >&5
16586 echo $ECHO_N "checking for log10f in -lm... $ECHO_C" >&6
16587 if test "${ac_cv_lib_m_log10f+set}" = set; then
16588   echo $ECHO_N "(cached) $ECHO_C" >&6
16589 else
16590   ac_check_lib_save_LIBS=$LIBS
16591 LIBS="-lm  $LIBS"
16592 if test x$gcc_no_link = xyes; then
16593   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16594 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16595    { (exit 1); exit 1; }; }
16596 fi
16597 cat >conftest.$ac_ext <<_ACEOF
16598 /* confdefs.h.  */
16599 _ACEOF
16600 cat confdefs.h >>conftest.$ac_ext
16601 cat >>conftest.$ac_ext <<_ACEOF
16602 /* end confdefs.h.  */
16603
16604 /* Override any gcc2 internal prototype to avoid an error.  */
16605 #ifdef __cplusplus
16606 extern "C"
16607 #endif
16608 /* We use char because int might match the return type of a gcc2
16609    builtin and then its argument prototype would still apply.  */
16610 char log10f ();
16611 int
16612 main ()
16613 {
16614 log10f ();
16615   ;
16616   return 0;
16617 }
16618 _ACEOF
16619 rm -f conftest.$ac_objext conftest$ac_exeext
16620 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16621   (eval $ac_link) 2>conftest.er1
16622   ac_status=$?
16623   grep -v '^ *+' conftest.er1 >conftest.err
16624   rm -f conftest.er1
16625   cat conftest.err >&5
16626   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16627   (exit $ac_status); } &&
16628          { ac_try='test -z "$ac_c_werror_flag"
16629                          || test ! -s conftest.err'
16630   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16631   (eval $ac_try) 2>&5
16632   ac_status=$?
16633   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16634   (exit $ac_status); }; } &&
16635          { ac_try='test -s conftest$ac_exeext'
16636   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16637   (eval $ac_try) 2>&5
16638   ac_status=$?
16639   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16640   (exit $ac_status); }; }; then
16641   ac_cv_lib_m_log10f=yes
16642 else
16643   echo "$as_me: failed program was:" >&5
16644 sed 's/^/| /' conftest.$ac_ext >&5
16645
16646 ac_cv_lib_m_log10f=no
16647 fi
16648 rm -f conftest.err conftest.$ac_objext \
16649       conftest$ac_exeext conftest.$ac_ext
16650 LIBS=$ac_check_lib_save_LIBS
16651 fi
16652 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10f" >&5
16653 echo "${ECHO_T}$ac_cv_lib_m_log10f" >&6
16654 if test $ac_cv_lib_m_log10f = yes; then
16655
16656 cat >>confdefs.h <<\_ACEOF
16657 #define HAVE_LOG10F 1
16658 _ACEOF
16659
16660 fi
16661
16662 echo "$as_me:$LINENO: checking for log10 in -lm" >&5
16663 echo $ECHO_N "checking for log10 in -lm... $ECHO_C" >&6
16664 if test "${ac_cv_lib_m_log10+set}" = set; then
16665   echo $ECHO_N "(cached) $ECHO_C" >&6
16666 else
16667   ac_check_lib_save_LIBS=$LIBS
16668 LIBS="-lm  $LIBS"
16669 if test x$gcc_no_link = xyes; then
16670   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16671 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16672    { (exit 1); exit 1; }; }
16673 fi
16674 cat >conftest.$ac_ext <<_ACEOF
16675 /* confdefs.h.  */
16676 _ACEOF
16677 cat confdefs.h >>conftest.$ac_ext
16678 cat >>conftest.$ac_ext <<_ACEOF
16679 /* end confdefs.h.  */
16680
16681 /* Override any gcc2 internal prototype to avoid an error.  */
16682 #ifdef __cplusplus
16683 extern "C"
16684 #endif
16685 /* We use char because int might match the return type of a gcc2
16686    builtin and then its argument prototype would still apply.  */
16687 char log10 ();
16688 int
16689 main ()
16690 {
16691 log10 ();
16692   ;
16693   return 0;
16694 }
16695 _ACEOF
16696 rm -f conftest.$ac_objext conftest$ac_exeext
16697 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16698   (eval $ac_link) 2>conftest.er1
16699   ac_status=$?
16700   grep -v '^ *+' conftest.er1 >conftest.err
16701   rm -f conftest.er1
16702   cat conftest.err >&5
16703   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16704   (exit $ac_status); } &&
16705          { ac_try='test -z "$ac_c_werror_flag"
16706                          || test ! -s conftest.err'
16707   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16708   (eval $ac_try) 2>&5
16709   ac_status=$?
16710   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16711   (exit $ac_status); }; } &&
16712          { ac_try='test -s conftest$ac_exeext'
16713   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16714   (eval $ac_try) 2>&5
16715   ac_status=$?
16716   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16717   (exit $ac_status); }; }; then
16718   ac_cv_lib_m_log10=yes
16719 else
16720   echo "$as_me: failed program was:" >&5
16721 sed 's/^/| /' conftest.$ac_ext >&5
16722
16723 ac_cv_lib_m_log10=no
16724 fi
16725 rm -f conftest.err conftest.$ac_objext \
16726       conftest$ac_exeext conftest.$ac_ext
16727 LIBS=$ac_check_lib_save_LIBS
16728 fi
16729 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10" >&5
16730 echo "${ECHO_T}$ac_cv_lib_m_log10" >&6
16731 if test $ac_cv_lib_m_log10 = yes; then
16732
16733 cat >>confdefs.h <<\_ACEOF
16734 #define HAVE_LOG10 1
16735 _ACEOF
16736
16737 fi
16738
16739 echo "$as_me:$LINENO: checking for log10l in -lm" >&5
16740 echo $ECHO_N "checking for log10l in -lm... $ECHO_C" >&6
16741 if test "${ac_cv_lib_m_log10l+set}" = set; then
16742   echo $ECHO_N "(cached) $ECHO_C" >&6
16743 else
16744   ac_check_lib_save_LIBS=$LIBS
16745 LIBS="-lm  $LIBS"
16746 if test x$gcc_no_link = xyes; then
16747   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16748 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16749    { (exit 1); exit 1; }; }
16750 fi
16751 cat >conftest.$ac_ext <<_ACEOF
16752 /* confdefs.h.  */
16753 _ACEOF
16754 cat confdefs.h >>conftest.$ac_ext
16755 cat >>conftest.$ac_ext <<_ACEOF
16756 /* end confdefs.h.  */
16757
16758 /* Override any gcc2 internal prototype to avoid an error.  */
16759 #ifdef __cplusplus
16760 extern "C"
16761 #endif
16762 /* We use char because int might match the return type of a gcc2
16763    builtin and then its argument prototype would still apply.  */
16764 char log10l ();
16765 int
16766 main ()
16767 {
16768 log10l ();
16769   ;
16770   return 0;
16771 }
16772 _ACEOF
16773 rm -f conftest.$ac_objext conftest$ac_exeext
16774 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16775   (eval $ac_link) 2>conftest.er1
16776   ac_status=$?
16777   grep -v '^ *+' conftest.er1 >conftest.err
16778   rm -f conftest.er1
16779   cat conftest.err >&5
16780   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16781   (exit $ac_status); } &&
16782          { ac_try='test -z "$ac_c_werror_flag"
16783                          || test ! -s conftest.err'
16784   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16785   (eval $ac_try) 2>&5
16786   ac_status=$?
16787   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16788   (exit $ac_status); }; } &&
16789          { ac_try='test -s conftest$ac_exeext'
16790   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16791   (eval $ac_try) 2>&5
16792   ac_status=$?
16793   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16794   (exit $ac_status); }; }; then
16795   ac_cv_lib_m_log10l=yes
16796 else
16797   echo "$as_me: failed program was:" >&5
16798 sed 's/^/| /' conftest.$ac_ext >&5
16799
16800 ac_cv_lib_m_log10l=no
16801 fi
16802 rm -f conftest.err conftest.$ac_objext \
16803       conftest$ac_exeext conftest.$ac_ext
16804 LIBS=$ac_check_lib_save_LIBS
16805 fi
16806 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10l" >&5
16807 echo "${ECHO_T}$ac_cv_lib_m_log10l" >&6
16808 if test $ac_cv_lib_m_log10l = yes; then
16809
16810 cat >>confdefs.h <<\_ACEOF
16811 #define HAVE_LOG10L 1
16812 _ACEOF
16813
16814 fi
16815
16816 echo "$as_me:$LINENO: checking for clog10f in -lm" >&5
16817 echo $ECHO_N "checking for clog10f in -lm... $ECHO_C" >&6
16818 if test "${ac_cv_lib_m_clog10f+set}" = set; then
16819   echo $ECHO_N "(cached) $ECHO_C" >&6
16820 else
16821   ac_check_lib_save_LIBS=$LIBS
16822 LIBS="-lm  $LIBS"
16823 if test x$gcc_no_link = xyes; then
16824   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16825 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16826    { (exit 1); exit 1; }; }
16827 fi
16828 cat >conftest.$ac_ext <<_ACEOF
16829 /* confdefs.h.  */
16830 _ACEOF
16831 cat confdefs.h >>conftest.$ac_ext
16832 cat >>conftest.$ac_ext <<_ACEOF
16833 /* end confdefs.h.  */
16834
16835 /* Override any gcc2 internal prototype to avoid an error.  */
16836 #ifdef __cplusplus
16837 extern "C"
16838 #endif
16839 /* We use char because int might match the return type of a gcc2
16840    builtin and then its argument prototype would still apply.  */
16841 char clog10f ();
16842 int
16843 main ()
16844 {
16845 clog10f ();
16846   ;
16847   return 0;
16848 }
16849 _ACEOF
16850 rm -f conftest.$ac_objext conftest$ac_exeext
16851 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16852   (eval $ac_link) 2>conftest.er1
16853   ac_status=$?
16854   grep -v '^ *+' conftest.er1 >conftest.err
16855   rm -f conftest.er1
16856   cat conftest.err >&5
16857   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16858   (exit $ac_status); } &&
16859          { ac_try='test -z "$ac_c_werror_flag"
16860                          || test ! -s conftest.err'
16861   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16862   (eval $ac_try) 2>&5
16863   ac_status=$?
16864   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16865   (exit $ac_status); }; } &&
16866          { ac_try='test -s conftest$ac_exeext'
16867   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16868   (eval $ac_try) 2>&5
16869   ac_status=$?
16870   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16871   (exit $ac_status); }; }; then
16872   ac_cv_lib_m_clog10f=yes
16873 else
16874   echo "$as_me: failed program was:" >&5
16875 sed 's/^/| /' conftest.$ac_ext >&5
16876
16877 ac_cv_lib_m_clog10f=no
16878 fi
16879 rm -f conftest.err conftest.$ac_objext \
16880       conftest$ac_exeext conftest.$ac_ext
16881 LIBS=$ac_check_lib_save_LIBS
16882 fi
16883 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10f" >&5
16884 echo "${ECHO_T}$ac_cv_lib_m_clog10f" >&6
16885 if test $ac_cv_lib_m_clog10f = yes; then
16886
16887 cat >>confdefs.h <<\_ACEOF
16888 #define HAVE_CLOG10F 1
16889 _ACEOF
16890
16891 fi
16892
16893 echo "$as_me:$LINENO: checking for clog10 in -lm" >&5
16894 echo $ECHO_N "checking for clog10 in -lm... $ECHO_C" >&6
16895 if test "${ac_cv_lib_m_clog10+set}" = set; then
16896   echo $ECHO_N "(cached) $ECHO_C" >&6
16897 else
16898   ac_check_lib_save_LIBS=$LIBS
16899 LIBS="-lm  $LIBS"
16900 if test x$gcc_no_link = xyes; then
16901   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16902 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16903    { (exit 1); exit 1; }; }
16904 fi
16905 cat >conftest.$ac_ext <<_ACEOF
16906 /* confdefs.h.  */
16907 _ACEOF
16908 cat confdefs.h >>conftest.$ac_ext
16909 cat >>conftest.$ac_ext <<_ACEOF
16910 /* end confdefs.h.  */
16911
16912 /* Override any gcc2 internal prototype to avoid an error.  */
16913 #ifdef __cplusplus
16914 extern "C"
16915 #endif
16916 /* We use char because int might match the return type of a gcc2
16917    builtin and then its argument prototype would still apply.  */
16918 char clog10 ();
16919 int
16920 main ()
16921 {
16922 clog10 ();
16923   ;
16924   return 0;
16925 }
16926 _ACEOF
16927 rm -f conftest.$ac_objext conftest$ac_exeext
16928 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16929   (eval $ac_link) 2>conftest.er1
16930   ac_status=$?
16931   grep -v '^ *+' conftest.er1 >conftest.err
16932   rm -f conftest.er1
16933   cat conftest.err >&5
16934   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16935   (exit $ac_status); } &&
16936          { ac_try='test -z "$ac_c_werror_flag"
16937                          || test ! -s conftest.err'
16938   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16939   (eval $ac_try) 2>&5
16940   ac_status=$?
16941   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16942   (exit $ac_status); }; } &&
16943          { ac_try='test -s conftest$ac_exeext'
16944   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16945   (eval $ac_try) 2>&5
16946   ac_status=$?
16947   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16948   (exit $ac_status); }; }; then
16949   ac_cv_lib_m_clog10=yes
16950 else
16951   echo "$as_me: failed program was:" >&5
16952 sed 's/^/| /' conftest.$ac_ext >&5
16953
16954 ac_cv_lib_m_clog10=no
16955 fi
16956 rm -f conftest.err conftest.$ac_objext \
16957       conftest$ac_exeext conftest.$ac_ext
16958 LIBS=$ac_check_lib_save_LIBS
16959 fi
16960 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10" >&5
16961 echo "${ECHO_T}$ac_cv_lib_m_clog10" >&6
16962 if test $ac_cv_lib_m_clog10 = yes; then
16963
16964 cat >>confdefs.h <<\_ACEOF
16965 #define HAVE_CLOG10 1
16966 _ACEOF
16967
16968 fi
16969
16970 echo "$as_me:$LINENO: checking for clog10l in -lm" >&5
16971 echo $ECHO_N "checking for clog10l in -lm... $ECHO_C" >&6
16972 if test "${ac_cv_lib_m_clog10l+set}" = set; then
16973   echo $ECHO_N "(cached) $ECHO_C" >&6
16974 else
16975   ac_check_lib_save_LIBS=$LIBS
16976 LIBS="-lm  $LIBS"
16977 if test x$gcc_no_link = xyes; then
16978   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16979 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16980    { (exit 1); exit 1; }; }
16981 fi
16982 cat >conftest.$ac_ext <<_ACEOF
16983 /* confdefs.h.  */
16984 _ACEOF
16985 cat confdefs.h >>conftest.$ac_ext
16986 cat >>conftest.$ac_ext <<_ACEOF
16987 /* end confdefs.h.  */
16988
16989 /* Override any gcc2 internal prototype to avoid an error.  */
16990 #ifdef __cplusplus
16991 extern "C"
16992 #endif
16993 /* We use char because int might match the return type of a gcc2
16994    builtin and then its argument prototype would still apply.  */
16995 char clog10l ();
16996 int
16997 main ()
16998 {
16999 clog10l ();
17000   ;
17001   return 0;
17002 }
17003 _ACEOF
17004 rm -f conftest.$ac_objext conftest$ac_exeext
17005 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17006   (eval $ac_link) 2>conftest.er1
17007   ac_status=$?
17008   grep -v '^ *+' conftest.er1 >conftest.err
17009   rm -f conftest.er1
17010   cat conftest.err >&5
17011   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17012   (exit $ac_status); } &&
17013          { ac_try='test -z "$ac_c_werror_flag"
17014                          || test ! -s conftest.err'
17015   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17016   (eval $ac_try) 2>&5
17017   ac_status=$?
17018   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17019   (exit $ac_status); }; } &&
17020          { ac_try='test -s conftest$ac_exeext'
17021   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17022   (eval $ac_try) 2>&5
17023   ac_status=$?
17024   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17025   (exit $ac_status); }; }; then
17026   ac_cv_lib_m_clog10l=yes
17027 else
17028   echo "$as_me: failed program was:" >&5
17029 sed 's/^/| /' conftest.$ac_ext >&5
17030
17031 ac_cv_lib_m_clog10l=no
17032 fi
17033 rm -f conftest.err conftest.$ac_objext \
17034       conftest$ac_exeext conftest.$ac_ext
17035 LIBS=$ac_check_lib_save_LIBS
17036 fi
17037 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10l" >&5
17038 echo "${ECHO_T}$ac_cv_lib_m_clog10l" >&6
17039 if test $ac_cv_lib_m_clog10l = yes; then
17040
17041 cat >>confdefs.h <<\_ACEOF
17042 #define HAVE_CLOG10L 1
17043 _ACEOF
17044
17045 fi
17046
17047 echo "$as_me:$LINENO: checking for nextafterf in -lm" >&5
17048 echo $ECHO_N "checking for nextafterf in -lm... $ECHO_C" >&6
17049 if test "${ac_cv_lib_m_nextafterf+set}" = set; then
17050   echo $ECHO_N "(cached) $ECHO_C" >&6
17051 else
17052   ac_check_lib_save_LIBS=$LIBS
17053 LIBS="-lm  $LIBS"
17054 if test x$gcc_no_link = xyes; then
17055   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17056 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17057    { (exit 1); exit 1; }; }
17058 fi
17059 cat >conftest.$ac_ext <<_ACEOF
17060 /* confdefs.h.  */
17061 _ACEOF
17062 cat confdefs.h >>conftest.$ac_ext
17063 cat >>conftest.$ac_ext <<_ACEOF
17064 /* end confdefs.h.  */
17065
17066 /* Override any gcc2 internal prototype to avoid an error.  */
17067 #ifdef __cplusplus
17068 extern "C"
17069 #endif
17070 /* We use char because int might match the return type of a gcc2
17071    builtin and then its argument prototype would still apply.  */
17072 char nextafterf ();
17073 int
17074 main ()
17075 {
17076 nextafterf ();
17077   ;
17078   return 0;
17079 }
17080 _ACEOF
17081 rm -f conftest.$ac_objext conftest$ac_exeext
17082 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17083   (eval $ac_link) 2>conftest.er1
17084   ac_status=$?
17085   grep -v '^ *+' conftest.er1 >conftest.err
17086   rm -f conftest.er1
17087   cat conftest.err >&5
17088   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17089   (exit $ac_status); } &&
17090          { ac_try='test -z "$ac_c_werror_flag"
17091                          || test ! -s conftest.err'
17092   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17093   (eval $ac_try) 2>&5
17094   ac_status=$?
17095   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17096   (exit $ac_status); }; } &&
17097          { ac_try='test -s conftest$ac_exeext'
17098   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17099   (eval $ac_try) 2>&5
17100   ac_status=$?
17101   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17102   (exit $ac_status); }; }; then
17103   ac_cv_lib_m_nextafterf=yes
17104 else
17105   echo "$as_me: failed program was:" >&5
17106 sed 's/^/| /' conftest.$ac_ext >&5
17107
17108 ac_cv_lib_m_nextafterf=no
17109 fi
17110 rm -f conftest.err conftest.$ac_objext \
17111       conftest$ac_exeext conftest.$ac_ext
17112 LIBS=$ac_check_lib_save_LIBS
17113 fi
17114 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafterf" >&5
17115 echo "${ECHO_T}$ac_cv_lib_m_nextafterf" >&6
17116 if test $ac_cv_lib_m_nextafterf = yes; then
17117
17118 cat >>confdefs.h <<\_ACEOF
17119 #define HAVE_NEXTAFTERF 1
17120 _ACEOF
17121
17122 fi
17123
17124 echo "$as_me:$LINENO: checking for nextafter in -lm" >&5
17125 echo $ECHO_N "checking for nextafter in -lm... $ECHO_C" >&6
17126 if test "${ac_cv_lib_m_nextafter+set}" = set; then
17127   echo $ECHO_N "(cached) $ECHO_C" >&6
17128 else
17129   ac_check_lib_save_LIBS=$LIBS
17130 LIBS="-lm  $LIBS"
17131 if test x$gcc_no_link = xyes; then
17132   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17133 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17134    { (exit 1); exit 1; }; }
17135 fi
17136 cat >conftest.$ac_ext <<_ACEOF
17137 /* confdefs.h.  */
17138 _ACEOF
17139 cat confdefs.h >>conftest.$ac_ext
17140 cat >>conftest.$ac_ext <<_ACEOF
17141 /* end confdefs.h.  */
17142
17143 /* Override any gcc2 internal prototype to avoid an error.  */
17144 #ifdef __cplusplus
17145 extern "C"
17146 #endif
17147 /* We use char because int might match the return type of a gcc2
17148    builtin and then its argument prototype would still apply.  */
17149 char nextafter ();
17150 int
17151 main ()
17152 {
17153 nextafter ();
17154   ;
17155   return 0;
17156 }
17157 _ACEOF
17158 rm -f conftest.$ac_objext conftest$ac_exeext
17159 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17160   (eval $ac_link) 2>conftest.er1
17161   ac_status=$?
17162   grep -v '^ *+' conftest.er1 >conftest.err
17163   rm -f conftest.er1
17164   cat conftest.err >&5
17165   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17166   (exit $ac_status); } &&
17167          { ac_try='test -z "$ac_c_werror_flag"
17168                          || test ! -s conftest.err'
17169   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17170   (eval $ac_try) 2>&5
17171   ac_status=$?
17172   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17173   (exit $ac_status); }; } &&
17174          { ac_try='test -s conftest$ac_exeext'
17175   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17176   (eval $ac_try) 2>&5
17177   ac_status=$?
17178   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17179   (exit $ac_status); }; }; then
17180   ac_cv_lib_m_nextafter=yes
17181 else
17182   echo "$as_me: failed program was:" >&5
17183 sed 's/^/| /' conftest.$ac_ext >&5
17184
17185 ac_cv_lib_m_nextafter=no
17186 fi
17187 rm -f conftest.err conftest.$ac_objext \
17188       conftest$ac_exeext conftest.$ac_ext
17189 LIBS=$ac_check_lib_save_LIBS
17190 fi
17191 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafter" >&5
17192 echo "${ECHO_T}$ac_cv_lib_m_nextafter" >&6
17193 if test $ac_cv_lib_m_nextafter = yes; then
17194
17195 cat >>confdefs.h <<\_ACEOF
17196 #define HAVE_NEXTAFTER 1
17197 _ACEOF
17198
17199 fi
17200
17201 echo "$as_me:$LINENO: checking for nextafterl in -lm" >&5
17202 echo $ECHO_N "checking for nextafterl in -lm... $ECHO_C" >&6
17203 if test "${ac_cv_lib_m_nextafterl+set}" = set; then
17204   echo $ECHO_N "(cached) $ECHO_C" >&6
17205 else
17206   ac_check_lib_save_LIBS=$LIBS
17207 LIBS="-lm  $LIBS"
17208 if test x$gcc_no_link = xyes; then
17209   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17210 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17211    { (exit 1); exit 1; }; }
17212 fi
17213 cat >conftest.$ac_ext <<_ACEOF
17214 /* confdefs.h.  */
17215 _ACEOF
17216 cat confdefs.h >>conftest.$ac_ext
17217 cat >>conftest.$ac_ext <<_ACEOF
17218 /* end confdefs.h.  */
17219
17220 /* Override any gcc2 internal prototype to avoid an error.  */
17221 #ifdef __cplusplus
17222 extern "C"
17223 #endif
17224 /* We use char because int might match the return type of a gcc2
17225    builtin and then its argument prototype would still apply.  */
17226 char nextafterl ();
17227 int
17228 main ()
17229 {
17230 nextafterl ();
17231   ;
17232   return 0;
17233 }
17234 _ACEOF
17235 rm -f conftest.$ac_objext conftest$ac_exeext
17236 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17237   (eval $ac_link) 2>conftest.er1
17238   ac_status=$?
17239   grep -v '^ *+' conftest.er1 >conftest.err
17240   rm -f conftest.er1
17241   cat conftest.err >&5
17242   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17243   (exit $ac_status); } &&
17244          { ac_try='test -z "$ac_c_werror_flag"
17245                          || test ! -s conftest.err'
17246   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17247   (eval $ac_try) 2>&5
17248   ac_status=$?
17249   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17250   (exit $ac_status); }; } &&
17251          { ac_try='test -s conftest$ac_exeext'
17252   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17253   (eval $ac_try) 2>&5
17254   ac_status=$?
17255   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17256   (exit $ac_status); }; }; then
17257   ac_cv_lib_m_nextafterl=yes
17258 else
17259   echo "$as_me: failed program was:" >&5
17260 sed 's/^/| /' conftest.$ac_ext >&5
17261
17262 ac_cv_lib_m_nextafterl=no
17263 fi
17264 rm -f conftest.err conftest.$ac_objext \
17265       conftest$ac_exeext conftest.$ac_ext
17266 LIBS=$ac_check_lib_save_LIBS
17267 fi
17268 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafterl" >&5
17269 echo "${ECHO_T}$ac_cv_lib_m_nextafterl" >&6
17270 if test $ac_cv_lib_m_nextafterl = yes; then
17271
17272 cat >>confdefs.h <<\_ACEOF
17273 #define HAVE_NEXTAFTERL 1
17274 _ACEOF
17275
17276 fi
17277
17278 echo "$as_me:$LINENO: checking for powf in -lm" >&5
17279 echo $ECHO_N "checking for powf in -lm... $ECHO_C" >&6
17280 if test "${ac_cv_lib_m_powf+set}" = set; then
17281   echo $ECHO_N "(cached) $ECHO_C" >&6
17282 else
17283   ac_check_lib_save_LIBS=$LIBS
17284 LIBS="-lm  $LIBS"
17285 if test x$gcc_no_link = xyes; then
17286   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17287 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17288    { (exit 1); exit 1; }; }
17289 fi
17290 cat >conftest.$ac_ext <<_ACEOF
17291 /* confdefs.h.  */
17292 _ACEOF
17293 cat confdefs.h >>conftest.$ac_ext
17294 cat >>conftest.$ac_ext <<_ACEOF
17295 /* end confdefs.h.  */
17296
17297 /* Override any gcc2 internal prototype to avoid an error.  */
17298 #ifdef __cplusplus
17299 extern "C"
17300 #endif
17301 /* We use char because int might match the return type of a gcc2
17302    builtin and then its argument prototype would still apply.  */
17303 char powf ();
17304 int
17305 main ()
17306 {
17307 powf ();
17308   ;
17309   return 0;
17310 }
17311 _ACEOF
17312 rm -f conftest.$ac_objext conftest$ac_exeext
17313 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17314   (eval $ac_link) 2>conftest.er1
17315   ac_status=$?
17316   grep -v '^ *+' conftest.er1 >conftest.err
17317   rm -f conftest.er1
17318   cat conftest.err >&5
17319   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17320   (exit $ac_status); } &&
17321          { ac_try='test -z "$ac_c_werror_flag"
17322                          || test ! -s conftest.err'
17323   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17324   (eval $ac_try) 2>&5
17325   ac_status=$?
17326   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17327   (exit $ac_status); }; } &&
17328          { ac_try='test -s conftest$ac_exeext'
17329   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17330   (eval $ac_try) 2>&5
17331   ac_status=$?
17332   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17333   (exit $ac_status); }; }; then
17334   ac_cv_lib_m_powf=yes
17335 else
17336   echo "$as_me: failed program was:" >&5
17337 sed 's/^/| /' conftest.$ac_ext >&5
17338
17339 ac_cv_lib_m_powf=no
17340 fi
17341 rm -f conftest.err conftest.$ac_objext \
17342       conftest$ac_exeext conftest.$ac_ext
17343 LIBS=$ac_check_lib_save_LIBS
17344 fi
17345 echo "$as_me:$LINENO: result: $ac_cv_lib_m_powf" >&5
17346 echo "${ECHO_T}$ac_cv_lib_m_powf" >&6
17347 if test $ac_cv_lib_m_powf = yes; then
17348
17349 cat >>confdefs.h <<\_ACEOF
17350 #define HAVE_POWF 1
17351 _ACEOF
17352
17353 fi
17354
17355 echo "$as_me:$LINENO: checking for pow in -lm" >&5
17356 echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
17357 if test "${ac_cv_lib_m_pow+set}" = set; then
17358   echo $ECHO_N "(cached) $ECHO_C" >&6
17359 else
17360   ac_check_lib_save_LIBS=$LIBS
17361 LIBS="-lm  $LIBS"
17362 if test x$gcc_no_link = xyes; then
17363   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17364 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17365    { (exit 1); exit 1; }; }
17366 fi
17367 cat >conftest.$ac_ext <<_ACEOF
17368 /* confdefs.h.  */
17369 _ACEOF
17370 cat confdefs.h >>conftest.$ac_ext
17371 cat >>conftest.$ac_ext <<_ACEOF
17372 /* end confdefs.h.  */
17373
17374 /* Override any gcc2 internal prototype to avoid an error.  */
17375 #ifdef __cplusplus
17376 extern "C"
17377 #endif
17378 /* We use char because int might match the return type of a gcc2
17379    builtin and then its argument prototype would still apply.  */
17380 char pow ();
17381 int
17382 main ()
17383 {
17384 pow ();
17385   ;
17386   return 0;
17387 }
17388 _ACEOF
17389 rm -f conftest.$ac_objext conftest$ac_exeext
17390 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17391   (eval $ac_link) 2>conftest.er1
17392   ac_status=$?
17393   grep -v '^ *+' conftest.er1 >conftest.err
17394   rm -f conftest.er1
17395   cat conftest.err >&5
17396   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17397   (exit $ac_status); } &&
17398          { ac_try='test -z "$ac_c_werror_flag"
17399                          || test ! -s conftest.err'
17400   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17401   (eval $ac_try) 2>&5
17402   ac_status=$?
17403   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17404   (exit $ac_status); }; } &&
17405          { ac_try='test -s conftest$ac_exeext'
17406   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17407   (eval $ac_try) 2>&5
17408   ac_status=$?
17409   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17410   (exit $ac_status); }; }; then
17411   ac_cv_lib_m_pow=yes
17412 else
17413   echo "$as_me: failed program was:" >&5
17414 sed 's/^/| /' conftest.$ac_ext >&5
17415
17416 ac_cv_lib_m_pow=no
17417 fi
17418 rm -f conftest.err conftest.$ac_objext \
17419       conftest$ac_exeext conftest.$ac_ext
17420 LIBS=$ac_check_lib_save_LIBS
17421 fi
17422 echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
17423 echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
17424 if test $ac_cv_lib_m_pow = yes; then
17425
17426 cat >>confdefs.h <<\_ACEOF
17427 #define HAVE_POW 1
17428 _ACEOF
17429
17430 fi
17431
17432 echo "$as_me:$LINENO: checking for powl in -lm" >&5
17433 echo $ECHO_N "checking for powl in -lm... $ECHO_C" >&6
17434 if test "${ac_cv_lib_m_powl+set}" = set; then
17435   echo $ECHO_N "(cached) $ECHO_C" >&6
17436 else
17437   ac_check_lib_save_LIBS=$LIBS
17438 LIBS="-lm  $LIBS"
17439 if test x$gcc_no_link = xyes; then
17440   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17441 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17442    { (exit 1); exit 1; }; }
17443 fi
17444 cat >conftest.$ac_ext <<_ACEOF
17445 /* confdefs.h.  */
17446 _ACEOF
17447 cat confdefs.h >>conftest.$ac_ext
17448 cat >>conftest.$ac_ext <<_ACEOF
17449 /* end confdefs.h.  */
17450
17451 /* Override any gcc2 internal prototype to avoid an error.  */
17452 #ifdef __cplusplus
17453 extern "C"
17454 #endif
17455 /* We use char because int might match the return type of a gcc2
17456    builtin and then its argument prototype would still apply.  */
17457 char powl ();
17458 int
17459 main ()
17460 {
17461 powl ();
17462   ;
17463   return 0;
17464 }
17465 _ACEOF
17466 rm -f conftest.$ac_objext conftest$ac_exeext
17467 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17468   (eval $ac_link) 2>conftest.er1
17469   ac_status=$?
17470   grep -v '^ *+' conftest.er1 >conftest.err
17471   rm -f conftest.er1
17472   cat conftest.err >&5
17473   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17474   (exit $ac_status); } &&
17475          { ac_try='test -z "$ac_c_werror_flag"
17476                          || test ! -s conftest.err'
17477   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17478   (eval $ac_try) 2>&5
17479   ac_status=$?
17480   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17481   (exit $ac_status); }; } &&
17482          { ac_try='test -s conftest$ac_exeext'
17483   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17484   (eval $ac_try) 2>&5
17485   ac_status=$?
17486   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17487   (exit $ac_status); }; }; then
17488   ac_cv_lib_m_powl=yes
17489 else
17490   echo "$as_me: failed program was:" >&5
17491 sed 's/^/| /' conftest.$ac_ext >&5
17492
17493 ac_cv_lib_m_powl=no
17494 fi
17495 rm -f conftest.err conftest.$ac_objext \
17496       conftest$ac_exeext conftest.$ac_ext
17497 LIBS=$ac_check_lib_save_LIBS
17498 fi
17499 echo "$as_me:$LINENO: result: $ac_cv_lib_m_powl" >&5
17500 echo "${ECHO_T}$ac_cv_lib_m_powl" >&6
17501 if test $ac_cv_lib_m_powl = yes; then
17502
17503 cat >>confdefs.h <<\_ACEOF
17504 #define HAVE_POWL 1
17505 _ACEOF
17506
17507 fi
17508
17509 echo "$as_me:$LINENO: checking for cpowf in -lm" >&5
17510 echo $ECHO_N "checking for cpowf in -lm... $ECHO_C" >&6
17511 if test "${ac_cv_lib_m_cpowf+set}" = set; then
17512   echo $ECHO_N "(cached) $ECHO_C" >&6
17513 else
17514   ac_check_lib_save_LIBS=$LIBS
17515 LIBS="-lm  $LIBS"
17516 if test x$gcc_no_link = xyes; then
17517   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17518 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17519    { (exit 1); exit 1; }; }
17520 fi
17521 cat >conftest.$ac_ext <<_ACEOF
17522 /* confdefs.h.  */
17523 _ACEOF
17524 cat confdefs.h >>conftest.$ac_ext
17525 cat >>conftest.$ac_ext <<_ACEOF
17526 /* end confdefs.h.  */
17527
17528 /* Override any gcc2 internal prototype to avoid an error.  */
17529 #ifdef __cplusplus
17530 extern "C"
17531 #endif
17532 /* We use char because int might match the return type of a gcc2
17533    builtin and then its argument prototype would still apply.  */
17534 char cpowf ();
17535 int
17536 main ()
17537 {
17538 cpowf ();
17539   ;
17540   return 0;
17541 }
17542 _ACEOF
17543 rm -f conftest.$ac_objext conftest$ac_exeext
17544 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17545   (eval $ac_link) 2>conftest.er1
17546   ac_status=$?
17547   grep -v '^ *+' conftest.er1 >conftest.err
17548   rm -f conftest.er1
17549   cat conftest.err >&5
17550   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17551   (exit $ac_status); } &&
17552          { ac_try='test -z "$ac_c_werror_flag"
17553                          || test ! -s conftest.err'
17554   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17555   (eval $ac_try) 2>&5
17556   ac_status=$?
17557   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17558   (exit $ac_status); }; } &&
17559          { ac_try='test -s conftest$ac_exeext'
17560   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17561   (eval $ac_try) 2>&5
17562   ac_status=$?
17563   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17564   (exit $ac_status); }; }; then
17565   ac_cv_lib_m_cpowf=yes
17566 else
17567   echo "$as_me: failed program was:" >&5
17568 sed 's/^/| /' conftest.$ac_ext >&5
17569
17570 ac_cv_lib_m_cpowf=no
17571 fi
17572 rm -f conftest.err conftest.$ac_objext \
17573       conftest$ac_exeext conftest.$ac_ext
17574 LIBS=$ac_check_lib_save_LIBS
17575 fi
17576 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpowf" >&5
17577 echo "${ECHO_T}$ac_cv_lib_m_cpowf" >&6
17578 if test $ac_cv_lib_m_cpowf = yes; then
17579
17580 cat >>confdefs.h <<\_ACEOF
17581 #define HAVE_CPOWF 1
17582 _ACEOF
17583
17584 fi
17585
17586 echo "$as_me:$LINENO: checking for cpow in -lm" >&5
17587 echo $ECHO_N "checking for cpow in -lm... $ECHO_C" >&6
17588 if test "${ac_cv_lib_m_cpow+set}" = set; then
17589   echo $ECHO_N "(cached) $ECHO_C" >&6
17590 else
17591   ac_check_lib_save_LIBS=$LIBS
17592 LIBS="-lm  $LIBS"
17593 if test x$gcc_no_link = xyes; then
17594   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17595 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17596    { (exit 1); exit 1; }; }
17597 fi
17598 cat >conftest.$ac_ext <<_ACEOF
17599 /* confdefs.h.  */
17600 _ACEOF
17601 cat confdefs.h >>conftest.$ac_ext
17602 cat >>conftest.$ac_ext <<_ACEOF
17603 /* end confdefs.h.  */
17604
17605 /* Override any gcc2 internal prototype to avoid an error.  */
17606 #ifdef __cplusplus
17607 extern "C"
17608 #endif
17609 /* We use char because int might match the return type of a gcc2
17610    builtin and then its argument prototype would still apply.  */
17611 char cpow ();
17612 int
17613 main ()
17614 {
17615 cpow ();
17616   ;
17617   return 0;
17618 }
17619 _ACEOF
17620 rm -f conftest.$ac_objext conftest$ac_exeext
17621 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17622   (eval $ac_link) 2>conftest.er1
17623   ac_status=$?
17624   grep -v '^ *+' conftest.er1 >conftest.err
17625   rm -f conftest.er1
17626   cat conftest.err >&5
17627   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17628   (exit $ac_status); } &&
17629          { ac_try='test -z "$ac_c_werror_flag"
17630                          || test ! -s conftest.err'
17631   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17632   (eval $ac_try) 2>&5
17633   ac_status=$?
17634   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17635   (exit $ac_status); }; } &&
17636          { ac_try='test -s conftest$ac_exeext'
17637   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17638   (eval $ac_try) 2>&5
17639   ac_status=$?
17640   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17641   (exit $ac_status); }; }; then
17642   ac_cv_lib_m_cpow=yes
17643 else
17644   echo "$as_me: failed program was:" >&5
17645 sed 's/^/| /' conftest.$ac_ext >&5
17646
17647 ac_cv_lib_m_cpow=no
17648 fi
17649 rm -f conftest.err conftest.$ac_objext \
17650       conftest$ac_exeext conftest.$ac_ext
17651 LIBS=$ac_check_lib_save_LIBS
17652 fi
17653 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpow" >&5
17654 echo "${ECHO_T}$ac_cv_lib_m_cpow" >&6
17655 if test $ac_cv_lib_m_cpow = yes; then
17656
17657 cat >>confdefs.h <<\_ACEOF
17658 #define HAVE_CPOW 1
17659 _ACEOF
17660
17661 fi
17662
17663 echo "$as_me:$LINENO: checking for cpowl in -lm" >&5
17664 echo $ECHO_N "checking for cpowl in -lm... $ECHO_C" >&6
17665 if test "${ac_cv_lib_m_cpowl+set}" = set; then
17666   echo $ECHO_N "(cached) $ECHO_C" >&6
17667 else
17668   ac_check_lib_save_LIBS=$LIBS
17669 LIBS="-lm  $LIBS"
17670 if test x$gcc_no_link = xyes; then
17671   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17672 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17673    { (exit 1); exit 1; }; }
17674 fi
17675 cat >conftest.$ac_ext <<_ACEOF
17676 /* confdefs.h.  */
17677 _ACEOF
17678 cat confdefs.h >>conftest.$ac_ext
17679 cat >>conftest.$ac_ext <<_ACEOF
17680 /* end confdefs.h.  */
17681
17682 /* Override any gcc2 internal prototype to avoid an error.  */
17683 #ifdef __cplusplus
17684 extern "C"
17685 #endif
17686 /* We use char because int might match the return type of a gcc2
17687    builtin and then its argument prototype would still apply.  */
17688 char cpowl ();
17689 int
17690 main ()
17691 {
17692 cpowl ();
17693   ;
17694   return 0;
17695 }
17696 _ACEOF
17697 rm -f conftest.$ac_objext conftest$ac_exeext
17698 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17699   (eval $ac_link) 2>conftest.er1
17700   ac_status=$?
17701   grep -v '^ *+' conftest.er1 >conftest.err
17702   rm -f conftest.er1
17703   cat conftest.err >&5
17704   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17705   (exit $ac_status); } &&
17706          { ac_try='test -z "$ac_c_werror_flag"
17707                          || test ! -s conftest.err'
17708   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17709   (eval $ac_try) 2>&5
17710   ac_status=$?
17711   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17712   (exit $ac_status); }; } &&
17713          { ac_try='test -s conftest$ac_exeext'
17714   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17715   (eval $ac_try) 2>&5
17716   ac_status=$?
17717   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17718   (exit $ac_status); }; }; then
17719   ac_cv_lib_m_cpowl=yes
17720 else
17721   echo "$as_me: failed program was:" >&5
17722 sed 's/^/| /' conftest.$ac_ext >&5
17723
17724 ac_cv_lib_m_cpowl=no
17725 fi
17726 rm -f conftest.err conftest.$ac_objext \
17727       conftest$ac_exeext conftest.$ac_ext
17728 LIBS=$ac_check_lib_save_LIBS
17729 fi
17730 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpowl" >&5
17731 echo "${ECHO_T}$ac_cv_lib_m_cpowl" >&6
17732 if test $ac_cv_lib_m_cpowl = yes; then
17733
17734 cat >>confdefs.h <<\_ACEOF
17735 #define HAVE_CPOWL 1
17736 _ACEOF
17737
17738 fi
17739
17740 echo "$as_me:$LINENO: checking for roundf in -lm" >&5
17741 echo $ECHO_N "checking for roundf in -lm... $ECHO_C" >&6
17742 if test "${ac_cv_lib_m_roundf+set}" = set; then
17743   echo $ECHO_N "(cached) $ECHO_C" >&6
17744 else
17745   ac_check_lib_save_LIBS=$LIBS
17746 LIBS="-lm  $LIBS"
17747 if test x$gcc_no_link = xyes; then
17748   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17749 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17750    { (exit 1); exit 1; }; }
17751 fi
17752 cat >conftest.$ac_ext <<_ACEOF
17753 /* confdefs.h.  */
17754 _ACEOF
17755 cat confdefs.h >>conftest.$ac_ext
17756 cat >>conftest.$ac_ext <<_ACEOF
17757 /* end confdefs.h.  */
17758
17759 /* Override any gcc2 internal prototype to avoid an error.  */
17760 #ifdef __cplusplus
17761 extern "C"
17762 #endif
17763 /* We use char because int might match the return type of a gcc2
17764    builtin and then its argument prototype would still apply.  */
17765 char roundf ();
17766 int
17767 main ()
17768 {
17769 roundf ();
17770   ;
17771   return 0;
17772 }
17773 _ACEOF
17774 rm -f conftest.$ac_objext conftest$ac_exeext
17775 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17776   (eval $ac_link) 2>conftest.er1
17777   ac_status=$?
17778   grep -v '^ *+' conftest.er1 >conftest.err
17779   rm -f conftest.er1
17780   cat conftest.err >&5
17781   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17782   (exit $ac_status); } &&
17783          { ac_try='test -z "$ac_c_werror_flag"
17784                          || test ! -s conftest.err'
17785   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17786   (eval $ac_try) 2>&5
17787   ac_status=$?
17788   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17789   (exit $ac_status); }; } &&
17790          { ac_try='test -s conftest$ac_exeext'
17791   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17792   (eval $ac_try) 2>&5
17793   ac_status=$?
17794   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17795   (exit $ac_status); }; }; then
17796   ac_cv_lib_m_roundf=yes
17797 else
17798   echo "$as_me: failed program was:" >&5
17799 sed 's/^/| /' conftest.$ac_ext >&5
17800
17801 ac_cv_lib_m_roundf=no
17802 fi
17803 rm -f conftest.err conftest.$ac_objext \
17804       conftest$ac_exeext conftest.$ac_ext
17805 LIBS=$ac_check_lib_save_LIBS
17806 fi
17807 echo "$as_me:$LINENO: result: $ac_cv_lib_m_roundf" >&5
17808 echo "${ECHO_T}$ac_cv_lib_m_roundf" >&6
17809 if test $ac_cv_lib_m_roundf = yes; then
17810
17811 cat >>confdefs.h <<\_ACEOF
17812 #define HAVE_ROUNDF 1
17813 _ACEOF
17814
17815 fi
17816
17817 echo "$as_me:$LINENO: checking for round in -lm" >&5
17818 echo $ECHO_N "checking for round in -lm... $ECHO_C" >&6
17819 if test "${ac_cv_lib_m_round+set}" = set; then
17820   echo $ECHO_N "(cached) $ECHO_C" >&6
17821 else
17822   ac_check_lib_save_LIBS=$LIBS
17823 LIBS="-lm  $LIBS"
17824 if test x$gcc_no_link = xyes; then
17825   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17826 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17827    { (exit 1); exit 1; }; }
17828 fi
17829 cat >conftest.$ac_ext <<_ACEOF
17830 /* confdefs.h.  */
17831 _ACEOF
17832 cat confdefs.h >>conftest.$ac_ext
17833 cat >>conftest.$ac_ext <<_ACEOF
17834 /* end confdefs.h.  */
17835
17836 /* Override any gcc2 internal prototype to avoid an error.  */
17837 #ifdef __cplusplus
17838 extern "C"
17839 #endif
17840 /* We use char because int might match the return type of a gcc2
17841    builtin and then its argument prototype would still apply.  */
17842 char round ();
17843 int
17844 main ()
17845 {
17846 round ();
17847   ;
17848   return 0;
17849 }
17850 _ACEOF
17851 rm -f conftest.$ac_objext conftest$ac_exeext
17852 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17853   (eval $ac_link) 2>conftest.er1
17854   ac_status=$?
17855   grep -v '^ *+' conftest.er1 >conftest.err
17856   rm -f conftest.er1
17857   cat conftest.err >&5
17858   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17859   (exit $ac_status); } &&
17860          { ac_try='test -z "$ac_c_werror_flag"
17861                          || test ! -s conftest.err'
17862   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17863   (eval $ac_try) 2>&5
17864   ac_status=$?
17865   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17866   (exit $ac_status); }; } &&
17867          { ac_try='test -s conftest$ac_exeext'
17868   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17869   (eval $ac_try) 2>&5
17870   ac_status=$?
17871   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17872   (exit $ac_status); }; }; then
17873   ac_cv_lib_m_round=yes
17874 else
17875   echo "$as_me: failed program was:" >&5
17876 sed 's/^/| /' conftest.$ac_ext >&5
17877
17878 ac_cv_lib_m_round=no
17879 fi
17880 rm -f conftest.err conftest.$ac_objext \
17881       conftest$ac_exeext conftest.$ac_ext
17882 LIBS=$ac_check_lib_save_LIBS
17883 fi
17884 echo "$as_me:$LINENO: result: $ac_cv_lib_m_round" >&5
17885 echo "${ECHO_T}$ac_cv_lib_m_round" >&6
17886 if test $ac_cv_lib_m_round = yes; then
17887
17888 cat >>confdefs.h <<\_ACEOF
17889 #define HAVE_ROUND 1
17890 _ACEOF
17891
17892 fi
17893
17894 echo "$as_me:$LINENO: checking for roundl in -lm" >&5
17895 echo $ECHO_N "checking for roundl in -lm... $ECHO_C" >&6
17896 if test "${ac_cv_lib_m_roundl+set}" = set; then
17897   echo $ECHO_N "(cached) $ECHO_C" >&6
17898 else
17899   ac_check_lib_save_LIBS=$LIBS
17900 LIBS="-lm  $LIBS"
17901 if test x$gcc_no_link = xyes; then
17902   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17903 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17904    { (exit 1); exit 1; }; }
17905 fi
17906 cat >conftest.$ac_ext <<_ACEOF
17907 /* confdefs.h.  */
17908 _ACEOF
17909 cat confdefs.h >>conftest.$ac_ext
17910 cat >>conftest.$ac_ext <<_ACEOF
17911 /* end confdefs.h.  */
17912
17913 /* Override any gcc2 internal prototype to avoid an error.  */
17914 #ifdef __cplusplus
17915 extern "C"
17916 #endif
17917 /* We use char because int might match the return type of a gcc2
17918    builtin and then its argument prototype would still apply.  */
17919 char roundl ();
17920 int
17921 main ()
17922 {
17923 roundl ();
17924   ;
17925   return 0;
17926 }
17927 _ACEOF
17928 rm -f conftest.$ac_objext conftest$ac_exeext
17929 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17930   (eval $ac_link) 2>conftest.er1
17931   ac_status=$?
17932   grep -v '^ *+' conftest.er1 >conftest.err
17933   rm -f conftest.er1
17934   cat conftest.err >&5
17935   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17936   (exit $ac_status); } &&
17937          { ac_try='test -z "$ac_c_werror_flag"
17938                          || test ! -s conftest.err'
17939   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17940   (eval $ac_try) 2>&5
17941   ac_status=$?
17942   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17943   (exit $ac_status); }; } &&
17944          { ac_try='test -s conftest$ac_exeext'
17945   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17946   (eval $ac_try) 2>&5
17947   ac_status=$?
17948   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17949   (exit $ac_status); }; }; then
17950   ac_cv_lib_m_roundl=yes
17951 else
17952   echo "$as_me: failed program was:" >&5
17953 sed 's/^/| /' conftest.$ac_ext >&5
17954
17955 ac_cv_lib_m_roundl=no
17956 fi
17957 rm -f conftest.err conftest.$ac_objext \
17958       conftest$ac_exeext conftest.$ac_ext
17959 LIBS=$ac_check_lib_save_LIBS
17960 fi
17961 echo "$as_me:$LINENO: result: $ac_cv_lib_m_roundl" >&5
17962 echo "${ECHO_T}$ac_cv_lib_m_roundl" >&6
17963 if test $ac_cv_lib_m_roundl = yes; then
17964
17965 cat >>confdefs.h <<\_ACEOF
17966 #define HAVE_ROUNDL 1
17967 _ACEOF
17968
17969 fi
17970
17971 echo "$as_me:$LINENO: checking for scalbnf in -lm" >&5
17972 echo $ECHO_N "checking for scalbnf in -lm... $ECHO_C" >&6
17973 if test "${ac_cv_lib_m_scalbnf+set}" = set; then
17974   echo $ECHO_N "(cached) $ECHO_C" >&6
17975 else
17976   ac_check_lib_save_LIBS=$LIBS
17977 LIBS="-lm  $LIBS"
17978 if test x$gcc_no_link = xyes; then
17979   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17980 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17981    { (exit 1); exit 1; }; }
17982 fi
17983 cat >conftest.$ac_ext <<_ACEOF
17984 /* confdefs.h.  */
17985 _ACEOF
17986 cat confdefs.h >>conftest.$ac_ext
17987 cat >>conftest.$ac_ext <<_ACEOF
17988 /* end confdefs.h.  */
17989
17990 /* Override any gcc2 internal prototype to avoid an error.  */
17991 #ifdef __cplusplus
17992 extern "C"
17993 #endif
17994 /* We use char because int might match the return type of a gcc2
17995    builtin and then its argument prototype would still apply.  */
17996 char scalbnf ();
17997 int
17998 main ()
17999 {
18000 scalbnf ();
18001   ;
18002   return 0;
18003 }
18004 _ACEOF
18005 rm -f conftest.$ac_objext conftest$ac_exeext
18006 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18007   (eval $ac_link) 2>conftest.er1
18008   ac_status=$?
18009   grep -v '^ *+' conftest.er1 >conftest.err
18010   rm -f conftest.er1
18011   cat conftest.err >&5
18012   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18013   (exit $ac_status); } &&
18014          { ac_try='test -z "$ac_c_werror_flag"
18015                          || test ! -s conftest.err'
18016   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18017   (eval $ac_try) 2>&5
18018   ac_status=$?
18019   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18020   (exit $ac_status); }; } &&
18021          { ac_try='test -s conftest$ac_exeext'
18022   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18023   (eval $ac_try) 2>&5
18024   ac_status=$?
18025   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18026   (exit $ac_status); }; }; then
18027   ac_cv_lib_m_scalbnf=yes
18028 else
18029   echo "$as_me: failed program was:" >&5
18030 sed 's/^/| /' conftest.$ac_ext >&5
18031
18032 ac_cv_lib_m_scalbnf=no
18033 fi
18034 rm -f conftest.err conftest.$ac_objext \
18035       conftest$ac_exeext conftest.$ac_ext
18036 LIBS=$ac_check_lib_save_LIBS
18037 fi
18038 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbnf" >&5
18039 echo "${ECHO_T}$ac_cv_lib_m_scalbnf" >&6
18040 if test $ac_cv_lib_m_scalbnf = yes; then
18041
18042 cat >>confdefs.h <<\_ACEOF
18043 #define HAVE_SCALBNF 1
18044 _ACEOF
18045
18046 fi
18047
18048 echo "$as_me:$LINENO: checking for scalbn in -lm" >&5
18049 echo $ECHO_N "checking for scalbn in -lm... $ECHO_C" >&6
18050 if test "${ac_cv_lib_m_scalbn+set}" = set; then
18051   echo $ECHO_N "(cached) $ECHO_C" >&6
18052 else
18053   ac_check_lib_save_LIBS=$LIBS
18054 LIBS="-lm  $LIBS"
18055 if test x$gcc_no_link = xyes; then
18056   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18057 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18058    { (exit 1); exit 1; }; }
18059 fi
18060 cat >conftest.$ac_ext <<_ACEOF
18061 /* confdefs.h.  */
18062 _ACEOF
18063 cat confdefs.h >>conftest.$ac_ext
18064 cat >>conftest.$ac_ext <<_ACEOF
18065 /* end confdefs.h.  */
18066
18067 /* Override any gcc2 internal prototype to avoid an error.  */
18068 #ifdef __cplusplus
18069 extern "C"
18070 #endif
18071 /* We use char because int might match the return type of a gcc2
18072    builtin and then its argument prototype would still apply.  */
18073 char scalbn ();
18074 int
18075 main ()
18076 {
18077 scalbn ();
18078   ;
18079   return 0;
18080 }
18081 _ACEOF
18082 rm -f conftest.$ac_objext conftest$ac_exeext
18083 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18084   (eval $ac_link) 2>conftest.er1
18085   ac_status=$?
18086   grep -v '^ *+' conftest.er1 >conftest.err
18087   rm -f conftest.er1
18088   cat conftest.err >&5
18089   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18090   (exit $ac_status); } &&
18091          { ac_try='test -z "$ac_c_werror_flag"
18092                          || test ! -s conftest.err'
18093   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18094   (eval $ac_try) 2>&5
18095   ac_status=$?
18096   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18097   (exit $ac_status); }; } &&
18098          { ac_try='test -s conftest$ac_exeext'
18099   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18100   (eval $ac_try) 2>&5
18101   ac_status=$?
18102   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18103   (exit $ac_status); }; }; then
18104   ac_cv_lib_m_scalbn=yes
18105 else
18106   echo "$as_me: failed program was:" >&5
18107 sed 's/^/| /' conftest.$ac_ext >&5
18108
18109 ac_cv_lib_m_scalbn=no
18110 fi
18111 rm -f conftest.err conftest.$ac_objext \
18112       conftest$ac_exeext conftest.$ac_ext
18113 LIBS=$ac_check_lib_save_LIBS
18114 fi
18115 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbn" >&5
18116 echo "${ECHO_T}$ac_cv_lib_m_scalbn" >&6
18117 if test $ac_cv_lib_m_scalbn = yes; then
18118
18119 cat >>confdefs.h <<\_ACEOF
18120 #define HAVE_SCALBN 1
18121 _ACEOF
18122
18123 fi
18124
18125 echo "$as_me:$LINENO: checking for scalbnl in -lm" >&5
18126 echo $ECHO_N "checking for scalbnl in -lm... $ECHO_C" >&6
18127 if test "${ac_cv_lib_m_scalbnl+set}" = set; then
18128   echo $ECHO_N "(cached) $ECHO_C" >&6
18129 else
18130   ac_check_lib_save_LIBS=$LIBS
18131 LIBS="-lm  $LIBS"
18132 if test x$gcc_no_link = xyes; then
18133   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18134 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18135    { (exit 1); exit 1; }; }
18136 fi
18137 cat >conftest.$ac_ext <<_ACEOF
18138 /* confdefs.h.  */
18139 _ACEOF
18140 cat confdefs.h >>conftest.$ac_ext
18141 cat >>conftest.$ac_ext <<_ACEOF
18142 /* end confdefs.h.  */
18143
18144 /* Override any gcc2 internal prototype to avoid an error.  */
18145 #ifdef __cplusplus
18146 extern "C"
18147 #endif
18148 /* We use char because int might match the return type of a gcc2
18149    builtin and then its argument prototype would still apply.  */
18150 char scalbnl ();
18151 int
18152 main ()
18153 {
18154 scalbnl ();
18155   ;
18156   return 0;
18157 }
18158 _ACEOF
18159 rm -f conftest.$ac_objext conftest$ac_exeext
18160 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18161   (eval $ac_link) 2>conftest.er1
18162   ac_status=$?
18163   grep -v '^ *+' conftest.er1 >conftest.err
18164   rm -f conftest.er1
18165   cat conftest.err >&5
18166   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18167   (exit $ac_status); } &&
18168          { ac_try='test -z "$ac_c_werror_flag"
18169                          || test ! -s conftest.err'
18170   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18171   (eval $ac_try) 2>&5
18172   ac_status=$?
18173   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18174   (exit $ac_status); }; } &&
18175          { ac_try='test -s conftest$ac_exeext'
18176   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18177   (eval $ac_try) 2>&5
18178   ac_status=$?
18179   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18180   (exit $ac_status); }; }; then
18181   ac_cv_lib_m_scalbnl=yes
18182 else
18183   echo "$as_me: failed program was:" >&5
18184 sed 's/^/| /' conftest.$ac_ext >&5
18185
18186 ac_cv_lib_m_scalbnl=no
18187 fi
18188 rm -f conftest.err conftest.$ac_objext \
18189       conftest$ac_exeext conftest.$ac_ext
18190 LIBS=$ac_check_lib_save_LIBS
18191 fi
18192 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbnl" >&5
18193 echo "${ECHO_T}$ac_cv_lib_m_scalbnl" >&6
18194 if test $ac_cv_lib_m_scalbnl = yes; then
18195
18196 cat >>confdefs.h <<\_ACEOF
18197 #define HAVE_SCALBNL 1
18198 _ACEOF
18199
18200 fi
18201
18202 echo "$as_me:$LINENO: checking for sinf in -lm" >&5
18203 echo $ECHO_N "checking for sinf in -lm... $ECHO_C" >&6
18204 if test "${ac_cv_lib_m_sinf+set}" = set; then
18205   echo $ECHO_N "(cached) $ECHO_C" >&6
18206 else
18207   ac_check_lib_save_LIBS=$LIBS
18208 LIBS="-lm  $LIBS"
18209 if test x$gcc_no_link = xyes; then
18210   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18211 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18212    { (exit 1); exit 1; }; }
18213 fi
18214 cat >conftest.$ac_ext <<_ACEOF
18215 /* confdefs.h.  */
18216 _ACEOF
18217 cat confdefs.h >>conftest.$ac_ext
18218 cat >>conftest.$ac_ext <<_ACEOF
18219 /* end confdefs.h.  */
18220
18221 /* Override any gcc2 internal prototype to avoid an error.  */
18222 #ifdef __cplusplus
18223 extern "C"
18224 #endif
18225 /* We use char because int might match the return type of a gcc2
18226    builtin and then its argument prototype would still apply.  */
18227 char sinf ();
18228 int
18229 main ()
18230 {
18231 sinf ();
18232   ;
18233   return 0;
18234 }
18235 _ACEOF
18236 rm -f conftest.$ac_objext conftest$ac_exeext
18237 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18238   (eval $ac_link) 2>conftest.er1
18239   ac_status=$?
18240   grep -v '^ *+' conftest.er1 >conftest.err
18241   rm -f conftest.er1
18242   cat conftest.err >&5
18243   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18244   (exit $ac_status); } &&
18245          { ac_try='test -z "$ac_c_werror_flag"
18246                          || test ! -s conftest.err'
18247   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18248   (eval $ac_try) 2>&5
18249   ac_status=$?
18250   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18251   (exit $ac_status); }; } &&
18252          { ac_try='test -s conftest$ac_exeext'
18253   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18254   (eval $ac_try) 2>&5
18255   ac_status=$?
18256   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18257   (exit $ac_status); }; }; then
18258   ac_cv_lib_m_sinf=yes
18259 else
18260   echo "$as_me: failed program was:" >&5
18261 sed 's/^/| /' conftest.$ac_ext >&5
18262
18263 ac_cv_lib_m_sinf=no
18264 fi
18265 rm -f conftest.err conftest.$ac_objext \
18266       conftest$ac_exeext conftest.$ac_ext
18267 LIBS=$ac_check_lib_save_LIBS
18268 fi
18269 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinf" >&5
18270 echo "${ECHO_T}$ac_cv_lib_m_sinf" >&6
18271 if test $ac_cv_lib_m_sinf = yes; then
18272
18273 cat >>confdefs.h <<\_ACEOF
18274 #define HAVE_SINF 1
18275 _ACEOF
18276
18277 fi
18278
18279 echo "$as_me:$LINENO: checking for sin in -lm" >&5
18280 echo $ECHO_N "checking for sin in -lm... $ECHO_C" >&6
18281 if test "${ac_cv_lib_m_sin+set}" = set; then
18282   echo $ECHO_N "(cached) $ECHO_C" >&6
18283 else
18284   ac_check_lib_save_LIBS=$LIBS
18285 LIBS="-lm  $LIBS"
18286 if test x$gcc_no_link = xyes; then
18287   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18288 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18289    { (exit 1); exit 1; }; }
18290 fi
18291 cat >conftest.$ac_ext <<_ACEOF
18292 /* confdefs.h.  */
18293 _ACEOF
18294 cat confdefs.h >>conftest.$ac_ext
18295 cat >>conftest.$ac_ext <<_ACEOF
18296 /* end confdefs.h.  */
18297
18298 /* Override any gcc2 internal prototype to avoid an error.  */
18299 #ifdef __cplusplus
18300 extern "C"
18301 #endif
18302 /* We use char because int might match the return type of a gcc2
18303    builtin and then its argument prototype would still apply.  */
18304 char sin ();
18305 int
18306 main ()
18307 {
18308 sin ();
18309   ;
18310   return 0;
18311 }
18312 _ACEOF
18313 rm -f conftest.$ac_objext conftest$ac_exeext
18314 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18315   (eval $ac_link) 2>conftest.er1
18316   ac_status=$?
18317   grep -v '^ *+' conftest.er1 >conftest.err
18318   rm -f conftest.er1
18319   cat conftest.err >&5
18320   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18321   (exit $ac_status); } &&
18322          { ac_try='test -z "$ac_c_werror_flag"
18323                          || test ! -s conftest.err'
18324   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18325   (eval $ac_try) 2>&5
18326   ac_status=$?
18327   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18328   (exit $ac_status); }; } &&
18329          { ac_try='test -s conftest$ac_exeext'
18330   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18331   (eval $ac_try) 2>&5
18332   ac_status=$?
18333   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18334   (exit $ac_status); }; }; then
18335   ac_cv_lib_m_sin=yes
18336 else
18337   echo "$as_me: failed program was:" >&5
18338 sed 's/^/| /' conftest.$ac_ext >&5
18339
18340 ac_cv_lib_m_sin=no
18341 fi
18342 rm -f conftest.err conftest.$ac_objext \
18343       conftest$ac_exeext conftest.$ac_ext
18344 LIBS=$ac_check_lib_save_LIBS
18345 fi
18346 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sin" >&5
18347 echo "${ECHO_T}$ac_cv_lib_m_sin" >&6
18348 if test $ac_cv_lib_m_sin = yes; then
18349
18350 cat >>confdefs.h <<\_ACEOF
18351 #define HAVE_SIN 1
18352 _ACEOF
18353
18354 fi
18355
18356 echo "$as_me:$LINENO: checking for sinl in -lm" >&5
18357 echo $ECHO_N "checking for sinl in -lm... $ECHO_C" >&6
18358 if test "${ac_cv_lib_m_sinl+set}" = set; then
18359   echo $ECHO_N "(cached) $ECHO_C" >&6
18360 else
18361   ac_check_lib_save_LIBS=$LIBS
18362 LIBS="-lm  $LIBS"
18363 if test x$gcc_no_link = xyes; then
18364   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18365 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18366    { (exit 1); exit 1; }; }
18367 fi
18368 cat >conftest.$ac_ext <<_ACEOF
18369 /* confdefs.h.  */
18370 _ACEOF
18371 cat confdefs.h >>conftest.$ac_ext
18372 cat >>conftest.$ac_ext <<_ACEOF
18373 /* end confdefs.h.  */
18374
18375 /* Override any gcc2 internal prototype to avoid an error.  */
18376 #ifdef __cplusplus
18377 extern "C"
18378 #endif
18379 /* We use char because int might match the return type of a gcc2
18380    builtin and then its argument prototype would still apply.  */
18381 char sinl ();
18382 int
18383 main ()
18384 {
18385 sinl ();
18386   ;
18387   return 0;
18388 }
18389 _ACEOF
18390 rm -f conftest.$ac_objext conftest$ac_exeext
18391 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18392   (eval $ac_link) 2>conftest.er1
18393   ac_status=$?
18394   grep -v '^ *+' conftest.er1 >conftest.err
18395   rm -f conftest.er1
18396   cat conftest.err >&5
18397   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18398   (exit $ac_status); } &&
18399          { ac_try='test -z "$ac_c_werror_flag"
18400                          || test ! -s conftest.err'
18401   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18402   (eval $ac_try) 2>&5
18403   ac_status=$?
18404   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18405   (exit $ac_status); }; } &&
18406          { ac_try='test -s conftest$ac_exeext'
18407   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18408   (eval $ac_try) 2>&5
18409   ac_status=$?
18410   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18411   (exit $ac_status); }; }; then
18412   ac_cv_lib_m_sinl=yes
18413 else
18414   echo "$as_me: failed program was:" >&5
18415 sed 's/^/| /' conftest.$ac_ext >&5
18416
18417 ac_cv_lib_m_sinl=no
18418 fi
18419 rm -f conftest.err conftest.$ac_objext \
18420       conftest$ac_exeext conftest.$ac_ext
18421 LIBS=$ac_check_lib_save_LIBS
18422 fi
18423 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinl" >&5
18424 echo "${ECHO_T}$ac_cv_lib_m_sinl" >&6
18425 if test $ac_cv_lib_m_sinl = yes; then
18426
18427 cat >>confdefs.h <<\_ACEOF
18428 #define HAVE_SINL 1
18429 _ACEOF
18430
18431 fi
18432
18433 echo "$as_me:$LINENO: checking for csinf in -lm" >&5
18434 echo $ECHO_N "checking for csinf in -lm... $ECHO_C" >&6
18435 if test "${ac_cv_lib_m_csinf+set}" = set; then
18436   echo $ECHO_N "(cached) $ECHO_C" >&6
18437 else
18438   ac_check_lib_save_LIBS=$LIBS
18439 LIBS="-lm  $LIBS"
18440 if test x$gcc_no_link = xyes; then
18441   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18442 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18443    { (exit 1); exit 1; }; }
18444 fi
18445 cat >conftest.$ac_ext <<_ACEOF
18446 /* confdefs.h.  */
18447 _ACEOF
18448 cat confdefs.h >>conftest.$ac_ext
18449 cat >>conftest.$ac_ext <<_ACEOF
18450 /* end confdefs.h.  */
18451
18452 /* Override any gcc2 internal prototype to avoid an error.  */
18453 #ifdef __cplusplus
18454 extern "C"
18455 #endif
18456 /* We use char because int might match the return type of a gcc2
18457    builtin and then its argument prototype would still apply.  */
18458 char csinf ();
18459 int
18460 main ()
18461 {
18462 csinf ();
18463   ;
18464   return 0;
18465 }
18466 _ACEOF
18467 rm -f conftest.$ac_objext conftest$ac_exeext
18468 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18469   (eval $ac_link) 2>conftest.er1
18470   ac_status=$?
18471   grep -v '^ *+' conftest.er1 >conftest.err
18472   rm -f conftest.er1
18473   cat conftest.err >&5
18474   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18475   (exit $ac_status); } &&
18476          { ac_try='test -z "$ac_c_werror_flag"
18477                          || test ! -s conftest.err'
18478   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18479   (eval $ac_try) 2>&5
18480   ac_status=$?
18481   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18482   (exit $ac_status); }; } &&
18483          { ac_try='test -s conftest$ac_exeext'
18484   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18485   (eval $ac_try) 2>&5
18486   ac_status=$?
18487   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18488   (exit $ac_status); }; }; then
18489   ac_cv_lib_m_csinf=yes
18490 else
18491   echo "$as_me: failed program was:" >&5
18492 sed 's/^/| /' conftest.$ac_ext >&5
18493
18494 ac_cv_lib_m_csinf=no
18495 fi
18496 rm -f conftest.err conftest.$ac_objext \
18497       conftest$ac_exeext conftest.$ac_ext
18498 LIBS=$ac_check_lib_save_LIBS
18499 fi
18500 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinf" >&5
18501 echo "${ECHO_T}$ac_cv_lib_m_csinf" >&6
18502 if test $ac_cv_lib_m_csinf = yes; then
18503
18504 cat >>confdefs.h <<\_ACEOF
18505 #define HAVE_CSINF 1
18506 _ACEOF
18507
18508 fi
18509
18510 echo "$as_me:$LINENO: checking for csin in -lm" >&5
18511 echo $ECHO_N "checking for csin in -lm... $ECHO_C" >&6
18512 if test "${ac_cv_lib_m_csin+set}" = set; then
18513   echo $ECHO_N "(cached) $ECHO_C" >&6
18514 else
18515   ac_check_lib_save_LIBS=$LIBS
18516 LIBS="-lm  $LIBS"
18517 if test x$gcc_no_link = xyes; then
18518   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18519 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18520    { (exit 1); exit 1; }; }
18521 fi
18522 cat >conftest.$ac_ext <<_ACEOF
18523 /* confdefs.h.  */
18524 _ACEOF
18525 cat confdefs.h >>conftest.$ac_ext
18526 cat >>conftest.$ac_ext <<_ACEOF
18527 /* end confdefs.h.  */
18528
18529 /* Override any gcc2 internal prototype to avoid an error.  */
18530 #ifdef __cplusplus
18531 extern "C"
18532 #endif
18533 /* We use char because int might match the return type of a gcc2
18534    builtin and then its argument prototype would still apply.  */
18535 char csin ();
18536 int
18537 main ()
18538 {
18539 csin ();
18540   ;
18541   return 0;
18542 }
18543 _ACEOF
18544 rm -f conftest.$ac_objext conftest$ac_exeext
18545 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18546   (eval $ac_link) 2>conftest.er1
18547   ac_status=$?
18548   grep -v '^ *+' conftest.er1 >conftest.err
18549   rm -f conftest.er1
18550   cat conftest.err >&5
18551   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18552   (exit $ac_status); } &&
18553          { ac_try='test -z "$ac_c_werror_flag"
18554                          || test ! -s conftest.err'
18555   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18556   (eval $ac_try) 2>&5
18557   ac_status=$?
18558   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18559   (exit $ac_status); }; } &&
18560          { ac_try='test -s conftest$ac_exeext'
18561   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18562   (eval $ac_try) 2>&5
18563   ac_status=$?
18564   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18565   (exit $ac_status); }; }; then
18566   ac_cv_lib_m_csin=yes
18567 else
18568   echo "$as_me: failed program was:" >&5
18569 sed 's/^/| /' conftest.$ac_ext >&5
18570
18571 ac_cv_lib_m_csin=no
18572 fi
18573 rm -f conftest.err conftest.$ac_objext \
18574       conftest$ac_exeext conftest.$ac_ext
18575 LIBS=$ac_check_lib_save_LIBS
18576 fi
18577 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csin" >&5
18578 echo "${ECHO_T}$ac_cv_lib_m_csin" >&6
18579 if test $ac_cv_lib_m_csin = yes; then
18580
18581 cat >>confdefs.h <<\_ACEOF
18582 #define HAVE_CSIN 1
18583 _ACEOF
18584
18585 fi
18586
18587 echo "$as_me:$LINENO: checking for csinl in -lm" >&5
18588 echo $ECHO_N "checking for csinl in -lm... $ECHO_C" >&6
18589 if test "${ac_cv_lib_m_csinl+set}" = set; then
18590   echo $ECHO_N "(cached) $ECHO_C" >&6
18591 else
18592   ac_check_lib_save_LIBS=$LIBS
18593 LIBS="-lm  $LIBS"
18594 if test x$gcc_no_link = xyes; then
18595   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18596 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18597    { (exit 1); exit 1; }; }
18598 fi
18599 cat >conftest.$ac_ext <<_ACEOF
18600 /* confdefs.h.  */
18601 _ACEOF
18602 cat confdefs.h >>conftest.$ac_ext
18603 cat >>conftest.$ac_ext <<_ACEOF
18604 /* end confdefs.h.  */
18605
18606 /* Override any gcc2 internal prototype to avoid an error.  */
18607 #ifdef __cplusplus
18608 extern "C"
18609 #endif
18610 /* We use char because int might match the return type of a gcc2
18611    builtin and then its argument prototype would still apply.  */
18612 char csinl ();
18613 int
18614 main ()
18615 {
18616 csinl ();
18617   ;
18618   return 0;
18619 }
18620 _ACEOF
18621 rm -f conftest.$ac_objext conftest$ac_exeext
18622 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18623   (eval $ac_link) 2>conftest.er1
18624   ac_status=$?
18625   grep -v '^ *+' conftest.er1 >conftest.err
18626   rm -f conftest.er1
18627   cat conftest.err >&5
18628   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18629   (exit $ac_status); } &&
18630          { ac_try='test -z "$ac_c_werror_flag"
18631                          || test ! -s conftest.err'
18632   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18633   (eval $ac_try) 2>&5
18634   ac_status=$?
18635   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18636   (exit $ac_status); }; } &&
18637          { ac_try='test -s conftest$ac_exeext'
18638   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18639   (eval $ac_try) 2>&5
18640   ac_status=$?
18641   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18642   (exit $ac_status); }; }; then
18643   ac_cv_lib_m_csinl=yes
18644 else
18645   echo "$as_me: failed program was:" >&5
18646 sed 's/^/| /' conftest.$ac_ext >&5
18647
18648 ac_cv_lib_m_csinl=no
18649 fi
18650 rm -f conftest.err conftest.$ac_objext \
18651       conftest$ac_exeext conftest.$ac_ext
18652 LIBS=$ac_check_lib_save_LIBS
18653 fi
18654 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinl" >&5
18655 echo "${ECHO_T}$ac_cv_lib_m_csinl" >&6
18656 if test $ac_cv_lib_m_csinl = yes; then
18657
18658 cat >>confdefs.h <<\_ACEOF
18659 #define HAVE_CSINL 1
18660 _ACEOF
18661
18662 fi
18663
18664 echo "$as_me:$LINENO: checking for sinhf in -lm" >&5
18665 echo $ECHO_N "checking for sinhf in -lm... $ECHO_C" >&6
18666 if test "${ac_cv_lib_m_sinhf+set}" = set; then
18667   echo $ECHO_N "(cached) $ECHO_C" >&6
18668 else
18669   ac_check_lib_save_LIBS=$LIBS
18670 LIBS="-lm  $LIBS"
18671 if test x$gcc_no_link = xyes; then
18672   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18673 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18674    { (exit 1); exit 1; }; }
18675 fi
18676 cat >conftest.$ac_ext <<_ACEOF
18677 /* confdefs.h.  */
18678 _ACEOF
18679 cat confdefs.h >>conftest.$ac_ext
18680 cat >>conftest.$ac_ext <<_ACEOF
18681 /* end confdefs.h.  */
18682
18683 /* Override any gcc2 internal prototype to avoid an error.  */
18684 #ifdef __cplusplus
18685 extern "C"
18686 #endif
18687 /* We use char because int might match the return type of a gcc2
18688    builtin and then its argument prototype would still apply.  */
18689 char sinhf ();
18690 int
18691 main ()
18692 {
18693 sinhf ();
18694   ;
18695   return 0;
18696 }
18697 _ACEOF
18698 rm -f conftest.$ac_objext conftest$ac_exeext
18699 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18700   (eval $ac_link) 2>conftest.er1
18701   ac_status=$?
18702   grep -v '^ *+' conftest.er1 >conftest.err
18703   rm -f conftest.er1
18704   cat conftest.err >&5
18705   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18706   (exit $ac_status); } &&
18707          { ac_try='test -z "$ac_c_werror_flag"
18708                          || test ! -s conftest.err'
18709   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18710   (eval $ac_try) 2>&5
18711   ac_status=$?
18712   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18713   (exit $ac_status); }; } &&
18714          { ac_try='test -s conftest$ac_exeext'
18715   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18716   (eval $ac_try) 2>&5
18717   ac_status=$?
18718   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18719   (exit $ac_status); }; }; then
18720   ac_cv_lib_m_sinhf=yes
18721 else
18722   echo "$as_me: failed program was:" >&5
18723 sed 's/^/| /' conftest.$ac_ext >&5
18724
18725 ac_cv_lib_m_sinhf=no
18726 fi
18727 rm -f conftest.err conftest.$ac_objext \
18728       conftest$ac_exeext conftest.$ac_ext
18729 LIBS=$ac_check_lib_save_LIBS
18730 fi
18731 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinhf" >&5
18732 echo "${ECHO_T}$ac_cv_lib_m_sinhf" >&6
18733 if test $ac_cv_lib_m_sinhf = yes; then
18734
18735 cat >>confdefs.h <<\_ACEOF
18736 #define HAVE_SINHF 1
18737 _ACEOF
18738
18739 fi
18740
18741 echo "$as_me:$LINENO: checking for sinh in -lm" >&5
18742 echo $ECHO_N "checking for sinh in -lm... $ECHO_C" >&6
18743 if test "${ac_cv_lib_m_sinh+set}" = set; then
18744   echo $ECHO_N "(cached) $ECHO_C" >&6
18745 else
18746   ac_check_lib_save_LIBS=$LIBS
18747 LIBS="-lm  $LIBS"
18748 if test x$gcc_no_link = xyes; then
18749   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18750 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18751    { (exit 1); exit 1; }; }
18752 fi
18753 cat >conftest.$ac_ext <<_ACEOF
18754 /* confdefs.h.  */
18755 _ACEOF
18756 cat confdefs.h >>conftest.$ac_ext
18757 cat >>conftest.$ac_ext <<_ACEOF
18758 /* end confdefs.h.  */
18759
18760 /* Override any gcc2 internal prototype to avoid an error.  */
18761 #ifdef __cplusplus
18762 extern "C"
18763 #endif
18764 /* We use char because int might match the return type of a gcc2
18765    builtin and then its argument prototype would still apply.  */
18766 char sinh ();
18767 int
18768 main ()
18769 {
18770 sinh ();
18771   ;
18772   return 0;
18773 }
18774 _ACEOF
18775 rm -f conftest.$ac_objext conftest$ac_exeext
18776 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18777   (eval $ac_link) 2>conftest.er1
18778   ac_status=$?
18779   grep -v '^ *+' conftest.er1 >conftest.err
18780   rm -f conftest.er1
18781   cat conftest.err >&5
18782   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18783   (exit $ac_status); } &&
18784          { ac_try='test -z "$ac_c_werror_flag"
18785                          || test ! -s conftest.err'
18786   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18787   (eval $ac_try) 2>&5
18788   ac_status=$?
18789   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18790   (exit $ac_status); }; } &&
18791          { ac_try='test -s conftest$ac_exeext'
18792   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18793   (eval $ac_try) 2>&5
18794   ac_status=$?
18795   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18796   (exit $ac_status); }; }; then
18797   ac_cv_lib_m_sinh=yes
18798 else
18799   echo "$as_me: failed program was:" >&5
18800 sed 's/^/| /' conftest.$ac_ext >&5
18801
18802 ac_cv_lib_m_sinh=no
18803 fi
18804 rm -f conftest.err conftest.$ac_objext \
18805       conftest$ac_exeext conftest.$ac_ext
18806 LIBS=$ac_check_lib_save_LIBS
18807 fi
18808 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinh" >&5
18809 echo "${ECHO_T}$ac_cv_lib_m_sinh" >&6
18810 if test $ac_cv_lib_m_sinh = yes; then
18811
18812 cat >>confdefs.h <<\_ACEOF
18813 #define HAVE_SINH 1
18814 _ACEOF
18815
18816 fi
18817
18818 echo "$as_me:$LINENO: checking for sinhl in -lm" >&5
18819 echo $ECHO_N "checking for sinhl in -lm... $ECHO_C" >&6
18820 if test "${ac_cv_lib_m_sinhl+set}" = set; then
18821   echo $ECHO_N "(cached) $ECHO_C" >&6
18822 else
18823   ac_check_lib_save_LIBS=$LIBS
18824 LIBS="-lm  $LIBS"
18825 if test x$gcc_no_link = xyes; then
18826   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18827 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18828    { (exit 1); exit 1; }; }
18829 fi
18830 cat >conftest.$ac_ext <<_ACEOF
18831 /* confdefs.h.  */
18832 _ACEOF
18833 cat confdefs.h >>conftest.$ac_ext
18834 cat >>conftest.$ac_ext <<_ACEOF
18835 /* end confdefs.h.  */
18836
18837 /* Override any gcc2 internal prototype to avoid an error.  */
18838 #ifdef __cplusplus
18839 extern "C"
18840 #endif
18841 /* We use char because int might match the return type of a gcc2
18842    builtin and then its argument prototype would still apply.  */
18843 char sinhl ();
18844 int
18845 main ()
18846 {
18847 sinhl ();
18848   ;
18849   return 0;
18850 }
18851 _ACEOF
18852 rm -f conftest.$ac_objext conftest$ac_exeext
18853 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18854   (eval $ac_link) 2>conftest.er1
18855   ac_status=$?
18856   grep -v '^ *+' conftest.er1 >conftest.err
18857   rm -f conftest.er1
18858   cat conftest.err >&5
18859   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18860   (exit $ac_status); } &&
18861          { ac_try='test -z "$ac_c_werror_flag"
18862                          || test ! -s conftest.err'
18863   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18864   (eval $ac_try) 2>&5
18865   ac_status=$?
18866   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18867   (exit $ac_status); }; } &&
18868          { ac_try='test -s conftest$ac_exeext'
18869   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18870   (eval $ac_try) 2>&5
18871   ac_status=$?
18872   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18873   (exit $ac_status); }; }; then
18874   ac_cv_lib_m_sinhl=yes
18875 else
18876   echo "$as_me: failed program was:" >&5
18877 sed 's/^/| /' conftest.$ac_ext >&5
18878
18879 ac_cv_lib_m_sinhl=no
18880 fi
18881 rm -f conftest.err conftest.$ac_objext \
18882       conftest$ac_exeext conftest.$ac_ext
18883 LIBS=$ac_check_lib_save_LIBS
18884 fi
18885 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinhl" >&5
18886 echo "${ECHO_T}$ac_cv_lib_m_sinhl" >&6
18887 if test $ac_cv_lib_m_sinhl = yes; then
18888
18889 cat >>confdefs.h <<\_ACEOF
18890 #define HAVE_SINHL 1
18891 _ACEOF
18892
18893 fi
18894
18895 echo "$as_me:$LINENO: checking for csinhf in -lm" >&5
18896 echo $ECHO_N "checking for csinhf in -lm... $ECHO_C" >&6
18897 if test "${ac_cv_lib_m_csinhf+set}" = set; then
18898   echo $ECHO_N "(cached) $ECHO_C" >&6
18899 else
18900   ac_check_lib_save_LIBS=$LIBS
18901 LIBS="-lm  $LIBS"
18902 if test x$gcc_no_link = xyes; then
18903   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18904 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18905    { (exit 1); exit 1; }; }
18906 fi
18907 cat >conftest.$ac_ext <<_ACEOF
18908 /* confdefs.h.  */
18909 _ACEOF
18910 cat confdefs.h >>conftest.$ac_ext
18911 cat >>conftest.$ac_ext <<_ACEOF
18912 /* end confdefs.h.  */
18913
18914 /* Override any gcc2 internal prototype to avoid an error.  */
18915 #ifdef __cplusplus
18916 extern "C"
18917 #endif
18918 /* We use char because int might match the return type of a gcc2
18919    builtin and then its argument prototype would still apply.  */
18920 char csinhf ();
18921 int
18922 main ()
18923 {
18924 csinhf ();
18925   ;
18926   return 0;
18927 }
18928 _ACEOF
18929 rm -f conftest.$ac_objext conftest$ac_exeext
18930 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18931   (eval $ac_link) 2>conftest.er1
18932   ac_status=$?
18933   grep -v '^ *+' conftest.er1 >conftest.err
18934   rm -f conftest.er1
18935   cat conftest.err >&5
18936   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18937   (exit $ac_status); } &&
18938          { ac_try='test -z "$ac_c_werror_flag"
18939                          || test ! -s conftest.err'
18940   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18941   (eval $ac_try) 2>&5
18942   ac_status=$?
18943   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18944   (exit $ac_status); }; } &&
18945          { ac_try='test -s conftest$ac_exeext'
18946   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18947   (eval $ac_try) 2>&5
18948   ac_status=$?
18949   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18950   (exit $ac_status); }; }; then
18951   ac_cv_lib_m_csinhf=yes
18952 else
18953   echo "$as_me: failed program was:" >&5
18954 sed 's/^/| /' conftest.$ac_ext >&5
18955
18956 ac_cv_lib_m_csinhf=no
18957 fi
18958 rm -f conftest.err conftest.$ac_objext \
18959       conftest$ac_exeext conftest.$ac_ext
18960 LIBS=$ac_check_lib_save_LIBS
18961 fi
18962 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinhf" >&5
18963 echo "${ECHO_T}$ac_cv_lib_m_csinhf" >&6
18964 if test $ac_cv_lib_m_csinhf = yes; then
18965
18966 cat >>confdefs.h <<\_ACEOF
18967 #define HAVE_CSINHF 1
18968 _ACEOF
18969
18970 fi
18971
18972 echo "$as_me:$LINENO: checking for csinh in -lm" >&5
18973 echo $ECHO_N "checking for csinh in -lm... $ECHO_C" >&6
18974 if test "${ac_cv_lib_m_csinh+set}" = set; then
18975   echo $ECHO_N "(cached) $ECHO_C" >&6
18976 else
18977   ac_check_lib_save_LIBS=$LIBS
18978 LIBS="-lm  $LIBS"
18979 if test x$gcc_no_link = xyes; then
18980   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18981 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18982    { (exit 1); exit 1; }; }
18983 fi
18984 cat >conftest.$ac_ext <<_ACEOF
18985 /* confdefs.h.  */
18986 _ACEOF
18987 cat confdefs.h >>conftest.$ac_ext
18988 cat >>conftest.$ac_ext <<_ACEOF
18989 /* end confdefs.h.  */
18990
18991 /* Override any gcc2 internal prototype to avoid an error.  */
18992 #ifdef __cplusplus
18993 extern "C"
18994 #endif
18995 /* We use char because int might match the return type of a gcc2
18996    builtin and then its argument prototype would still apply.  */
18997 char csinh ();
18998 int
18999 main ()
19000 {
19001 csinh ();
19002   ;
19003   return 0;
19004 }
19005 _ACEOF
19006 rm -f conftest.$ac_objext conftest$ac_exeext
19007 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19008   (eval $ac_link) 2>conftest.er1
19009   ac_status=$?
19010   grep -v '^ *+' conftest.er1 >conftest.err
19011   rm -f conftest.er1
19012   cat conftest.err >&5
19013   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19014   (exit $ac_status); } &&
19015          { ac_try='test -z "$ac_c_werror_flag"
19016                          || test ! -s conftest.err'
19017   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19018   (eval $ac_try) 2>&5
19019   ac_status=$?
19020   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19021   (exit $ac_status); }; } &&
19022          { ac_try='test -s conftest$ac_exeext'
19023   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19024   (eval $ac_try) 2>&5
19025   ac_status=$?
19026   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19027   (exit $ac_status); }; }; then
19028   ac_cv_lib_m_csinh=yes
19029 else
19030   echo "$as_me: failed program was:" >&5
19031 sed 's/^/| /' conftest.$ac_ext >&5
19032
19033 ac_cv_lib_m_csinh=no
19034 fi
19035 rm -f conftest.err conftest.$ac_objext \
19036       conftest$ac_exeext conftest.$ac_ext
19037 LIBS=$ac_check_lib_save_LIBS
19038 fi
19039 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinh" >&5
19040 echo "${ECHO_T}$ac_cv_lib_m_csinh" >&6
19041 if test $ac_cv_lib_m_csinh = yes; then
19042
19043 cat >>confdefs.h <<\_ACEOF
19044 #define HAVE_CSINH 1
19045 _ACEOF
19046
19047 fi
19048
19049 echo "$as_me:$LINENO: checking for csinhl in -lm" >&5
19050 echo $ECHO_N "checking for csinhl in -lm... $ECHO_C" >&6
19051 if test "${ac_cv_lib_m_csinhl+set}" = set; then
19052   echo $ECHO_N "(cached) $ECHO_C" >&6
19053 else
19054   ac_check_lib_save_LIBS=$LIBS
19055 LIBS="-lm  $LIBS"
19056 if test x$gcc_no_link = xyes; then
19057   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19058 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19059    { (exit 1); exit 1; }; }
19060 fi
19061 cat >conftest.$ac_ext <<_ACEOF
19062 /* confdefs.h.  */
19063 _ACEOF
19064 cat confdefs.h >>conftest.$ac_ext
19065 cat >>conftest.$ac_ext <<_ACEOF
19066 /* end confdefs.h.  */
19067
19068 /* Override any gcc2 internal prototype to avoid an error.  */
19069 #ifdef __cplusplus
19070 extern "C"
19071 #endif
19072 /* We use char because int might match the return type of a gcc2
19073    builtin and then its argument prototype would still apply.  */
19074 char csinhl ();
19075 int
19076 main ()
19077 {
19078 csinhl ();
19079   ;
19080   return 0;
19081 }
19082 _ACEOF
19083 rm -f conftest.$ac_objext conftest$ac_exeext
19084 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19085   (eval $ac_link) 2>conftest.er1
19086   ac_status=$?
19087   grep -v '^ *+' conftest.er1 >conftest.err
19088   rm -f conftest.er1
19089   cat conftest.err >&5
19090   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19091   (exit $ac_status); } &&
19092          { ac_try='test -z "$ac_c_werror_flag"
19093                          || test ! -s conftest.err'
19094   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19095   (eval $ac_try) 2>&5
19096   ac_status=$?
19097   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19098   (exit $ac_status); }; } &&
19099          { ac_try='test -s conftest$ac_exeext'
19100   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19101   (eval $ac_try) 2>&5
19102   ac_status=$?
19103   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19104   (exit $ac_status); }; }; then
19105   ac_cv_lib_m_csinhl=yes
19106 else
19107   echo "$as_me: failed program was:" >&5
19108 sed 's/^/| /' conftest.$ac_ext >&5
19109
19110 ac_cv_lib_m_csinhl=no
19111 fi
19112 rm -f conftest.err conftest.$ac_objext \
19113       conftest$ac_exeext conftest.$ac_ext
19114 LIBS=$ac_check_lib_save_LIBS
19115 fi
19116 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinhl" >&5
19117 echo "${ECHO_T}$ac_cv_lib_m_csinhl" >&6
19118 if test $ac_cv_lib_m_csinhl = yes; then
19119
19120 cat >>confdefs.h <<\_ACEOF
19121 #define HAVE_CSINHL 1
19122 _ACEOF
19123
19124 fi
19125
19126 echo "$as_me:$LINENO: checking for sqrtf in -lm" >&5
19127 echo $ECHO_N "checking for sqrtf in -lm... $ECHO_C" >&6
19128 if test "${ac_cv_lib_m_sqrtf+set}" = set; then
19129   echo $ECHO_N "(cached) $ECHO_C" >&6
19130 else
19131   ac_check_lib_save_LIBS=$LIBS
19132 LIBS="-lm  $LIBS"
19133 if test x$gcc_no_link = xyes; then
19134   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19135 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19136    { (exit 1); exit 1; }; }
19137 fi
19138 cat >conftest.$ac_ext <<_ACEOF
19139 /* confdefs.h.  */
19140 _ACEOF
19141 cat confdefs.h >>conftest.$ac_ext
19142 cat >>conftest.$ac_ext <<_ACEOF
19143 /* end confdefs.h.  */
19144
19145 /* Override any gcc2 internal prototype to avoid an error.  */
19146 #ifdef __cplusplus
19147 extern "C"
19148 #endif
19149 /* We use char because int might match the return type of a gcc2
19150    builtin and then its argument prototype would still apply.  */
19151 char sqrtf ();
19152 int
19153 main ()
19154 {
19155 sqrtf ();
19156   ;
19157   return 0;
19158 }
19159 _ACEOF
19160 rm -f conftest.$ac_objext conftest$ac_exeext
19161 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19162   (eval $ac_link) 2>conftest.er1
19163   ac_status=$?
19164   grep -v '^ *+' conftest.er1 >conftest.err
19165   rm -f conftest.er1
19166   cat conftest.err >&5
19167   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19168   (exit $ac_status); } &&
19169          { ac_try='test -z "$ac_c_werror_flag"
19170                          || test ! -s conftest.err'
19171   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19172   (eval $ac_try) 2>&5
19173   ac_status=$?
19174   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19175   (exit $ac_status); }; } &&
19176          { ac_try='test -s conftest$ac_exeext'
19177   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19178   (eval $ac_try) 2>&5
19179   ac_status=$?
19180   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19181   (exit $ac_status); }; }; then
19182   ac_cv_lib_m_sqrtf=yes
19183 else
19184   echo "$as_me: failed program was:" >&5
19185 sed 's/^/| /' conftest.$ac_ext >&5
19186
19187 ac_cv_lib_m_sqrtf=no
19188 fi
19189 rm -f conftest.err conftest.$ac_objext \
19190       conftest$ac_exeext conftest.$ac_ext
19191 LIBS=$ac_check_lib_save_LIBS
19192 fi
19193 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrtf" >&5
19194 echo "${ECHO_T}$ac_cv_lib_m_sqrtf" >&6
19195 if test $ac_cv_lib_m_sqrtf = yes; then
19196
19197 cat >>confdefs.h <<\_ACEOF
19198 #define HAVE_SQRTF 1
19199 _ACEOF
19200
19201 fi
19202
19203 echo "$as_me:$LINENO: checking for sqrt in -lm" >&5
19204 echo $ECHO_N "checking for sqrt in -lm... $ECHO_C" >&6
19205 if test "${ac_cv_lib_m_sqrt+set}" = set; then
19206   echo $ECHO_N "(cached) $ECHO_C" >&6
19207 else
19208   ac_check_lib_save_LIBS=$LIBS
19209 LIBS="-lm  $LIBS"
19210 if test x$gcc_no_link = xyes; then
19211   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19212 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19213    { (exit 1); exit 1; }; }
19214 fi
19215 cat >conftest.$ac_ext <<_ACEOF
19216 /* confdefs.h.  */
19217 _ACEOF
19218 cat confdefs.h >>conftest.$ac_ext
19219 cat >>conftest.$ac_ext <<_ACEOF
19220 /* end confdefs.h.  */
19221
19222 /* Override any gcc2 internal prototype to avoid an error.  */
19223 #ifdef __cplusplus
19224 extern "C"
19225 #endif
19226 /* We use char because int might match the return type of a gcc2
19227    builtin and then its argument prototype would still apply.  */
19228 char sqrt ();
19229 int
19230 main ()
19231 {
19232 sqrt ();
19233   ;
19234   return 0;
19235 }
19236 _ACEOF
19237 rm -f conftest.$ac_objext conftest$ac_exeext
19238 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19239   (eval $ac_link) 2>conftest.er1
19240   ac_status=$?
19241   grep -v '^ *+' conftest.er1 >conftest.err
19242   rm -f conftest.er1
19243   cat conftest.err >&5
19244   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19245   (exit $ac_status); } &&
19246          { ac_try='test -z "$ac_c_werror_flag"
19247                          || test ! -s conftest.err'
19248   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19249   (eval $ac_try) 2>&5
19250   ac_status=$?
19251   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19252   (exit $ac_status); }; } &&
19253          { ac_try='test -s conftest$ac_exeext'
19254   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19255   (eval $ac_try) 2>&5
19256   ac_status=$?
19257   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19258   (exit $ac_status); }; }; then
19259   ac_cv_lib_m_sqrt=yes
19260 else
19261   echo "$as_me: failed program was:" >&5
19262 sed 's/^/| /' conftest.$ac_ext >&5
19263
19264 ac_cv_lib_m_sqrt=no
19265 fi
19266 rm -f conftest.err conftest.$ac_objext \
19267       conftest$ac_exeext conftest.$ac_ext
19268 LIBS=$ac_check_lib_save_LIBS
19269 fi
19270 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrt" >&5
19271 echo "${ECHO_T}$ac_cv_lib_m_sqrt" >&6
19272 if test $ac_cv_lib_m_sqrt = yes; then
19273
19274 cat >>confdefs.h <<\_ACEOF
19275 #define HAVE_SQRT 1
19276 _ACEOF
19277
19278 fi
19279
19280 echo "$as_me:$LINENO: checking for sqrtl in -lm" >&5
19281 echo $ECHO_N "checking for sqrtl in -lm... $ECHO_C" >&6
19282 if test "${ac_cv_lib_m_sqrtl+set}" = set; then
19283   echo $ECHO_N "(cached) $ECHO_C" >&6
19284 else
19285   ac_check_lib_save_LIBS=$LIBS
19286 LIBS="-lm  $LIBS"
19287 if test x$gcc_no_link = xyes; then
19288   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19289 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19290    { (exit 1); exit 1; }; }
19291 fi
19292 cat >conftest.$ac_ext <<_ACEOF
19293 /* confdefs.h.  */
19294 _ACEOF
19295 cat confdefs.h >>conftest.$ac_ext
19296 cat >>conftest.$ac_ext <<_ACEOF
19297 /* end confdefs.h.  */
19298
19299 /* Override any gcc2 internal prototype to avoid an error.  */
19300 #ifdef __cplusplus
19301 extern "C"
19302 #endif
19303 /* We use char because int might match the return type of a gcc2
19304    builtin and then its argument prototype would still apply.  */
19305 char sqrtl ();
19306 int
19307 main ()
19308 {
19309 sqrtl ();
19310   ;
19311   return 0;
19312 }
19313 _ACEOF
19314 rm -f conftest.$ac_objext conftest$ac_exeext
19315 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19316   (eval $ac_link) 2>conftest.er1
19317   ac_status=$?
19318   grep -v '^ *+' conftest.er1 >conftest.err
19319   rm -f conftest.er1
19320   cat conftest.err >&5
19321   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19322   (exit $ac_status); } &&
19323          { ac_try='test -z "$ac_c_werror_flag"
19324                          || test ! -s conftest.err'
19325   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19326   (eval $ac_try) 2>&5
19327   ac_status=$?
19328   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19329   (exit $ac_status); }; } &&
19330          { ac_try='test -s conftest$ac_exeext'
19331   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19332   (eval $ac_try) 2>&5
19333   ac_status=$?
19334   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19335   (exit $ac_status); }; }; then
19336   ac_cv_lib_m_sqrtl=yes
19337 else
19338   echo "$as_me: failed program was:" >&5
19339 sed 's/^/| /' conftest.$ac_ext >&5
19340
19341 ac_cv_lib_m_sqrtl=no
19342 fi
19343 rm -f conftest.err conftest.$ac_objext \
19344       conftest$ac_exeext conftest.$ac_ext
19345 LIBS=$ac_check_lib_save_LIBS
19346 fi
19347 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrtl" >&5
19348 echo "${ECHO_T}$ac_cv_lib_m_sqrtl" >&6
19349 if test $ac_cv_lib_m_sqrtl = yes; then
19350
19351 cat >>confdefs.h <<\_ACEOF
19352 #define HAVE_SQRTL 1
19353 _ACEOF
19354
19355 fi
19356
19357 echo "$as_me:$LINENO: checking for csqrtf in -lm" >&5
19358 echo $ECHO_N "checking for csqrtf in -lm... $ECHO_C" >&6
19359 if test "${ac_cv_lib_m_csqrtf+set}" = set; then
19360   echo $ECHO_N "(cached) $ECHO_C" >&6
19361 else
19362   ac_check_lib_save_LIBS=$LIBS
19363 LIBS="-lm  $LIBS"
19364 if test x$gcc_no_link = xyes; then
19365   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19366 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19367    { (exit 1); exit 1; }; }
19368 fi
19369 cat >conftest.$ac_ext <<_ACEOF
19370 /* confdefs.h.  */
19371 _ACEOF
19372 cat confdefs.h >>conftest.$ac_ext
19373 cat >>conftest.$ac_ext <<_ACEOF
19374 /* end confdefs.h.  */
19375
19376 /* Override any gcc2 internal prototype to avoid an error.  */
19377 #ifdef __cplusplus
19378 extern "C"
19379 #endif
19380 /* We use char because int might match the return type of a gcc2
19381    builtin and then its argument prototype would still apply.  */
19382 char csqrtf ();
19383 int
19384 main ()
19385 {
19386 csqrtf ();
19387   ;
19388   return 0;
19389 }
19390 _ACEOF
19391 rm -f conftest.$ac_objext conftest$ac_exeext
19392 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19393   (eval $ac_link) 2>conftest.er1
19394   ac_status=$?
19395   grep -v '^ *+' conftest.er1 >conftest.err
19396   rm -f conftest.er1
19397   cat conftest.err >&5
19398   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19399   (exit $ac_status); } &&
19400          { ac_try='test -z "$ac_c_werror_flag"
19401                          || test ! -s conftest.err'
19402   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19403   (eval $ac_try) 2>&5
19404   ac_status=$?
19405   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19406   (exit $ac_status); }; } &&
19407          { ac_try='test -s conftest$ac_exeext'
19408   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19409   (eval $ac_try) 2>&5
19410   ac_status=$?
19411   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19412   (exit $ac_status); }; }; then
19413   ac_cv_lib_m_csqrtf=yes
19414 else
19415   echo "$as_me: failed program was:" >&5
19416 sed 's/^/| /' conftest.$ac_ext >&5
19417
19418 ac_cv_lib_m_csqrtf=no
19419 fi
19420 rm -f conftest.err conftest.$ac_objext \
19421       conftest$ac_exeext conftest.$ac_ext
19422 LIBS=$ac_check_lib_save_LIBS
19423 fi
19424 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrtf" >&5
19425 echo "${ECHO_T}$ac_cv_lib_m_csqrtf" >&6
19426 if test $ac_cv_lib_m_csqrtf = yes; then
19427
19428 cat >>confdefs.h <<\_ACEOF
19429 #define HAVE_CSQRTF 1
19430 _ACEOF
19431
19432 fi
19433
19434 echo "$as_me:$LINENO: checking for csqrt in -lm" >&5
19435 echo $ECHO_N "checking for csqrt in -lm... $ECHO_C" >&6
19436 if test "${ac_cv_lib_m_csqrt+set}" = set; then
19437   echo $ECHO_N "(cached) $ECHO_C" >&6
19438 else
19439   ac_check_lib_save_LIBS=$LIBS
19440 LIBS="-lm  $LIBS"
19441 if test x$gcc_no_link = xyes; then
19442   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19443 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19444    { (exit 1); exit 1; }; }
19445 fi
19446 cat >conftest.$ac_ext <<_ACEOF
19447 /* confdefs.h.  */
19448 _ACEOF
19449 cat confdefs.h >>conftest.$ac_ext
19450 cat >>conftest.$ac_ext <<_ACEOF
19451 /* end confdefs.h.  */
19452
19453 /* Override any gcc2 internal prototype to avoid an error.  */
19454 #ifdef __cplusplus
19455 extern "C"
19456 #endif
19457 /* We use char because int might match the return type of a gcc2
19458    builtin and then its argument prototype would still apply.  */
19459 char csqrt ();
19460 int
19461 main ()
19462 {
19463 csqrt ();
19464   ;
19465   return 0;
19466 }
19467 _ACEOF
19468 rm -f conftest.$ac_objext conftest$ac_exeext
19469 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19470   (eval $ac_link) 2>conftest.er1
19471   ac_status=$?
19472   grep -v '^ *+' conftest.er1 >conftest.err
19473   rm -f conftest.er1
19474   cat conftest.err >&5
19475   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19476   (exit $ac_status); } &&
19477          { ac_try='test -z "$ac_c_werror_flag"
19478                          || test ! -s conftest.err'
19479   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19480   (eval $ac_try) 2>&5
19481   ac_status=$?
19482   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19483   (exit $ac_status); }; } &&
19484          { ac_try='test -s conftest$ac_exeext'
19485   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19486   (eval $ac_try) 2>&5
19487   ac_status=$?
19488   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19489   (exit $ac_status); }; }; then
19490   ac_cv_lib_m_csqrt=yes
19491 else
19492   echo "$as_me: failed program was:" >&5
19493 sed 's/^/| /' conftest.$ac_ext >&5
19494
19495 ac_cv_lib_m_csqrt=no
19496 fi
19497 rm -f conftest.err conftest.$ac_objext \
19498       conftest$ac_exeext conftest.$ac_ext
19499 LIBS=$ac_check_lib_save_LIBS
19500 fi
19501 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrt" >&5
19502 echo "${ECHO_T}$ac_cv_lib_m_csqrt" >&6
19503 if test $ac_cv_lib_m_csqrt = yes; then
19504
19505 cat >>confdefs.h <<\_ACEOF
19506 #define HAVE_CSQRT 1
19507 _ACEOF
19508
19509 fi
19510
19511 echo "$as_me:$LINENO: checking for csqrtl in -lm" >&5
19512 echo $ECHO_N "checking for csqrtl in -lm... $ECHO_C" >&6
19513 if test "${ac_cv_lib_m_csqrtl+set}" = set; then
19514   echo $ECHO_N "(cached) $ECHO_C" >&6
19515 else
19516   ac_check_lib_save_LIBS=$LIBS
19517 LIBS="-lm  $LIBS"
19518 if test x$gcc_no_link = xyes; then
19519   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19520 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19521    { (exit 1); exit 1; }; }
19522 fi
19523 cat >conftest.$ac_ext <<_ACEOF
19524 /* confdefs.h.  */
19525 _ACEOF
19526 cat confdefs.h >>conftest.$ac_ext
19527 cat >>conftest.$ac_ext <<_ACEOF
19528 /* end confdefs.h.  */
19529
19530 /* Override any gcc2 internal prototype to avoid an error.  */
19531 #ifdef __cplusplus
19532 extern "C"
19533 #endif
19534 /* We use char because int might match the return type of a gcc2
19535    builtin and then its argument prototype would still apply.  */
19536 char csqrtl ();
19537 int
19538 main ()
19539 {
19540 csqrtl ();
19541   ;
19542   return 0;
19543 }
19544 _ACEOF
19545 rm -f conftest.$ac_objext conftest$ac_exeext
19546 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19547   (eval $ac_link) 2>conftest.er1
19548   ac_status=$?
19549   grep -v '^ *+' conftest.er1 >conftest.err
19550   rm -f conftest.er1
19551   cat conftest.err >&5
19552   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19553   (exit $ac_status); } &&
19554          { ac_try='test -z "$ac_c_werror_flag"
19555                          || test ! -s conftest.err'
19556   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19557   (eval $ac_try) 2>&5
19558   ac_status=$?
19559   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19560   (exit $ac_status); }; } &&
19561          { ac_try='test -s conftest$ac_exeext'
19562   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19563   (eval $ac_try) 2>&5
19564   ac_status=$?
19565   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19566   (exit $ac_status); }; }; then
19567   ac_cv_lib_m_csqrtl=yes
19568 else
19569   echo "$as_me: failed program was:" >&5
19570 sed 's/^/| /' conftest.$ac_ext >&5
19571
19572 ac_cv_lib_m_csqrtl=no
19573 fi
19574 rm -f conftest.err conftest.$ac_objext \
19575       conftest$ac_exeext conftest.$ac_ext
19576 LIBS=$ac_check_lib_save_LIBS
19577 fi
19578 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrtl" >&5
19579 echo "${ECHO_T}$ac_cv_lib_m_csqrtl" >&6
19580 if test $ac_cv_lib_m_csqrtl = yes; then
19581
19582 cat >>confdefs.h <<\_ACEOF
19583 #define HAVE_CSQRTL 1
19584 _ACEOF
19585
19586 fi
19587
19588 echo "$as_me:$LINENO: checking for tanf in -lm" >&5
19589 echo $ECHO_N "checking for tanf in -lm... $ECHO_C" >&6
19590 if test "${ac_cv_lib_m_tanf+set}" = set; then
19591   echo $ECHO_N "(cached) $ECHO_C" >&6
19592 else
19593   ac_check_lib_save_LIBS=$LIBS
19594 LIBS="-lm  $LIBS"
19595 if test x$gcc_no_link = xyes; then
19596   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19597 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19598    { (exit 1); exit 1; }; }
19599 fi
19600 cat >conftest.$ac_ext <<_ACEOF
19601 /* confdefs.h.  */
19602 _ACEOF
19603 cat confdefs.h >>conftest.$ac_ext
19604 cat >>conftest.$ac_ext <<_ACEOF
19605 /* end confdefs.h.  */
19606
19607 /* Override any gcc2 internal prototype to avoid an error.  */
19608 #ifdef __cplusplus
19609 extern "C"
19610 #endif
19611 /* We use char because int might match the return type of a gcc2
19612    builtin and then its argument prototype would still apply.  */
19613 char tanf ();
19614 int
19615 main ()
19616 {
19617 tanf ();
19618   ;
19619   return 0;
19620 }
19621 _ACEOF
19622 rm -f conftest.$ac_objext conftest$ac_exeext
19623 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19624   (eval $ac_link) 2>conftest.er1
19625   ac_status=$?
19626   grep -v '^ *+' conftest.er1 >conftest.err
19627   rm -f conftest.er1
19628   cat conftest.err >&5
19629   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19630   (exit $ac_status); } &&
19631          { ac_try='test -z "$ac_c_werror_flag"
19632                          || test ! -s conftest.err'
19633   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19634   (eval $ac_try) 2>&5
19635   ac_status=$?
19636   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19637   (exit $ac_status); }; } &&
19638          { ac_try='test -s conftest$ac_exeext'
19639   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19640   (eval $ac_try) 2>&5
19641   ac_status=$?
19642   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19643   (exit $ac_status); }; }; then
19644   ac_cv_lib_m_tanf=yes
19645 else
19646   echo "$as_me: failed program was:" >&5
19647 sed 's/^/| /' conftest.$ac_ext >&5
19648
19649 ac_cv_lib_m_tanf=no
19650 fi
19651 rm -f conftest.err conftest.$ac_objext \
19652       conftest$ac_exeext conftest.$ac_ext
19653 LIBS=$ac_check_lib_save_LIBS
19654 fi
19655 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanf" >&5
19656 echo "${ECHO_T}$ac_cv_lib_m_tanf" >&6
19657 if test $ac_cv_lib_m_tanf = yes; then
19658
19659 cat >>confdefs.h <<\_ACEOF
19660 #define HAVE_TANF 1
19661 _ACEOF
19662
19663 fi
19664
19665 echo "$as_me:$LINENO: checking for tan in -lm" >&5
19666 echo $ECHO_N "checking for tan in -lm... $ECHO_C" >&6
19667 if test "${ac_cv_lib_m_tan+set}" = set; then
19668   echo $ECHO_N "(cached) $ECHO_C" >&6
19669 else
19670   ac_check_lib_save_LIBS=$LIBS
19671 LIBS="-lm  $LIBS"
19672 if test x$gcc_no_link = xyes; then
19673   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19674 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19675    { (exit 1); exit 1; }; }
19676 fi
19677 cat >conftest.$ac_ext <<_ACEOF
19678 /* confdefs.h.  */
19679 _ACEOF
19680 cat confdefs.h >>conftest.$ac_ext
19681 cat >>conftest.$ac_ext <<_ACEOF
19682 /* end confdefs.h.  */
19683
19684 /* Override any gcc2 internal prototype to avoid an error.  */
19685 #ifdef __cplusplus
19686 extern "C"
19687 #endif
19688 /* We use char because int might match the return type of a gcc2
19689    builtin and then its argument prototype would still apply.  */
19690 char tan ();
19691 int
19692 main ()
19693 {
19694 tan ();
19695   ;
19696   return 0;
19697 }
19698 _ACEOF
19699 rm -f conftest.$ac_objext conftest$ac_exeext
19700 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19701   (eval $ac_link) 2>conftest.er1
19702   ac_status=$?
19703   grep -v '^ *+' conftest.er1 >conftest.err
19704   rm -f conftest.er1
19705   cat conftest.err >&5
19706   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19707   (exit $ac_status); } &&
19708          { ac_try='test -z "$ac_c_werror_flag"
19709                          || test ! -s conftest.err'
19710   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19711   (eval $ac_try) 2>&5
19712   ac_status=$?
19713   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19714   (exit $ac_status); }; } &&
19715          { ac_try='test -s conftest$ac_exeext'
19716   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19717   (eval $ac_try) 2>&5
19718   ac_status=$?
19719   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19720   (exit $ac_status); }; }; then
19721   ac_cv_lib_m_tan=yes
19722 else
19723   echo "$as_me: failed program was:" >&5
19724 sed 's/^/| /' conftest.$ac_ext >&5
19725
19726 ac_cv_lib_m_tan=no
19727 fi
19728 rm -f conftest.err conftest.$ac_objext \
19729       conftest$ac_exeext conftest.$ac_ext
19730 LIBS=$ac_check_lib_save_LIBS
19731 fi
19732 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tan" >&5
19733 echo "${ECHO_T}$ac_cv_lib_m_tan" >&6
19734 if test $ac_cv_lib_m_tan = yes; then
19735
19736 cat >>confdefs.h <<\_ACEOF
19737 #define HAVE_TAN 1
19738 _ACEOF
19739
19740 fi
19741
19742 echo "$as_me:$LINENO: checking for tanl in -lm" >&5
19743 echo $ECHO_N "checking for tanl in -lm... $ECHO_C" >&6
19744 if test "${ac_cv_lib_m_tanl+set}" = set; then
19745   echo $ECHO_N "(cached) $ECHO_C" >&6
19746 else
19747   ac_check_lib_save_LIBS=$LIBS
19748 LIBS="-lm  $LIBS"
19749 if test x$gcc_no_link = xyes; then
19750   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19751 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19752    { (exit 1); exit 1; }; }
19753 fi
19754 cat >conftest.$ac_ext <<_ACEOF
19755 /* confdefs.h.  */
19756 _ACEOF
19757 cat confdefs.h >>conftest.$ac_ext
19758 cat >>conftest.$ac_ext <<_ACEOF
19759 /* end confdefs.h.  */
19760
19761 /* Override any gcc2 internal prototype to avoid an error.  */
19762 #ifdef __cplusplus
19763 extern "C"
19764 #endif
19765 /* We use char because int might match the return type of a gcc2
19766    builtin and then its argument prototype would still apply.  */
19767 char tanl ();
19768 int
19769 main ()
19770 {
19771 tanl ();
19772   ;
19773   return 0;
19774 }
19775 _ACEOF
19776 rm -f conftest.$ac_objext conftest$ac_exeext
19777 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19778   (eval $ac_link) 2>conftest.er1
19779   ac_status=$?
19780   grep -v '^ *+' conftest.er1 >conftest.err
19781   rm -f conftest.er1
19782   cat conftest.err >&5
19783   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19784   (exit $ac_status); } &&
19785          { ac_try='test -z "$ac_c_werror_flag"
19786                          || test ! -s conftest.err'
19787   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19788   (eval $ac_try) 2>&5
19789   ac_status=$?
19790   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19791   (exit $ac_status); }; } &&
19792          { ac_try='test -s conftest$ac_exeext'
19793   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19794   (eval $ac_try) 2>&5
19795   ac_status=$?
19796   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19797   (exit $ac_status); }; }; then
19798   ac_cv_lib_m_tanl=yes
19799 else
19800   echo "$as_me: failed program was:" >&5
19801 sed 's/^/| /' conftest.$ac_ext >&5
19802
19803 ac_cv_lib_m_tanl=no
19804 fi
19805 rm -f conftest.err conftest.$ac_objext \
19806       conftest$ac_exeext conftest.$ac_ext
19807 LIBS=$ac_check_lib_save_LIBS
19808 fi
19809 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanl" >&5
19810 echo "${ECHO_T}$ac_cv_lib_m_tanl" >&6
19811 if test $ac_cv_lib_m_tanl = yes; then
19812
19813 cat >>confdefs.h <<\_ACEOF
19814 #define HAVE_TANL 1
19815 _ACEOF
19816
19817 fi
19818
19819 echo "$as_me:$LINENO: checking for ctanf in -lm" >&5
19820 echo $ECHO_N "checking for ctanf in -lm... $ECHO_C" >&6
19821 if test "${ac_cv_lib_m_ctanf+set}" = set; then
19822   echo $ECHO_N "(cached) $ECHO_C" >&6
19823 else
19824   ac_check_lib_save_LIBS=$LIBS
19825 LIBS="-lm  $LIBS"
19826 if test x$gcc_no_link = xyes; then
19827   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19828 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19829    { (exit 1); exit 1; }; }
19830 fi
19831 cat >conftest.$ac_ext <<_ACEOF
19832 /* confdefs.h.  */
19833 _ACEOF
19834 cat confdefs.h >>conftest.$ac_ext
19835 cat >>conftest.$ac_ext <<_ACEOF
19836 /* end confdefs.h.  */
19837
19838 /* Override any gcc2 internal prototype to avoid an error.  */
19839 #ifdef __cplusplus
19840 extern "C"
19841 #endif
19842 /* We use char because int might match the return type of a gcc2
19843    builtin and then its argument prototype would still apply.  */
19844 char ctanf ();
19845 int
19846 main ()
19847 {
19848 ctanf ();
19849   ;
19850   return 0;
19851 }
19852 _ACEOF
19853 rm -f conftest.$ac_objext conftest$ac_exeext
19854 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19855   (eval $ac_link) 2>conftest.er1
19856   ac_status=$?
19857   grep -v '^ *+' conftest.er1 >conftest.err
19858   rm -f conftest.er1
19859   cat conftest.err >&5
19860   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19861   (exit $ac_status); } &&
19862          { ac_try='test -z "$ac_c_werror_flag"
19863                          || test ! -s conftest.err'
19864   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19865   (eval $ac_try) 2>&5
19866   ac_status=$?
19867   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19868   (exit $ac_status); }; } &&
19869          { ac_try='test -s conftest$ac_exeext'
19870   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19871   (eval $ac_try) 2>&5
19872   ac_status=$?
19873   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19874   (exit $ac_status); }; }; then
19875   ac_cv_lib_m_ctanf=yes
19876 else
19877   echo "$as_me: failed program was:" >&5
19878 sed 's/^/| /' conftest.$ac_ext >&5
19879
19880 ac_cv_lib_m_ctanf=no
19881 fi
19882 rm -f conftest.err conftest.$ac_objext \
19883       conftest$ac_exeext conftest.$ac_ext
19884 LIBS=$ac_check_lib_save_LIBS
19885 fi
19886 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanf" >&5
19887 echo "${ECHO_T}$ac_cv_lib_m_ctanf" >&6
19888 if test $ac_cv_lib_m_ctanf = yes; then
19889
19890 cat >>confdefs.h <<\_ACEOF
19891 #define HAVE_CTANF 1
19892 _ACEOF
19893
19894 fi
19895
19896 echo "$as_me:$LINENO: checking for ctan in -lm" >&5
19897 echo $ECHO_N "checking for ctan in -lm... $ECHO_C" >&6
19898 if test "${ac_cv_lib_m_ctan+set}" = set; then
19899   echo $ECHO_N "(cached) $ECHO_C" >&6
19900 else
19901   ac_check_lib_save_LIBS=$LIBS
19902 LIBS="-lm  $LIBS"
19903 if test x$gcc_no_link = xyes; then
19904   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19905 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19906    { (exit 1); exit 1; }; }
19907 fi
19908 cat >conftest.$ac_ext <<_ACEOF
19909 /* confdefs.h.  */
19910 _ACEOF
19911 cat confdefs.h >>conftest.$ac_ext
19912 cat >>conftest.$ac_ext <<_ACEOF
19913 /* end confdefs.h.  */
19914
19915 /* Override any gcc2 internal prototype to avoid an error.  */
19916 #ifdef __cplusplus
19917 extern "C"
19918 #endif
19919 /* We use char because int might match the return type of a gcc2
19920    builtin and then its argument prototype would still apply.  */
19921 char ctan ();
19922 int
19923 main ()
19924 {
19925 ctan ();
19926   ;
19927   return 0;
19928 }
19929 _ACEOF
19930 rm -f conftest.$ac_objext conftest$ac_exeext
19931 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19932   (eval $ac_link) 2>conftest.er1
19933   ac_status=$?
19934   grep -v '^ *+' conftest.er1 >conftest.err
19935   rm -f conftest.er1
19936   cat conftest.err >&5
19937   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19938   (exit $ac_status); } &&
19939          { ac_try='test -z "$ac_c_werror_flag"
19940                          || test ! -s conftest.err'
19941   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19942   (eval $ac_try) 2>&5
19943   ac_status=$?
19944   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19945   (exit $ac_status); }; } &&
19946          { ac_try='test -s conftest$ac_exeext'
19947   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19948   (eval $ac_try) 2>&5
19949   ac_status=$?
19950   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19951   (exit $ac_status); }; }; then
19952   ac_cv_lib_m_ctan=yes
19953 else
19954   echo "$as_me: failed program was:" >&5
19955 sed 's/^/| /' conftest.$ac_ext >&5
19956
19957 ac_cv_lib_m_ctan=no
19958 fi
19959 rm -f conftest.err conftest.$ac_objext \
19960       conftest$ac_exeext conftest.$ac_ext
19961 LIBS=$ac_check_lib_save_LIBS
19962 fi
19963 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctan" >&5
19964 echo "${ECHO_T}$ac_cv_lib_m_ctan" >&6
19965 if test $ac_cv_lib_m_ctan = yes; then
19966
19967 cat >>confdefs.h <<\_ACEOF
19968 #define HAVE_CTAN 1
19969 _ACEOF
19970
19971 fi
19972
19973 echo "$as_me:$LINENO: checking for ctanl in -lm" >&5
19974 echo $ECHO_N "checking for ctanl in -lm... $ECHO_C" >&6
19975 if test "${ac_cv_lib_m_ctanl+set}" = set; then
19976   echo $ECHO_N "(cached) $ECHO_C" >&6
19977 else
19978   ac_check_lib_save_LIBS=$LIBS
19979 LIBS="-lm  $LIBS"
19980 if test x$gcc_no_link = xyes; then
19981   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19982 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19983    { (exit 1); exit 1; }; }
19984 fi
19985 cat >conftest.$ac_ext <<_ACEOF
19986 /* confdefs.h.  */
19987 _ACEOF
19988 cat confdefs.h >>conftest.$ac_ext
19989 cat >>conftest.$ac_ext <<_ACEOF
19990 /* end confdefs.h.  */
19991
19992 /* Override any gcc2 internal prototype to avoid an error.  */
19993 #ifdef __cplusplus
19994 extern "C"
19995 #endif
19996 /* We use char because int might match the return type of a gcc2
19997    builtin and then its argument prototype would still apply.  */
19998 char ctanl ();
19999 int
20000 main ()
20001 {
20002 ctanl ();
20003   ;
20004   return 0;
20005 }
20006 _ACEOF
20007 rm -f conftest.$ac_objext conftest$ac_exeext
20008 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20009   (eval $ac_link) 2>conftest.er1
20010   ac_status=$?
20011   grep -v '^ *+' conftest.er1 >conftest.err
20012   rm -f conftest.er1
20013   cat conftest.err >&5
20014   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20015   (exit $ac_status); } &&
20016          { ac_try='test -z "$ac_c_werror_flag"
20017                          || test ! -s conftest.err'
20018   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20019   (eval $ac_try) 2>&5
20020   ac_status=$?
20021   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20022   (exit $ac_status); }; } &&
20023          { ac_try='test -s conftest$ac_exeext'
20024   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20025   (eval $ac_try) 2>&5
20026   ac_status=$?
20027   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20028   (exit $ac_status); }; }; then
20029   ac_cv_lib_m_ctanl=yes
20030 else
20031   echo "$as_me: failed program was:" >&5
20032 sed 's/^/| /' conftest.$ac_ext >&5
20033
20034 ac_cv_lib_m_ctanl=no
20035 fi
20036 rm -f conftest.err conftest.$ac_objext \
20037       conftest$ac_exeext conftest.$ac_ext
20038 LIBS=$ac_check_lib_save_LIBS
20039 fi
20040 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanl" >&5
20041 echo "${ECHO_T}$ac_cv_lib_m_ctanl" >&6
20042 if test $ac_cv_lib_m_ctanl = yes; then
20043
20044 cat >>confdefs.h <<\_ACEOF
20045 #define HAVE_CTANL 1
20046 _ACEOF
20047
20048 fi
20049
20050 echo "$as_me:$LINENO: checking for tanhf in -lm" >&5
20051 echo $ECHO_N "checking for tanhf in -lm... $ECHO_C" >&6
20052 if test "${ac_cv_lib_m_tanhf+set}" = set; then
20053   echo $ECHO_N "(cached) $ECHO_C" >&6
20054 else
20055   ac_check_lib_save_LIBS=$LIBS
20056 LIBS="-lm  $LIBS"
20057 if test x$gcc_no_link = xyes; then
20058   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20059 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20060    { (exit 1); exit 1; }; }
20061 fi
20062 cat >conftest.$ac_ext <<_ACEOF
20063 /* confdefs.h.  */
20064 _ACEOF
20065 cat confdefs.h >>conftest.$ac_ext
20066 cat >>conftest.$ac_ext <<_ACEOF
20067 /* end confdefs.h.  */
20068
20069 /* Override any gcc2 internal prototype to avoid an error.  */
20070 #ifdef __cplusplus
20071 extern "C"
20072 #endif
20073 /* We use char because int might match the return type of a gcc2
20074    builtin and then its argument prototype would still apply.  */
20075 char tanhf ();
20076 int
20077 main ()
20078 {
20079 tanhf ();
20080   ;
20081   return 0;
20082 }
20083 _ACEOF
20084 rm -f conftest.$ac_objext conftest$ac_exeext
20085 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20086   (eval $ac_link) 2>conftest.er1
20087   ac_status=$?
20088   grep -v '^ *+' conftest.er1 >conftest.err
20089   rm -f conftest.er1
20090   cat conftest.err >&5
20091   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20092   (exit $ac_status); } &&
20093          { ac_try='test -z "$ac_c_werror_flag"
20094                          || test ! -s conftest.err'
20095   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20096   (eval $ac_try) 2>&5
20097   ac_status=$?
20098   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20099   (exit $ac_status); }; } &&
20100          { ac_try='test -s conftest$ac_exeext'
20101   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20102   (eval $ac_try) 2>&5
20103   ac_status=$?
20104   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20105   (exit $ac_status); }; }; then
20106   ac_cv_lib_m_tanhf=yes
20107 else
20108   echo "$as_me: failed program was:" >&5
20109 sed 's/^/| /' conftest.$ac_ext >&5
20110
20111 ac_cv_lib_m_tanhf=no
20112 fi
20113 rm -f conftest.err conftest.$ac_objext \
20114       conftest$ac_exeext conftest.$ac_ext
20115 LIBS=$ac_check_lib_save_LIBS
20116 fi
20117 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanhf" >&5
20118 echo "${ECHO_T}$ac_cv_lib_m_tanhf" >&6
20119 if test $ac_cv_lib_m_tanhf = yes; then
20120
20121 cat >>confdefs.h <<\_ACEOF
20122 #define HAVE_TANHF 1
20123 _ACEOF
20124
20125 fi
20126
20127 echo "$as_me:$LINENO: checking for tanh in -lm" >&5
20128 echo $ECHO_N "checking for tanh in -lm... $ECHO_C" >&6
20129 if test "${ac_cv_lib_m_tanh+set}" = set; then
20130   echo $ECHO_N "(cached) $ECHO_C" >&6
20131 else
20132   ac_check_lib_save_LIBS=$LIBS
20133 LIBS="-lm  $LIBS"
20134 if test x$gcc_no_link = xyes; then
20135   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20136 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20137    { (exit 1); exit 1; }; }
20138 fi
20139 cat >conftest.$ac_ext <<_ACEOF
20140 /* confdefs.h.  */
20141 _ACEOF
20142 cat confdefs.h >>conftest.$ac_ext
20143 cat >>conftest.$ac_ext <<_ACEOF
20144 /* end confdefs.h.  */
20145
20146 /* Override any gcc2 internal prototype to avoid an error.  */
20147 #ifdef __cplusplus
20148 extern "C"
20149 #endif
20150 /* We use char because int might match the return type of a gcc2
20151    builtin and then its argument prototype would still apply.  */
20152 char tanh ();
20153 int
20154 main ()
20155 {
20156 tanh ();
20157   ;
20158   return 0;
20159 }
20160 _ACEOF
20161 rm -f conftest.$ac_objext conftest$ac_exeext
20162 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20163   (eval $ac_link) 2>conftest.er1
20164   ac_status=$?
20165   grep -v '^ *+' conftest.er1 >conftest.err
20166   rm -f conftest.er1
20167   cat conftest.err >&5
20168   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20169   (exit $ac_status); } &&
20170          { ac_try='test -z "$ac_c_werror_flag"
20171                          || test ! -s conftest.err'
20172   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20173   (eval $ac_try) 2>&5
20174   ac_status=$?
20175   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20176   (exit $ac_status); }; } &&
20177          { ac_try='test -s conftest$ac_exeext'
20178   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20179   (eval $ac_try) 2>&5
20180   ac_status=$?
20181   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20182   (exit $ac_status); }; }; then
20183   ac_cv_lib_m_tanh=yes
20184 else
20185   echo "$as_me: failed program was:" >&5
20186 sed 's/^/| /' conftest.$ac_ext >&5
20187
20188 ac_cv_lib_m_tanh=no
20189 fi
20190 rm -f conftest.err conftest.$ac_objext \
20191       conftest$ac_exeext conftest.$ac_ext
20192 LIBS=$ac_check_lib_save_LIBS
20193 fi
20194 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanh" >&5
20195 echo "${ECHO_T}$ac_cv_lib_m_tanh" >&6
20196 if test $ac_cv_lib_m_tanh = yes; then
20197
20198 cat >>confdefs.h <<\_ACEOF
20199 #define HAVE_TANH 1
20200 _ACEOF
20201
20202 fi
20203
20204 echo "$as_me:$LINENO: checking for tanhl in -lm" >&5
20205 echo $ECHO_N "checking for tanhl in -lm... $ECHO_C" >&6
20206 if test "${ac_cv_lib_m_tanhl+set}" = set; then
20207   echo $ECHO_N "(cached) $ECHO_C" >&6
20208 else
20209   ac_check_lib_save_LIBS=$LIBS
20210 LIBS="-lm  $LIBS"
20211 if test x$gcc_no_link = xyes; then
20212   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20213 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20214    { (exit 1); exit 1; }; }
20215 fi
20216 cat >conftest.$ac_ext <<_ACEOF
20217 /* confdefs.h.  */
20218 _ACEOF
20219 cat confdefs.h >>conftest.$ac_ext
20220 cat >>conftest.$ac_ext <<_ACEOF
20221 /* end confdefs.h.  */
20222
20223 /* Override any gcc2 internal prototype to avoid an error.  */
20224 #ifdef __cplusplus
20225 extern "C"
20226 #endif
20227 /* We use char because int might match the return type of a gcc2
20228    builtin and then its argument prototype would still apply.  */
20229 char tanhl ();
20230 int
20231 main ()
20232 {
20233 tanhl ();
20234   ;
20235   return 0;
20236 }
20237 _ACEOF
20238 rm -f conftest.$ac_objext conftest$ac_exeext
20239 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20240   (eval $ac_link) 2>conftest.er1
20241   ac_status=$?
20242   grep -v '^ *+' conftest.er1 >conftest.err
20243   rm -f conftest.er1
20244   cat conftest.err >&5
20245   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20246   (exit $ac_status); } &&
20247          { ac_try='test -z "$ac_c_werror_flag"
20248                          || test ! -s conftest.err'
20249   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20250   (eval $ac_try) 2>&5
20251   ac_status=$?
20252   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20253   (exit $ac_status); }; } &&
20254          { ac_try='test -s conftest$ac_exeext'
20255   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20256   (eval $ac_try) 2>&5
20257   ac_status=$?
20258   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20259   (exit $ac_status); }; }; then
20260   ac_cv_lib_m_tanhl=yes
20261 else
20262   echo "$as_me: failed program was:" >&5
20263 sed 's/^/| /' conftest.$ac_ext >&5
20264
20265 ac_cv_lib_m_tanhl=no
20266 fi
20267 rm -f conftest.err conftest.$ac_objext \
20268       conftest$ac_exeext conftest.$ac_ext
20269 LIBS=$ac_check_lib_save_LIBS
20270 fi
20271 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanhl" >&5
20272 echo "${ECHO_T}$ac_cv_lib_m_tanhl" >&6
20273 if test $ac_cv_lib_m_tanhl = yes; then
20274
20275 cat >>confdefs.h <<\_ACEOF
20276 #define HAVE_TANHL 1
20277 _ACEOF
20278
20279 fi
20280
20281 echo "$as_me:$LINENO: checking for ctanhf in -lm" >&5
20282 echo $ECHO_N "checking for ctanhf in -lm... $ECHO_C" >&6
20283 if test "${ac_cv_lib_m_ctanhf+set}" = set; then
20284   echo $ECHO_N "(cached) $ECHO_C" >&6
20285 else
20286   ac_check_lib_save_LIBS=$LIBS
20287 LIBS="-lm  $LIBS"
20288 if test x$gcc_no_link = xyes; then
20289   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20290 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20291    { (exit 1); exit 1; }; }
20292 fi
20293 cat >conftest.$ac_ext <<_ACEOF
20294 /* confdefs.h.  */
20295 _ACEOF
20296 cat confdefs.h >>conftest.$ac_ext
20297 cat >>conftest.$ac_ext <<_ACEOF
20298 /* end confdefs.h.  */
20299
20300 /* Override any gcc2 internal prototype to avoid an error.  */
20301 #ifdef __cplusplus
20302 extern "C"
20303 #endif
20304 /* We use char because int might match the return type of a gcc2
20305    builtin and then its argument prototype would still apply.  */
20306 char ctanhf ();
20307 int
20308 main ()
20309 {
20310 ctanhf ();
20311   ;
20312   return 0;
20313 }
20314 _ACEOF
20315 rm -f conftest.$ac_objext conftest$ac_exeext
20316 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20317   (eval $ac_link) 2>conftest.er1
20318   ac_status=$?
20319   grep -v '^ *+' conftest.er1 >conftest.err
20320   rm -f conftest.er1
20321   cat conftest.err >&5
20322   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20323   (exit $ac_status); } &&
20324          { ac_try='test -z "$ac_c_werror_flag"
20325                          || test ! -s conftest.err'
20326   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20327   (eval $ac_try) 2>&5
20328   ac_status=$?
20329   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20330   (exit $ac_status); }; } &&
20331          { ac_try='test -s conftest$ac_exeext'
20332   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20333   (eval $ac_try) 2>&5
20334   ac_status=$?
20335   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20336   (exit $ac_status); }; }; then
20337   ac_cv_lib_m_ctanhf=yes
20338 else
20339   echo "$as_me: failed program was:" >&5
20340 sed 's/^/| /' conftest.$ac_ext >&5
20341
20342 ac_cv_lib_m_ctanhf=no
20343 fi
20344 rm -f conftest.err conftest.$ac_objext \
20345       conftest$ac_exeext conftest.$ac_ext
20346 LIBS=$ac_check_lib_save_LIBS
20347 fi
20348 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanhf" >&5
20349 echo "${ECHO_T}$ac_cv_lib_m_ctanhf" >&6
20350 if test $ac_cv_lib_m_ctanhf = yes; then
20351
20352 cat >>confdefs.h <<\_ACEOF
20353 #define HAVE_CTANHF 1
20354 _ACEOF
20355
20356 fi
20357
20358 echo "$as_me:$LINENO: checking for ctanh in -lm" >&5
20359 echo $ECHO_N "checking for ctanh in -lm... $ECHO_C" >&6
20360 if test "${ac_cv_lib_m_ctanh+set}" = set; then
20361   echo $ECHO_N "(cached) $ECHO_C" >&6
20362 else
20363   ac_check_lib_save_LIBS=$LIBS
20364 LIBS="-lm  $LIBS"
20365 if test x$gcc_no_link = xyes; then
20366   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20367 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20368    { (exit 1); exit 1; }; }
20369 fi
20370 cat >conftest.$ac_ext <<_ACEOF
20371 /* confdefs.h.  */
20372 _ACEOF
20373 cat confdefs.h >>conftest.$ac_ext
20374 cat >>conftest.$ac_ext <<_ACEOF
20375 /* end confdefs.h.  */
20376
20377 /* Override any gcc2 internal prototype to avoid an error.  */
20378 #ifdef __cplusplus
20379 extern "C"
20380 #endif
20381 /* We use char because int might match the return type of a gcc2
20382    builtin and then its argument prototype would still apply.  */
20383 char ctanh ();
20384 int
20385 main ()
20386 {
20387 ctanh ();
20388   ;
20389   return 0;
20390 }
20391 _ACEOF
20392 rm -f conftest.$ac_objext conftest$ac_exeext
20393 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20394   (eval $ac_link) 2>conftest.er1
20395   ac_status=$?
20396   grep -v '^ *+' conftest.er1 >conftest.err
20397   rm -f conftest.er1
20398   cat conftest.err >&5
20399   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20400   (exit $ac_status); } &&
20401          { ac_try='test -z "$ac_c_werror_flag"
20402                          || test ! -s conftest.err'
20403   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20404   (eval $ac_try) 2>&5
20405   ac_status=$?
20406   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20407   (exit $ac_status); }; } &&
20408          { ac_try='test -s conftest$ac_exeext'
20409   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20410   (eval $ac_try) 2>&5
20411   ac_status=$?
20412   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20413   (exit $ac_status); }; }; then
20414   ac_cv_lib_m_ctanh=yes
20415 else
20416   echo "$as_me: failed program was:" >&5
20417 sed 's/^/| /' conftest.$ac_ext >&5
20418
20419 ac_cv_lib_m_ctanh=no
20420 fi
20421 rm -f conftest.err conftest.$ac_objext \
20422       conftest$ac_exeext conftest.$ac_ext
20423 LIBS=$ac_check_lib_save_LIBS
20424 fi
20425 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanh" >&5
20426 echo "${ECHO_T}$ac_cv_lib_m_ctanh" >&6
20427 if test $ac_cv_lib_m_ctanh = yes; then
20428
20429 cat >>confdefs.h <<\_ACEOF
20430 #define HAVE_CTANH 1
20431 _ACEOF
20432
20433 fi
20434
20435 echo "$as_me:$LINENO: checking for ctanhl in -lm" >&5
20436 echo $ECHO_N "checking for ctanhl in -lm... $ECHO_C" >&6
20437 if test "${ac_cv_lib_m_ctanhl+set}" = set; then
20438   echo $ECHO_N "(cached) $ECHO_C" >&6
20439 else
20440   ac_check_lib_save_LIBS=$LIBS
20441 LIBS="-lm  $LIBS"
20442 if test x$gcc_no_link = xyes; then
20443   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20444 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20445    { (exit 1); exit 1; }; }
20446 fi
20447 cat >conftest.$ac_ext <<_ACEOF
20448 /* confdefs.h.  */
20449 _ACEOF
20450 cat confdefs.h >>conftest.$ac_ext
20451 cat >>conftest.$ac_ext <<_ACEOF
20452 /* end confdefs.h.  */
20453
20454 /* Override any gcc2 internal prototype to avoid an error.  */
20455 #ifdef __cplusplus
20456 extern "C"
20457 #endif
20458 /* We use char because int might match the return type of a gcc2
20459    builtin and then its argument prototype would still apply.  */
20460 char ctanhl ();
20461 int
20462 main ()
20463 {
20464 ctanhl ();
20465   ;
20466   return 0;
20467 }
20468 _ACEOF
20469 rm -f conftest.$ac_objext conftest$ac_exeext
20470 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20471   (eval $ac_link) 2>conftest.er1
20472   ac_status=$?
20473   grep -v '^ *+' conftest.er1 >conftest.err
20474   rm -f conftest.er1
20475   cat conftest.err >&5
20476   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20477   (exit $ac_status); } &&
20478          { ac_try='test -z "$ac_c_werror_flag"
20479                          || test ! -s conftest.err'
20480   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20481   (eval $ac_try) 2>&5
20482   ac_status=$?
20483   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20484   (exit $ac_status); }; } &&
20485          { ac_try='test -s conftest$ac_exeext'
20486   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20487   (eval $ac_try) 2>&5
20488   ac_status=$?
20489   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20490   (exit $ac_status); }; }; then
20491   ac_cv_lib_m_ctanhl=yes
20492 else
20493   echo "$as_me: failed program was:" >&5
20494 sed 's/^/| /' conftest.$ac_ext >&5
20495
20496 ac_cv_lib_m_ctanhl=no
20497 fi
20498 rm -f conftest.err conftest.$ac_objext \
20499       conftest$ac_exeext conftest.$ac_ext
20500 LIBS=$ac_check_lib_save_LIBS
20501 fi
20502 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanhl" >&5
20503 echo "${ECHO_T}$ac_cv_lib_m_ctanhl" >&6
20504 if test $ac_cv_lib_m_ctanhl = yes; then
20505
20506 cat >>confdefs.h <<\_ACEOF
20507 #define HAVE_CTANHL 1
20508 _ACEOF
20509
20510 fi
20511
20512 echo "$as_me:$LINENO: checking for truncf in -lm" >&5
20513 echo $ECHO_N "checking for truncf in -lm... $ECHO_C" >&6
20514 if test "${ac_cv_lib_m_truncf+set}" = set; then
20515   echo $ECHO_N "(cached) $ECHO_C" >&6
20516 else
20517   ac_check_lib_save_LIBS=$LIBS
20518 LIBS="-lm  $LIBS"
20519 if test x$gcc_no_link = xyes; then
20520   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20521 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20522    { (exit 1); exit 1; }; }
20523 fi
20524 cat >conftest.$ac_ext <<_ACEOF
20525 /* confdefs.h.  */
20526 _ACEOF
20527 cat confdefs.h >>conftest.$ac_ext
20528 cat >>conftest.$ac_ext <<_ACEOF
20529 /* end confdefs.h.  */
20530
20531 /* Override any gcc2 internal prototype to avoid an error.  */
20532 #ifdef __cplusplus
20533 extern "C"
20534 #endif
20535 /* We use char because int might match the return type of a gcc2
20536    builtin and then its argument prototype would still apply.  */
20537 char truncf ();
20538 int
20539 main ()
20540 {
20541 truncf ();
20542   ;
20543   return 0;
20544 }
20545 _ACEOF
20546 rm -f conftest.$ac_objext conftest$ac_exeext
20547 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20548   (eval $ac_link) 2>conftest.er1
20549   ac_status=$?
20550   grep -v '^ *+' conftest.er1 >conftest.err
20551   rm -f conftest.er1
20552   cat conftest.err >&5
20553   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20554   (exit $ac_status); } &&
20555          { ac_try='test -z "$ac_c_werror_flag"
20556                          || test ! -s conftest.err'
20557   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20558   (eval $ac_try) 2>&5
20559   ac_status=$?
20560   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20561   (exit $ac_status); }; } &&
20562          { ac_try='test -s conftest$ac_exeext'
20563   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20564   (eval $ac_try) 2>&5
20565   ac_status=$?
20566   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20567   (exit $ac_status); }; }; then
20568   ac_cv_lib_m_truncf=yes
20569 else
20570   echo "$as_me: failed program was:" >&5
20571 sed 's/^/| /' conftest.$ac_ext >&5
20572
20573 ac_cv_lib_m_truncf=no
20574 fi
20575 rm -f conftest.err conftest.$ac_objext \
20576       conftest$ac_exeext conftest.$ac_ext
20577 LIBS=$ac_check_lib_save_LIBS
20578 fi
20579 echo "$as_me:$LINENO: result: $ac_cv_lib_m_truncf" >&5
20580 echo "${ECHO_T}$ac_cv_lib_m_truncf" >&6
20581 if test $ac_cv_lib_m_truncf = yes; then
20582
20583 cat >>confdefs.h <<\_ACEOF
20584 #define HAVE_TRUNCF 1
20585 _ACEOF
20586
20587 fi
20588
20589 echo "$as_me:$LINENO: checking for trunc in -lm" >&5
20590 echo $ECHO_N "checking for trunc in -lm... $ECHO_C" >&6
20591 if test "${ac_cv_lib_m_trunc+set}" = set; then
20592   echo $ECHO_N "(cached) $ECHO_C" >&6
20593 else
20594   ac_check_lib_save_LIBS=$LIBS
20595 LIBS="-lm  $LIBS"
20596 if test x$gcc_no_link = xyes; then
20597   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20598 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20599    { (exit 1); exit 1; }; }
20600 fi
20601 cat >conftest.$ac_ext <<_ACEOF
20602 /* confdefs.h.  */
20603 _ACEOF
20604 cat confdefs.h >>conftest.$ac_ext
20605 cat >>conftest.$ac_ext <<_ACEOF
20606 /* end confdefs.h.  */
20607
20608 /* Override any gcc2 internal prototype to avoid an error.  */
20609 #ifdef __cplusplus
20610 extern "C"
20611 #endif
20612 /* We use char because int might match the return type of a gcc2
20613    builtin and then its argument prototype would still apply.  */
20614 char trunc ();
20615 int
20616 main ()
20617 {
20618 trunc ();
20619   ;
20620   return 0;
20621 }
20622 _ACEOF
20623 rm -f conftest.$ac_objext conftest$ac_exeext
20624 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20625   (eval $ac_link) 2>conftest.er1
20626   ac_status=$?
20627   grep -v '^ *+' conftest.er1 >conftest.err
20628   rm -f conftest.er1
20629   cat conftest.err >&5
20630   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20631   (exit $ac_status); } &&
20632          { ac_try='test -z "$ac_c_werror_flag"
20633                          || test ! -s conftest.err'
20634   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20635   (eval $ac_try) 2>&5
20636   ac_status=$?
20637   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20638   (exit $ac_status); }; } &&
20639          { ac_try='test -s conftest$ac_exeext'
20640   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20641   (eval $ac_try) 2>&5
20642   ac_status=$?
20643   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20644   (exit $ac_status); }; }; then
20645   ac_cv_lib_m_trunc=yes
20646 else
20647   echo "$as_me: failed program was:" >&5
20648 sed 's/^/| /' conftest.$ac_ext >&5
20649
20650 ac_cv_lib_m_trunc=no
20651 fi
20652 rm -f conftest.err conftest.$ac_objext \
20653       conftest$ac_exeext conftest.$ac_ext
20654 LIBS=$ac_check_lib_save_LIBS
20655 fi
20656 echo "$as_me:$LINENO: result: $ac_cv_lib_m_trunc" >&5
20657 echo "${ECHO_T}$ac_cv_lib_m_trunc" >&6
20658 if test $ac_cv_lib_m_trunc = yes; then
20659
20660 cat >>confdefs.h <<\_ACEOF
20661 #define HAVE_TRUNC 1
20662 _ACEOF
20663
20664 fi
20665
20666 echo "$as_me:$LINENO: checking for truncl in -lm" >&5
20667 echo $ECHO_N "checking for truncl in -lm... $ECHO_C" >&6
20668 if test "${ac_cv_lib_m_truncl+set}" = set; then
20669   echo $ECHO_N "(cached) $ECHO_C" >&6
20670 else
20671   ac_check_lib_save_LIBS=$LIBS
20672 LIBS="-lm  $LIBS"
20673 if test x$gcc_no_link = xyes; then
20674   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20675 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20676    { (exit 1); exit 1; }; }
20677 fi
20678 cat >conftest.$ac_ext <<_ACEOF
20679 /* confdefs.h.  */
20680 _ACEOF
20681 cat confdefs.h >>conftest.$ac_ext
20682 cat >>conftest.$ac_ext <<_ACEOF
20683 /* end confdefs.h.  */
20684
20685 /* Override any gcc2 internal prototype to avoid an error.  */
20686 #ifdef __cplusplus
20687 extern "C"
20688 #endif
20689 /* We use char because int might match the return type of a gcc2
20690    builtin and then its argument prototype would still apply.  */
20691 char truncl ();
20692 int
20693 main ()
20694 {
20695 truncl ();
20696   ;
20697   return 0;
20698 }
20699 _ACEOF
20700 rm -f conftest.$ac_objext conftest$ac_exeext
20701 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20702   (eval $ac_link) 2>conftest.er1
20703   ac_status=$?
20704   grep -v '^ *+' conftest.er1 >conftest.err
20705   rm -f conftest.er1
20706   cat conftest.err >&5
20707   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20708   (exit $ac_status); } &&
20709          { ac_try='test -z "$ac_c_werror_flag"
20710                          || test ! -s conftest.err'
20711   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20712   (eval $ac_try) 2>&5
20713   ac_status=$?
20714   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20715   (exit $ac_status); }; } &&
20716          { ac_try='test -s conftest$ac_exeext'
20717   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20718   (eval $ac_try) 2>&5
20719   ac_status=$?
20720   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20721   (exit $ac_status); }; }; then
20722   ac_cv_lib_m_truncl=yes
20723 else
20724   echo "$as_me: failed program was:" >&5
20725 sed 's/^/| /' conftest.$ac_ext >&5
20726
20727 ac_cv_lib_m_truncl=no
20728 fi
20729 rm -f conftest.err conftest.$ac_objext \
20730       conftest$ac_exeext conftest.$ac_ext
20731 LIBS=$ac_check_lib_save_LIBS
20732 fi
20733 echo "$as_me:$LINENO: result: $ac_cv_lib_m_truncl" >&5
20734 echo "${ECHO_T}$ac_cv_lib_m_truncl" >&6
20735 if test $ac_cv_lib_m_truncl = yes; then
20736
20737 cat >>confdefs.h <<\_ACEOF
20738 #define HAVE_TRUNCL 1
20739 _ACEOF
20740
20741 fi
20742
20743 echo "$as_me:$LINENO: checking for erff in -lm" >&5
20744 echo $ECHO_N "checking for erff in -lm... $ECHO_C" >&6
20745 if test "${ac_cv_lib_m_erff+set}" = set; then
20746   echo $ECHO_N "(cached) $ECHO_C" >&6
20747 else
20748   ac_check_lib_save_LIBS=$LIBS
20749 LIBS="-lm  $LIBS"
20750 if test x$gcc_no_link = xyes; then
20751   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20752 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20753    { (exit 1); exit 1; }; }
20754 fi
20755 cat >conftest.$ac_ext <<_ACEOF
20756 /* confdefs.h.  */
20757 _ACEOF
20758 cat confdefs.h >>conftest.$ac_ext
20759 cat >>conftest.$ac_ext <<_ACEOF
20760 /* end confdefs.h.  */
20761
20762 /* Override any gcc2 internal prototype to avoid an error.  */
20763 #ifdef __cplusplus
20764 extern "C"
20765 #endif
20766 /* We use char because int might match the return type of a gcc2
20767    builtin and then its argument prototype would still apply.  */
20768 char erff ();
20769 int
20770 main ()
20771 {
20772 erff ();
20773   ;
20774   return 0;
20775 }
20776 _ACEOF
20777 rm -f conftest.$ac_objext conftest$ac_exeext
20778 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20779   (eval $ac_link) 2>conftest.er1
20780   ac_status=$?
20781   grep -v '^ *+' conftest.er1 >conftest.err
20782   rm -f conftest.er1
20783   cat conftest.err >&5
20784   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20785   (exit $ac_status); } &&
20786          { ac_try='test -z "$ac_c_werror_flag"
20787                          || test ! -s conftest.err'
20788   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20789   (eval $ac_try) 2>&5
20790   ac_status=$?
20791   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20792   (exit $ac_status); }; } &&
20793          { ac_try='test -s conftest$ac_exeext'
20794   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20795   (eval $ac_try) 2>&5
20796   ac_status=$?
20797   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20798   (exit $ac_status); }; }; then
20799   ac_cv_lib_m_erff=yes
20800 else
20801   echo "$as_me: failed program was:" >&5
20802 sed 's/^/| /' conftest.$ac_ext >&5
20803
20804 ac_cv_lib_m_erff=no
20805 fi
20806 rm -f conftest.err conftest.$ac_objext \
20807       conftest$ac_exeext conftest.$ac_ext
20808 LIBS=$ac_check_lib_save_LIBS
20809 fi
20810 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erff" >&5
20811 echo "${ECHO_T}$ac_cv_lib_m_erff" >&6
20812 if test $ac_cv_lib_m_erff = yes; then
20813
20814 cat >>confdefs.h <<\_ACEOF
20815 #define HAVE_ERFF 1
20816 _ACEOF
20817
20818 fi
20819
20820 echo "$as_me:$LINENO: checking for erf in -lm" >&5
20821 echo $ECHO_N "checking for erf in -lm... $ECHO_C" >&6
20822 if test "${ac_cv_lib_m_erf+set}" = set; then
20823   echo $ECHO_N "(cached) $ECHO_C" >&6
20824 else
20825   ac_check_lib_save_LIBS=$LIBS
20826 LIBS="-lm  $LIBS"
20827 if test x$gcc_no_link = xyes; then
20828   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20829 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20830    { (exit 1); exit 1; }; }
20831 fi
20832 cat >conftest.$ac_ext <<_ACEOF
20833 /* confdefs.h.  */
20834 _ACEOF
20835 cat confdefs.h >>conftest.$ac_ext
20836 cat >>conftest.$ac_ext <<_ACEOF
20837 /* end confdefs.h.  */
20838
20839 /* Override any gcc2 internal prototype to avoid an error.  */
20840 #ifdef __cplusplus
20841 extern "C"
20842 #endif
20843 /* We use char because int might match the return type of a gcc2
20844    builtin and then its argument prototype would still apply.  */
20845 char erf ();
20846 int
20847 main ()
20848 {
20849 erf ();
20850   ;
20851   return 0;
20852 }
20853 _ACEOF
20854 rm -f conftest.$ac_objext conftest$ac_exeext
20855 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20856   (eval $ac_link) 2>conftest.er1
20857   ac_status=$?
20858   grep -v '^ *+' conftest.er1 >conftest.err
20859   rm -f conftest.er1
20860   cat conftest.err >&5
20861   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20862   (exit $ac_status); } &&
20863          { ac_try='test -z "$ac_c_werror_flag"
20864                          || test ! -s conftest.err'
20865   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20866   (eval $ac_try) 2>&5
20867   ac_status=$?
20868   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20869   (exit $ac_status); }; } &&
20870          { ac_try='test -s conftest$ac_exeext'
20871   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20872   (eval $ac_try) 2>&5
20873   ac_status=$?
20874   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20875   (exit $ac_status); }; }; then
20876   ac_cv_lib_m_erf=yes
20877 else
20878   echo "$as_me: failed program was:" >&5
20879 sed 's/^/| /' conftest.$ac_ext >&5
20880
20881 ac_cv_lib_m_erf=no
20882 fi
20883 rm -f conftest.err conftest.$ac_objext \
20884       conftest$ac_exeext conftest.$ac_ext
20885 LIBS=$ac_check_lib_save_LIBS
20886 fi
20887 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erf" >&5
20888 echo "${ECHO_T}$ac_cv_lib_m_erf" >&6
20889 if test $ac_cv_lib_m_erf = yes; then
20890
20891 cat >>confdefs.h <<\_ACEOF
20892 #define HAVE_ERF 1
20893 _ACEOF
20894
20895 fi
20896
20897 echo "$as_me:$LINENO: checking for erfl in -lm" >&5
20898 echo $ECHO_N "checking for erfl in -lm... $ECHO_C" >&6
20899 if test "${ac_cv_lib_m_erfl+set}" = set; then
20900   echo $ECHO_N "(cached) $ECHO_C" >&6
20901 else
20902   ac_check_lib_save_LIBS=$LIBS
20903 LIBS="-lm  $LIBS"
20904 if test x$gcc_no_link = xyes; then
20905   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20906 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20907    { (exit 1); exit 1; }; }
20908 fi
20909 cat >conftest.$ac_ext <<_ACEOF
20910 /* confdefs.h.  */
20911 _ACEOF
20912 cat confdefs.h >>conftest.$ac_ext
20913 cat >>conftest.$ac_ext <<_ACEOF
20914 /* end confdefs.h.  */
20915
20916 /* Override any gcc2 internal prototype to avoid an error.  */
20917 #ifdef __cplusplus
20918 extern "C"
20919 #endif
20920 /* We use char because int might match the return type of a gcc2
20921    builtin and then its argument prototype would still apply.  */
20922 char erfl ();
20923 int
20924 main ()
20925 {
20926 erfl ();
20927   ;
20928   return 0;
20929 }
20930 _ACEOF
20931 rm -f conftest.$ac_objext conftest$ac_exeext
20932 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20933   (eval $ac_link) 2>conftest.er1
20934   ac_status=$?
20935   grep -v '^ *+' conftest.er1 >conftest.err
20936   rm -f conftest.er1
20937   cat conftest.err >&5
20938   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20939   (exit $ac_status); } &&
20940          { ac_try='test -z "$ac_c_werror_flag"
20941                          || test ! -s conftest.err'
20942   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20943   (eval $ac_try) 2>&5
20944   ac_status=$?
20945   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20946   (exit $ac_status); }; } &&
20947          { ac_try='test -s conftest$ac_exeext'
20948   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20949   (eval $ac_try) 2>&5
20950   ac_status=$?
20951   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20952   (exit $ac_status); }; }; then
20953   ac_cv_lib_m_erfl=yes
20954 else
20955   echo "$as_me: failed program was:" >&5
20956 sed 's/^/| /' conftest.$ac_ext >&5
20957
20958 ac_cv_lib_m_erfl=no
20959 fi
20960 rm -f conftest.err conftest.$ac_objext \
20961       conftest$ac_exeext conftest.$ac_ext
20962 LIBS=$ac_check_lib_save_LIBS
20963 fi
20964 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfl" >&5
20965 echo "${ECHO_T}$ac_cv_lib_m_erfl" >&6
20966 if test $ac_cv_lib_m_erfl = yes; then
20967
20968 cat >>confdefs.h <<\_ACEOF
20969 #define HAVE_ERFL 1
20970 _ACEOF
20971
20972 fi
20973
20974 echo "$as_me:$LINENO: checking for erfcf in -lm" >&5
20975 echo $ECHO_N "checking for erfcf in -lm... $ECHO_C" >&6
20976 if test "${ac_cv_lib_m_erfcf+set}" = set; then
20977   echo $ECHO_N "(cached) $ECHO_C" >&6
20978 else
20979   ac_check_lib_save_LIBS=$LIBS
20980 LIBS="-lm  $LIBS"
20981 if test x$gcc_no_link = xyes; then
20982   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20983 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20984    { (exit 1); exit 1; }; }
20985 fi
20986 cat >conftest.$ac_ext <<_ACEOF
20987 /* confdefs.h.  */
20988 _ACEOF
20989 cat confdefs.h >>conftest.$ac_ext
20990 cat >>conftest.$ac_ext <<_ACEOF
20991 /* end confdefs.h.  */
20992
20993 /* Override any gcc2 internal prototype to avoid an error.  */
20994 #ifdef __cplusplus
20995 extern "C"
20996 #endif
20997 /* We use char because int might match the return type of a gcc2
20998    builtin and then its argument prototype would still apply.  */
20999 char erfcf ();
21000 int
21001 main ()
21002 {
21003 erfcf ();
21004   ;
21005   return 0;
21006 }
21007 _ACEOF
21008 rm -f conftest.$ac_objext conftest$ac_exeext
21009 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21010   (eval $ac_link) 2>conftest.er1
21011   ac_status=$?
21012   grep -v '^ *+' conftest.er1 >conftest.err
21013   rm -f conftest.er1
21014   cat conftest.err >&5
21015   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21016   (exit $ac_status); } &&
21017          { ac_try='test -z "$ac_c_werror_flag"
21018                          || test ! -s conftest.err'
21019   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21020   (eval $ac_try) 2>&5
21021   ac_status=$?
21022   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21023   (exit $ac_status); }; } &&
21024          { ac_try='test -s conftest$ac_exeext'
21025   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21026   (eval $ac_try) 2>&5
21027   ac_status=$?
21028   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21029   (exit $ac_status); }; }; then
21030   ac_cv_lib_m_erfcf=yes
21031 else
21032   echo "$as_me: failed program was:" >&5
21033 sed 's/^/| /' conftest.$ac_ext >&5
21034
21035 ac_cv_lib_m_erfcf=no
21036 fi
21037 rm -f conftest.err conftest.$ac_objext \
21038       conftest$ac_exeext conftest.$ac_ext
21039 LIBS=$ac_check_lib_save_LIBS
21040 fi
21041 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfcf" >&5
21042 echo "${ECHO_T}$ac_cv_lib_m_erfcf" >&6
21043 if test $ac_cv_lib_m_erfcf = yes; then
21044
21045 cat >>confdefs.h <<\_ACEOF
21046 #define HAVE_ERFCF 1
21047 _ACEOF
21048
21049 fi
21050
21051 echo "$as_me:$LINENO: checking for erfc in -lm" >&5
21052 echo $ECHO_N "checking for erfc in -lm... $ECHO_C" >&6
21053 if test "${ac_cv_lib_m_erfc+set}" = set; then
21054   echo $ECHO_N "(cached) $ECHO_C" >&6
21055 else
21056   ac_check_lib_save_LIBS=$LIBS
21057 LIBS="-lm  $LIBS"
21058 if test x$gcc_no_link = xyes; then
21059   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21060 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21061    { (exit 1); exit 1; }; }
21062 fi
21063 cat >conftest.$ac_ext <<_ACEOF
21064 /* confdefs.h.  */
21065 _ACEOF
21066 cat confdefs.h >>conftest.$ac_ext
21067 cat >>conftest.$ac_ext <<_ACEOF
21068 /* end confdefs.h.  */
21069
21070 /* Override any gcc2 internal prototype to avoid an error.  */
21071 #ifdef __cplusplus
21072 extern "C"
21073 #endif
21074 /* We use char because int might match the return type of a gcc2
21075    builtin and then its argument prototype would still apply.  */
21076 char erfc ();
21077 int
21078 main ()
21079 {
21080 erfc ();
21081   ;
21082   return 0;
21083 }
21084 _ACEOF
21085 rm -f conftest.$ac_objext conftest$ac_exeext
21086 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21087   (eval $ac_link) 2>conftest.er1
21088   ac_status=$?
21089   grep -v '^ *+' conftest.er1 >conftest.err
21090   rm -f conftest.er1
21091   cat conftest.err >&5
21092   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21093   (exit $ac_status); } &&
21094          { ac_try='test -z "$ac_c_werror_flag"
21095                          || test ! -s conftest.err'
21096   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21097   (eval $ac_try) 2>&5
21098   ac_status=$?
21099   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21100   (exit $ac_status); }; } &&
21101          { ac_try='test -s conftest$ac_exeext'
21102   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21103   (eval $ac_try) 2>&5
21104   ac_status=$?
21105   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21106   (exit $ac_status); }; }; then
21107   ac_cv_lib_m_erfc=yes
21108 else
21109   echo "$as_me: failed program was:" >&5
21110 sed 's/^/| /' conftest.$ac_ext >&5
21111
21112 ac_cv_lib_m_erfc=no
21113 fi
21114 rm -f conftest.err conftest.$ac_objext \
21115       conftest$ac_exeext conftest.$ac_ext
21116 LIBS=$ac_check_lib_save_LIBS
21117 fi
21118 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfc" >&5
21119 echo "${ECHO_T}$ac_cv_lib_m_erfc" >&6
21120 if test $ac_cv_lib_m_erfc = yes; then
21121
21122 cat >>confdefs.h <<\_ACEOF
21123 #define HAVE_ERFC 1
21124 _ACEOF
21125
21126 fi
21127
21128 echo "$as_me:$LINENO: checking for erfcl in -lm" >&5
21129 echo $ECHO_N "checking for erfcl in -lm... $ECHO_C" >&6
21130 if test "${ac_cv_lib_m_erfcl+set}" = set; then
21131   echo $ECHO_N "(cached) $ECHO_C" >&6
21132 else
21133   ac_check_lib_save_LIBS=$LIBS
21134 LIBS="-lm  $LIBS"
21135 if test x$gcc_no_link = xyes; then
21136   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21137 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21138    { (exit 1); exit 1; }; }
21139 fi
21140 cat >conftest.$ac_ext <<_ACEOF
21141 /* confdefs.h.  */
21142 _ACEOF
21143 cat confdefs.h >>conftest.$ac_ext
21144 cat >>conftest.$ac_ext <<_ACEOF
21145 /* end confdefs.h.  */
21146
21147 /* Override any gcc2 internal prototype to avoid an error.  */
21148 #ifdef __cplusplus
21149 extern "C"
21150 #endif
21151 /* We use char because int might match the return type of a gcc2
21152    builtin and then its argument prototype would still apply.  */
21153 char erfcl ();
21154 int
21155 main ()
21156 {
21157 erfcl ();
21158   ;
21159   return 0;
21160 }
21161 _ACEOF
21162 rm -f conftest.$ac_objext conftest$ac_exeext
21163 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21164   (eval $ac_link) 2>conftest.er1
21165   ac_status=$?
21166   grep -v '^ *+' conftest.er1 >conftest.err
21167   rm -f conftest.er1
21168   cat conftest.err >&5
21169   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21170   (exit $ac_status); } &&
21171          { ac_try='test -z "$ac_c_werror_flag"
21172                          || test ! -s conftest.err'
21173   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21174   (eval $ac_try) 2>&5
21175   ac_status=$?
21176   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21177   (exit $ac_status); }; } &&
21178          { ac_try='test -s conftest$ac_exeext'
21179   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21180   (eval $ac_try) 2>&5
21181   ac_status=$?
21182   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21183   (exit $ac_status); }; }; then
21184   ac_cv_lib_m_erfcl=yes
21185 else
21186   echo "$as_me: failed program was:" >&5
21187 sed 's/^/| /' conftest.$ac_ext >&5
21188
21189 ac_cv_lib_m_erfcl=no
21190 fi
21191 rm -f conftest.err conftest.$ac_objext \
21192       conftest$ac_exeext conftest.$ac_ext
21193 LIBS=$ac_check_lib_save_LIBS
21194 fi
21195 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfcl" >&5
21196 echo "${ECHO_T}$ac_cv_lib_m_erfcl" >&6
21197 if test $ac_cv_lib_m_erfcl = yes; then
21198
21199 cat >>confdefs.h <<\_ACEOF
21200 #define HAVE_ERFCL 1
21201 _ACEOF
21202
21203 fi
21204
21205 echo "$as_me:$LINENO: checking for j0f in -lm" >&5
21206 echo $ECHO_N "checking for j0f in -lm... $ECHO_C" >&6
21207 if test "${ac_cv_lib_m_j0f+set}" = set; then
21208   echo $ECHO_N "(cached) $ECHO_C" >&6
21209 else
21210   ac_check_lib_save_LIBS=$LIBS
21211 LIBS="-lm  $LIBS"
21212 if test x$gcc_no_link = xyes; then
21213   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21214 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21215    { (exit 1); exit 1; }; }
21216 fi
21217 cat >conftest.$ac_ext <<_ACEOF
21218 /* confdefs.h.  */
21219 _ACEOF
21220 cat confdefs.h >>conftest.$ac_ext
21221 cat >>conftest.$ac_ext <<_ACEOF
21222 /* end confdefs.h.  */
21223
21224 /* Override any gcc2 internal prototype to avoid an error.  */
21225 #ifdef __cplusplus
21226 extern "C"
21227 #endif
21228 /* We use char because int might match the return type of a gcc2
21229    builtin and then its argument prototype would still apply.  */
21230 char j0f ();
21231 int
21232 main ()
21233 {
21234 j0f ();
21235   ;
21236   return 0;
21237 }
21238 _ACEOF
21239 rm -f conftest.$ac_objext conftest$ac_exeext
21240 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21241   (eval $ac_link) 2>conftest.er1
21242   ac_status=$?
21243   grep -v '^ *+' conftest.er1 >conftest.err
21244   rm -f conftest.er1
21245   cat conftest.err >&5
21246   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21247   (exit $ac_status); } &&
21248          { ac_try='test -z "$ac_c_werror_flag"
21249                          || test ! -s conftest.err'
21250   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21251   (eval $ac_try) 2>&5
21252   ac_status=$?
21253   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21254   (exit $ac_status); }; } &&
21255          { ac_try='test -s conftest$ac_exeext'
21256   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21257   (eval $ac_try) 2>&5
21258   ac_status=$?
21259   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21260   (exit $ac_status); }; }; then
21261   ac_cv_lib_m_j0f=yes
21262 else
21263   echo "$as_me: failed program was:" >&5
21264 sed 's/^/| /' conftest.$ac_ext >&5
21265
21266 ac_cv_lib_m_j0f=no
21267 fi
21268 rm -f conftest.err conftest.$ac_objext \
21269       conftest$ac_exeext conftest.$ac_ext
21270 LIBS=$ac_check_lib_save_LIBS
21271 fi
21272 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0f" >&5
21273 echo "${ECHO_T}$ac_cv_lib_m_j0f" >&6
21274 if test $ac_cv_lib_m_j0f = yes; then
21275
21276 cat >>confdefs.h <<\_ACEOF
21277 #define HAVE_J0F 1
21278 _ACEOF
21279
21280 fi
21281
21282 echo "$as_me:$LINENO: checking for j0 in -lm" >&5
21283 echo $ECHO_N "checking for j0 in -lm... $ECHO_C" >&6
21284 if test "${ac_cv_lib_m_j0+set}" = set; then
21285   echo $ECHO_N "(cached) $ECHO_C" >&6
21286 else
21287   ac_check_lib_save_LIBS=$LIBS
21288 LIBS="-lm  $LIBS"
21289 if test x$gcc_no_link = xyes; then
21290   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21291 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21292    { (exit 1); exit 1; }; }
21293 fi
21294 cat >conftest.$ac_ext <<_ACEOF
21295 /* confdefs.h.  */
21296 _ACEOF
21297 cat confdefs.h >>conftest.$ac_ext
21298 cat >>conftest.$ac_ext <<_ACEOF
21299 /* end confdefs.h.  */
21300
21301 /* Override any gcc2 internal prototype to avoid an error.  */
21302 #ifdef __cplusplus
21303 extern "C"
21304 #endif
21305 /* We use char because int might match the return type of a gcc2
21306    builtin and then its argument prototype would still apply.  */
21307 char j0 ();
21308 int
21309 main ()
21310 {
21311 j0 ();
21312   ;
21313   return 0;
21314 }
21315 _ACEOF
21316 rm -f conftest.$ac_objext conftest$ac_exeext
21317 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21318   (eval $ac_link) 2>conftest.er1
21319   ac_status=$?
21320   grep -v '^ *+' conftest.er1 >conftest.err
21321   rm -f conftest.er1
21322   cat conftest.err >&5
21323   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21324   (exit $ac_status); } &&
21325          { ac_try='test -z "$ac_c_werror_flag"
21326                          || test ! -s conftest.err'
21327   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21328   (eval $ac_try) 2>&5
21329   ac_status=$?
21330   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21331   (exit $ac_status); }; } &&
21332          { ac_try='test -s conftest$ac_exeext'
21333   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21334   (eval $ac_try) 2>&5
21335   ac_status=$?
21336   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21337   (exit $ac_status); }; }; then
21338   ac_cv_lib_m_j0=yes
21339 else
21340   echo "$as_me: failed program was:" >&5
21341 sed 's/^/| /' conftest.$ac_ext >&5
21342
21343 ac_cv_lib_m_j0=no
21344 fi
21345 rm -f conftest.err conftest.$ac_objext \
21346       conftest$ac_exeext conftest.$ac_ext
21347 LIBS=$ac_check_lib_save_LIBS
21348 fi
21349 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0" >&5
21350 echo "${ECHO_T}$ac_cv_lib_m_j0" >&6
21351 if test $ac_cv_lib_m_j0 = yes; then
21352
21353 cat >>confdefs.h <<\_ACEOF
21354 #define HAVE_J0 1
21355 _ACEOF
21356
21357 fi
21358
21359 echo "$as_me:$LINENO: checking for j0l in -lm" >&5
21360 echo $ECHO_N "checking for j0l in -lm... $ECHO_C" >&6
21361 if test "${ac_cv_lib_m_j0l+set}" = set; then
21362   echo $ECHO_N "(cached) $ECHO_C" >&6
21363 else
21364   ac_check_lib_save_LIBS=$LIBS
21365 LIBS="-lm  $LIBS"
21366 if test x$gcc_no_link = xyes; then
21367   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21368 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21369    { (exit 1); exit 1; }; }
21370 fi
21371 cat >conftest.$ac_ext <<_ACEOF
21372 /* confdefs.h.  */
21373 _ACEOF
21374 cat confdefs.h >>conftest.$ac_ext
21375 cat >>conftest.$ac_ext <<_ACEOF
21376 /* end confdefs.h.  */
21377
21378 /* Override any gcc2 internal prototype to avoid an error.  */
21379 #ifdef __cplusplus
21380 extern "C"
21381 #endif
21382 /* We use char because int might match the return type of a gcc2
21383    builtin and then its argument prototype would still apply.  */
21384 char j0l ();
21385 int
21386 main ()
21387 {
21388 j0l ();
21389   ;
21390   return 0;
21391 }
21392 _ACEOF
21393 rm -f conftest.$ac_objext conftest$ac_exeext
21394 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21395   (eval $ac_link) 2>conftest.er1
21396   ac_status=$?
21397   grep -v '^ *+' conftest.er1 >conftest.err
21398   rm -f conftest.er1
21399   cat conftest.err >&5
21400   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21401   (exit $ac_status); } &&
21402          { ac_try='test -z "$ac_c_werror_flag"
21403                          || test ! -s conftest.err'
21404   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21405   (eval $ac_try) 2>&5
21406   ac_status=$?
21407   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21408   (exit $ac_status); }; } &&
21409          { ac_try='test -s conftest$ac_exeext'
21410   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21411   (eval $ac_try) 2>&5
21412   ac_status=$?
21413   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21414   (exit $ac_status); }; }; then
21415   ac_cv_lib_m_j0l=yes
21416 else
21417   echo "$as_me: failed program was:" >&5
21418 sed 's/^/| /' conftest.$ac_ext >&5
21419
21420 ac_cv_lib_m_j0l=no
21421 fi
21422 rm -f conftest.err conftest.$ac_objext \
21423       conftest$ac_exeext conftest.$ac_ext
21424 LIBS=$ac_check_lib_save_LIBS
21425 fi
21426 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0l" >&5
21427 echo "${ECHO_T}$ac_cv_lib_m_j0l" >&6
21428 if test $ac_cv_lib_m_j0l = yes; then
21429
21430 cat >>confdefs.h <<\_ACEOF
21431 #define HAVE_J0L 1
21432 _ACEOF
21433
21434 fi
21435
21436 echo "$as_me:$LINENO: checking for j1f in -lm" >&5
21437 echo $ECHO_N "checking for j1f in -lm... $ECHO_C" >&6
21438 if test "${ac_cv_lib_m_j1f+set}" = set; then
21439   echo $ECHO_N "(cached) $ECHO_C" >&6
21440 else
21441   ac_check_lib_save_LIBS=$LIBS
21442 LIBS="-lm  $LIBS"
21443 if test x$gcc_no_link = xyes; then
21444   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21445 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21446    { (exit 1); exit 1; }; }
21447 fi
21448 cat >conftest.$ac_ext <<_ACEOF
21449 /* confdefs.h.  */
21450 _ACEOF
21451 cat confdefs.h >>conftest.$ac_ext
21452 cat >>conftest.$ac_ext <<_ACEOF
21453 /* end confdefs.h.  */
21454
21455 /* Override any gcc2 internal prototype to avoid an error.  */
21456 #ifdef __cplusplus
21457 extern "C"
21458 #endif
21459 /* We use char because int might match the return type of a gcc2
21460    builtin and then its argument prototype would still apply.  */
21461 char j1f ();
21462 int
21463 main ()
21464 {
21465 j1f ();
21466   ;
21467   return 0;
21468 }
21469 _ACEOF
21470 rm -f conftest.$ac_objext conftest$ac_exeext
21471 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21472   (eval $ac_link) 2>conftest.er1
21473   ac_status=$?
21474   grep -v '^ *+' conftest.er1 >conftest.err
21475   rm -f conftest.er1
21476   cat conftest.err >&5
21477   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21478   (exit $ac_status); } &&
21479          { ac_try='test -z "$ac_c_werror_flag"
21480                          || test ! -s conftest.err'
21481   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21482   (eval $ac_try) 2>&5
21483   ac_status=$?
21484   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21485   (exit $ac_status); }; } &&
21486          { ac_try='test -s conftest$ac_exeext'
21487   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21488   (eval $ac_try) 2>&5
21489   ac_status=$?
21490   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21491   (exit $ac_status); }; }; then
21492   ac_cv_lib_m_j1f=yes
21493 else
21494   echo "$as_me: failed program was:" >&5
21495 sed 's/^/| /' conftest.$ac_ext >&5
21496
21497 ac_cv_lib_m_j1f=no
21498 fi
21499 rm -f conftest.err conftest.$ac_objext \
21500       conftest$ac_exeext conftest.$ac_ext
21501 LIBS=$ac_check_lib_save_LIBS
21502 fi
21503 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1f" >&5
21504 echo "${ECHO_T}$ac_cv_lib_m_j1f" >&6
21505 if test $ac_cv_lib_m_j1f = yes; then
21506
21507 cat >>confdefs.h <<\_ACEOF
21508 #define HAVE_J1F 1
21509 _ACEOF
21510
21511 fi
21512
21513 echo "$as_me:$LINENO: checking for j1 in -lm" >&5
21514 echo $ECHO_N "checking for j1 in -lm... $ECHO_C" >&6
21515 if test "${ac_cv_lib_m_j1+set}" = set; then
21516   echo $ECHO_N "(cached) $ECHO_C" >&6
21517 else
21518   ac_check_lib_save_LIBS=$LIBS
21519 LIBS="-lm  $LIBS"
21520 if test x$gcc_no_link = xyes; then
21521   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21522 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21523    { (exit 1); exit 1; }; }
21524 fi
21525 cat >conftest.$ac_ext <<_ACEOF
21526 /* confdefs.h.  */
21527 _ACEOF
21528 cat confdefs.h >>conftest.$ac_ext
21529 cat >>conftest.$ac_ext <<_ACEOF
21530 /* end confdefs.h.  */
21531
21532 /* Override any gcc2 internal prototype to avoid an error.  */
21533 #ifdef __cplusplus
21534 extern "C"
21535 #endif
21536 /* We use char because int might match the return type of a gcc2
21537    builtin and then its argument prototype would still apply.  */
21538 char j1 ();
21539 int
21540 main ()
21541 {
21542 j1 ();
21543   ;
21544   return 0;
21545 }
21546 _ACEOF
21547 rm -f conftest.$ac_objext conftest$ac_exeext
21548 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21549   (eval $ac_link) 2>conftest.er1
21550   ac_status=$?
21551   grep -v '^ *+' conftest.er1 >conftest.err
21552   rm -f conftest.er1
21553   cat conftest.err >&5
21554   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21555   (exit $ac_status); } &&
21556          { ac_try='test -z "$ac_c_werror_flag"
21557                          || test ! -s conftest.err'
21558   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21559   (eval $ac_try) 2>&5
21560   ac_status=$?
21561   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21562   (exit $ac_status); }; } &&
21563          { ac_try='test -s conftest$ac_exeext'
21564   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21565   (eval $ac_try) 2>&5
21566   ac_status=$?
21567   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21568   (exit $ac_status); }; }; then
21569   ac_cv_lib_m_j1=yes
21570 else
21571   echo "$as_me: failed program was:" >&5
21572 sed 's/^/| /' conftest.$ac_ext >&5
21573
21574 ac_cv_lib_m_j1=no
21575 fi
21576 rm -f conftest.err conftest.$ac_objext \
21577       conftest$ac_exeext conftest.$ac_ext
21578 LIBS=$ac_check_lib_save_LIBS
21579 fi
21580 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1" >&5
21581 echo "${ECHO_T}$ac_cv_lib_m_j1" >&6
21582 if test $ac_cv_lib_m_j1 = yes; then
21583
21584 cat >>confdefs.h <<\_ACEOF
21585 #define HAVE_J1 1
21586 _ACEOF
21587
21588 fi
21589
21590 echo "$as_me:$LINENO: checking for j1l in -lm" >&5
21591 echo $ECHO_N "checking for j1l in -lm... $ECHO_C" >&6
21592 if test "${ac_cv_lib_m_j1l+set}" = set; then
21593   echo $ECHO_N "(cached) $ECHO_C" >&6
21594 else
21595   ac_check_lib_save_LIBS=$LIBS
21596 LIBS="-lm  $LIBS"
21597 if test x$gcc_no_link = xyes; then
21598   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21599 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21600    { (exit 1); exit 1; }; }
21601 fi
21602 cat >conftest.$ac_ext <<_ACEOF
21603 /* confdefs.h.  */
21604 _ACEOF
21605 cat confdefs.h >>conftest.$ac_ext
21606 cat >>conftest.$ac_ext <<_ACEOF
21607 /* end confdefs.h.  */
21608
21609 /* Override any gcc2 internal prototype to avoid an error.  */
21610 #ifdef __cplusplus
21611 extern "C"
21612 #endif
21613 /* We use char because int might match the return type of a gcc2
21614    builtin and then its argument prototype would still apply.  */
21615 char j1l ();
21616 int
21617 main ()
21618 {
21619 j1l ();
21620   ;
21621   return 0;
21622 }
21623 _ACEOF
21624 rm -f conftest.$ac_objext conftest$ac_exeext
21625 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21626   (eval $ac_link) 2>conftest.er1
21627   ac_status=$?
21628   grep -v '^ *+' conftest.er1 >conftest.err
21629   rm -f conftest.er1
21630   cat conftest.err >&5
21631   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21632   (exit $ac_status); } &&
21633          { ac_try='test -z "$ac_c_werror_flag"
21634                          || test ! -s conftest.err'
21635   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21636   (eval $ac_try) 2>&5
21637   ac_status=$?
21638   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21639   (exit $ac_status); }; } &&
21640          { ac_try='test -s conftest$ac_exeext'
21641   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21642   (eval $ac_try) 2>&5
21643   ac_status=$?
21644   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21645   (exit $ac_status); }; }; then
21646   ac_cv_lib_m_j1l=yes
21647 else
21648   echo "$as_me: failed program was:" >&5
21649 sed 's/^/| /' conftest.$ac_ext >&5
21650
21651 ac_cv_lib_m_j1l=no
21652 fi
21653 rm -f conftest.err conftest.$ac_objext \
21654       conftest$ac_exeext conftest.$ac_ext
21655 LIBS=$ac_check_lib_save_LIBS
21656 fi
21657 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1l" >&5
21658 echo "${ECHO_T}$ac_cv_lib_m_j1l" >&6
21659 if test $ac_cv_lib_m_j1l = yes; then
21660
21661 cat >>confdefs.h <<\_ACEOF
21662 #define HAVE_J1L 1
21663 _ACEOF
21664
21665 fi
21666
21667 echo "$as_me:$LINENO: checking for jnf in -lm" >&5
21668 echo $ECHO_N "checking for jnf in -lm... $ECHO_C" >&6
21669 if test "${ac_cv_lib_m_jnf+set}" = set; then
21670   echo $ECHO_N "(cached) $ECHO_C" >&6
21671 else
21672   ac_check_lib_save_LIBS=$LIBS
21673 LIBS="-lm  $LIBS"
21674 if test x$gcc_no_link = xyes; then
21675   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21676 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21677    { (exit 1); exit 1; }; }
21678 fi
21679 cat >conftest.$ac_ext <<_ACEOF
21680 /* confdefs.h.  */
21681 _ACEOF
21682 cat confdefs.h >>conftest.$ac_ext
21683 cat >>conftest.$ac_ext <<_ACEOF
21684 /* end confdefs.h.  */
21685
21686 /* Override any gcc2 internal prototype to avoid an error.  */
21687 #ifdef __cplusplus
21688 extern "C"
21689 #endif
21690 /* We use char because int might match the return type of a gcc2
21691    builtin and then its argument prototype would still apply.  */
21692 char jnf ();
21693 int
21694 main ()
21695 {
21696 jnf ();
21697   ;
21698   return 0;
21699 }
21700 _ACEOF
21701 rm -f conftest.$ac_objext conftest$ac_exeext
21702 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21703   (eval $ac_link) 2>conftest.er1
21704   ac_status=$?
21705   grep -v '^ *+' conftest.er1 >conftest.err
21706   rm -f conftest.er1
21707   cat conftest.err >&5
21708   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21709   (exit $ac_status); } &&
21710          { ac_try='test -z "$ac_c_werror_flag"
21711                          || test ! -s conftest.err'
21712   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21713   (eval $ac_try) 2>&5
21714   ac_status=$?
21715   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21716   (exit $ac_status); }; } &&
21717          { ac_try='test -s conftest$ac_exeext'
21718   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21719   (eval $ac_try) 2>&5
21720   ac_status=$?
21721   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21722   (exit $ac_status); }; }; then
21723   ac_cv_lib_m_jnf=yes
21724 else
21725   echo "$as_me: failed program was:" >&5
21726 sed 's/^/| /' conftest.$ac_ext >&5
21727
21728 ac_cv_lib_m_jnf=no
21729 fi
21730 rm -f conftest.err conftest.$ac_objext \
21731       conftest$ac_exeext conftest.$ac_ext
21732 LIBS=$ac_check_lib_save_LIBS
21733 fi
21734 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jnf" >&5
21735 echo "${ECHO_T}$ac_cv_lib_m_jnf" >&6
21736 if test $ac_cv_lib_m_jnf = yes; then
21737
21738 cat >>confdefs.h <<\_ACEOF
21739 #define HAVE_JNF 1
21740 _ACEOF
21741
21742 fi
21743
21744 echo "$as_me:$LINENO: checking for jn in -lm" >&5
21745 echo $ECHO_N "checking for jn in -lm... $ECHO_C" >&6
21746 if test "${ac_cv_lib_m_jn+set}" = set; then
21747   echo $ECHO_N "(cached) $ECHO_C" >&6
21748 else
21749   ac_check_lib_save_LIBS=$LIBS
21750 LIBS="-lm  $LIBS"
21751 if test x$gcc_no_link = xyes; then
21752   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21753 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21754    { (exit 1); exit 1; }; }
21755 fi
21756 cat >conftest.$ac_ext <<_ACEOF
21757 /* confdefs.h.  */
21758 _ACEOF
21759 cat confdefs.h >>conftest.$ac_ext
21760 cat >>conftest.$ac_ext <<_ACEOF
21761 /* end confdefs.h.  */
21762
21763 /* Override any gcc2 internal prototype to avoid an error.  */
21764 #ifdef __cplusplus
21765 extern "C"
21766 #endif
21767 /* We use char because int might match the return type of a gcc2
21768    builtin and then its argument prototype would still apply.  */
21769 char jn ();
21770 int
21771 main ()
21772 {
21773 jn ();
21774   ;
21775   return 0;
21776 }
21777 _ACEOF
21778 rm -f conftest.$ac_objext conftest$ac_exeext
21779 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21780   (eval $ac_link) 2>conftest.er1
21781   ac_status=$?
21782   grep -v '^ *+' conftest.er1 >conftest.err
21783   rm -f conftest.er1
21784   cat conftest.err >&5
21785   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21786   (exit $ac_status); } &&
21787          { ac_try='test -z "$ac_c_werror_flag"
21788                          || test ! -s conftest.err'
21789   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21790   (eval $ac_try) 2>&5
21791   ac_status=$?
21792   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21793   (exit $ac_status); }; } &&
21794          { ac_try='test -s conftest$ac_exeext'
21795   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21796   (eval $ac_try) 2>&5
21797   ac_status=$?
21798   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21799   (exit $ac_status); }; }; then
21800   ac_cv_lib_m_jn=yes
21801 else
21802   echo "$as_me: failed program was:" >&5
21803 sed 's/^/| /' conftest.$ac_ext >&5
21804
21805 ac_cv_lib_m_jn=no
21806 fi
21807 rm -f conftest.err conftest.$ac_objext \
21808       conftest$ac_exeext conftest.$ac_ext
21809 LIBS=$ac_check_lib_save_LIBS
21810 fi
21811 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jn" >&5
21812 echo "${ECHO_T}$ac_cv_lib_m_jn" >&6
21813 if test $ac_cv_lib_m_jn = yes; then
21814
21815 cat >>confdefs.h <<\_ACEOF
21816 #define HAVE_JN 1
21817 _ACEOF
21818
21819 fi
21820
21821 echo "$as_me:$LINENO: checking for jnl in -lm" >&5
21822 echo $ECHO_N "checking for jnl in -lm... $ECHO_C" >&6
21823 if test "${ac_cv_lib_m_jnl+set}" = set; then
21824   echo $ECHO_N "(cached) $ECHO_C" >&6
21825 else
21826   ac_check_lib_save_LIBS=$LIBS
21827 LIBS="-lm  $LIBS"
21828 if test x$gcc_no_link = xyes; then
21829   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21830 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21831    { (exit 1); exit 1; }; }
21832 fi
21833 cat >conftest.$ac_ext <<_ACEOF
21834 /* confdefs.h.  */
21835 _ACEOF
21836 cat confdefs.h >>conftest.$ac_ext
21837 cat >>conftest.$ac_ext <<_ACEOF
21838 /* end confdefs.h.  */
21839
21840 /* Override any gcc2 internal prototype to avoid an error.  */
21841 #ifdef __cplusplus
21842 extern "C"
21843 #endif
21844 /* We use char because int might match the return type of a gcc2
21845    builtin and then its argument prototype would still apply.  */
21846 char jnl ();
21847 int
21848 main ()
21849 {
21850 jnl ();
21851   ;
21852   return 0;
21853 }
21854 _ACEOF
21855 rm -f conftest.$ac_objext conftest$ac_exeext
21856 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21857   (eval $ac_link) 2>conftest.er1
21858   ac_status=$?
21859   grep -v '^ *+' conftest.er1 >conftest.err
21860   rm -f conftest.er1
21861   cat conftest.err >&5
21862   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21863   (exit $ac_status); } &&
21864          { ac_try='test -z "$ac_c_werror_flag"
21865                          || test ! -s conftest.err'
21866   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21867   (eval $ac_try) 2>&5
21868   ac_status=$?
21869   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21870   (exit $ac_status); }; } &&
21871          { ac_try='test -s conftest$ac_exeext'
21872   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21873   (eval $ac_try) 2>&5
21874   ac_status=$?
21875   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21876   (exit $ac_status); }; }; then
21877   ac_cv_lib_m_jnl=yes
21878 else
21879   echo "$as_me: failed program was:" >&5
21880 sed 's/^/| /' conftest.$ac_ext >&5
21881
21882 ac_cv_lib_m_jnl=no
21883 fi
21884 rm -f conftest.err conftest.$ac_objext \
21885       conftest$ac_exeext conftest.$ac_ext
21886 LIBS=$ac_check_lib_save_LIBS
21887 fi
21888 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jnl" >&5
21889 echo "${ECHO_T}$ac_cv_lib_m_jnl" >&6
21890 if test $ac_cv_lib_m_jnl = yes; then
21891
21892 cat >>confdefs.h <<\_ACEOF
21893 #define HAVE_JNL 1
21894 _ACEOF
21895
21896 fi
21897
21898 echo "$as_me:$LINENO: checking for y0f in -lm" >&5
21899 echo $ECHO_N "checking for y0f in -lm... $ECHO_C" >&6
21900 if test "${ac_cv_lib_m_y0f+set}" = set; then
21901   echo $ECHO_N "(cached) $ECHO_C" >&6
21902 else
21903   ac_check_lib_save_LIBS=$LIBS
21904 LIBS="-lm  $LIBS"
21905 if test x$gcc_no_link = xyes; then
21906   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21907 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21908    { (exit 1); exit 1; }; }
21909 fi
21910 cat >conftest.$ac_ext <<_ACEOF
21911 /* confdefs.h.  */
21912 _ACEOF
21913 cat confdefs.h >>conftest.$ac_ext
21914 cat >>conftest.$ac_ext <<_ACEOF
21915 /* end confdefs.h.  */
21916
21917 /* Override any gcc2 internal prototype to avoid an error.  */
21918 #ifdef __cplusplus
21919 extern "C"
21920 #endif
21921 /* We use char because int might match the return type of a gcc2
21922    builtin and then its argument prototype would still apply.  */
21923 char y0f ();
21924 int
21925 main ()
21926 {
21927 y0f ();
21928   ;
21929   return 0;
21930 }
21931 _ACEOF
21932 rm -f conftest.$ac_objext conftest$ac_exeext
21933 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21934   (eval $ac_link) 2>conftest.er1
21935   ac_status=$?
21936   grep -v '^ *+' conftest.er1 >conftest.err
21937   rm -f conftest.er1
21938   cat conftest.err >&5
21939   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21940   (exit $ac_status); } &&
21941          { ac_try='test -z "$ac_c_werror_flag"
21942                          || test ! -s conftest.err'
21943   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21944   (eval $ac_try) 2>&5
21945   ac_status=$?
21946   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21947   (exit $ac_status); }; } &&
21948          { ac_try='test -s conftest$ac_exeext'
21949   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21950   (eval $ac_try) 2>&5
21951   ac_status=$?
21952   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21953   (exit $ac_status); }; }; then
21954   ac_cv_lib_m_y0f=yes
21955 else
21956   echo "$as_me: failed program was:" >&5
21957 sed 's/^/| /' conftest.$ac_ext >&5
21958
21959 ac_cv_lib_m_y0f=no
21960 fi
21961 rm -f conftest.err conftest.$ac_objext \
21962       conftest$ac_exeext conftest.$ac_ext
21963 LIBS=$ac_check_lib_save_LIBS
21964 fi
21965 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0f" >&5
21966 echo "${ECHO_T}$ac_cv_lib_m_y0f" >&6
21967 if test $ac_cv_lib_m_y0f = yes; then
21968
21969 cat >>confdefs.h <<\_ACEOF
21970 #define HAVE_Y0F 1
21971 _ACEOF
21972
21973 fi
21974
21975 echo "$as_me:$LINENO: checking for y0 in -lm" >&5
21976 echo $ECHO_N "checking for y0 in -lm... $ECHO_C" >&6
21977 if test "${ac_cv_lib_m_y0+set}" = set; then
21978   echo $ECHO_N "(cached) $ECHO_C" >&6
21979 else
21980   ac_check_lib_save_LIBS=$LIBS
21981 LIBS="-lm  $LIBS"
21982 if test x$gcc_no_link = xyes; then
21983   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21984 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21985    { (exit 1); exit 1; }; }
21986 fi
21987 cat >conftest.$ac_ext <<_ACEOF
21988 /* confdefs.h.  */
21989 _ACEOF
21990 cat confdefs.h >>conftest.$ac_ext
21991 cat >>conftest.$ac_ext <<_ACEOF
21992 /* end confdefs.h.  */
21993
21994 /* Override any gcc2 internal prototype to avoid an error.  */
21995 #ifdef __cplusplus
21996 extern "C"
21997 #endif
21998 /* We use char because int might match the return type of a gcc2
21999    builtin and then its argument prototype would still apply.  */
22000 char y0 ();
22001 int
22002 main ()
22003 {
22004 y0 ();
22005   ;
22006   return 0;
22007 }
22008 _ACEOF
22009 rm -f conftest.$ac_objext conftest$ac_exeext
22010 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22011   (eval $ac_link) 2>conftest.er1
22012   ac_status=$?
22013   grep -v '^ *+' conftest.er1 >conftest.err
22014   rm -f conftest.er1
22015   cat conftest.err >&5
22016   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22017   (exit $ac_status); } &&
22018          { ac_try='test -z "$ac_c_werror_flag"
22019                          || test ! -s conftest.err'
22020   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22021   (eval $ac_try) 2>&5
22022   ac_status=$?
22023   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22024   (exit $ac_status); }; } &&
22025          { ac_try='test -s conftest$ac_exeext'
22026   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22027   (eval $ac_try) 2>&5
22028   ac_status=$?
22029   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22030   (exit $ac_status); }; }; then
22031   ac_cv_lib_m_y0=yes
22032 else
22033   echo "$as_me: failed program was:" >&5
22034 sed 's/^/| /' conftest.$ac_ext >&5
22035
22036 ac_cv_lib_m_y0=no
22037 fi
22038 rm -f conftest.err conftest.$ac_objext \
22039       conftest$ac_exeext conftest.$ac_ext
22040 LIBS=$ac_check_lib_save_LIBS
22041 fi
22042 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0" >&5
22043 echo "${ECHO_T}$ac_cv_lib_m_y0" >&6
22044 if test $ac_cv_lib_m_y0 = yes; then
22045
22046 cat >>confdefs.h <<\_ACEOF
22047 #define HAVE_Y0 1
22048 _ACEOF
22049
22050 fi
22051
22052 echo "$as_me:$LINENO: checking for y0l in -lm" >&5
22053 echo $ECHO_N "checking for y0l in -lm... $ECHO_C" >&6
22054 if test "${ac_cv_lib_m_y0l+set}" = set; then
22055   echo $ECHO_N "(cached) $ECHO_C" >&6
22056 else
22057   ac_check_lib_save_LIBS=$LIBS
22058 LIBS="-lm  $LIBS"
22059 if test x$gcc_no_link = xyes; then
22060   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22061 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22062    { (exit 1); exit 1; }; }
22063 fi
22064 cat >conftest.$ac_ext <<_ACEOF
22065 /* confdefs.h.  */
22066 _ACEOF
22067 cat confdefs.h >>conftest.$ac_ext
22068 cat >>conftest.$ac_ext <<_ACEOF
22069 /* end confdefs.h.  */
22070
22071 /* Override any gcc2 internal prototype to avoid an error.  */
22072 #ifdef __cplusplus
22073 extern "C"
22074 #endif
22075 /* We use char because int might match the return type of a gcc2
22076    builtin and then its argument prototype would still apply.  */
22077 char y0l ();
22078 int
22079 main ()
22080 {
22081 y0l ();
22082   ;
22083   return 0;
22084 }
22085 _ACEOF
22086 rm -f conftest.$ac_objext conftest$ac_exeext
22087 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22088   (eval $ac_link) 2>conftest.er1
22089   ac_status=$?
22090   grep -v '^ *+' conftest.er1 >conftest.err
22091   rm -f conftest.er1
22092   cat conftest.err >&5
22093   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22094   (exit $ac_status); } &&
22095          { ac_try='test -z "$ac_c_werror_flag"
22096                          || test ! -s conftest.err'
22097   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22098   (eval $ac_try) 2>&5
22099   ac_status=$?
22100   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22101   (exit $ac_status); }; } &&
22102          { ac_try='test -s conftest$ac_exeext'
22103   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22104   (eval $ac_try) 2>&5
22105   ac_status=$?
22106   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22107   (exit $ac_status); }; }; then
22108   ac_cv_lib_m_y0l=yes
22109 else
22110   echo "$as_me: failed program was:" >&5
22111 sed 's/^/| /' conftest.$ac_ext >&5
22112
22113 ac_cv_lib_m_y0l=no
22114 fi
22115 rm -f conftest.err conftest.$ac_objext \
22116       conftest$ac_exeext conftest.$ac_ext
22117 LIBS=$ac_check_lib_save_LIBS
22118 fi
22119 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0l" >&5
22120 echo "${ECHO_T}$ac_cv_lib_m_y0l" >&6
22121 if test $ac_cv_lib_m_y0l = yes; then
22122
22123 cat >>confdefs.h <<\_ACEOF
22124 #define HAVE_Y0L 1
22125 _ACEOF
22126
22127 fi
22128
22129 echo "$as_me:$LINENO: checking for y1f in -lm" >&5
22130 echo $ECHO_N "checking for y1f in -lm... $ECHO_C" >&6
22131 if test "${ac_cv_lib_m_y1f+set}" = set; then
22132   echo $ECHO_N "(cached) $ECHO_C" >&6
22133 else
22134   ac_check_lib_save_LIBS=$LIBS
22135 LIBS="-lm  $LIBS"
22136 if test x$gcc_no_link = xyes; then
22137   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22138 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22139    { (exit 1); exit 1; }; }
22140 fi
22141 cat >conftest.$ac_ext <<_ACEOF
22142 /* confdefs.h.  */
22143 _ACEOF
22144 cat confdefs.h >>conftest.$ac_ext
22145 cat >>conftest.$ac_ext <<_ACEOF
22146 /* end confdefs.h.  */
22147
22148 /* Override any gcc2 internal prototype to avoid an error.  */
22149 #ifdef __cplusplus
22150 extern "C"
22151 #endif
22152 /* We use char because int might match the return type of a gcc2
22153    builtin and then its argument prototype would still apply.  */
22154 char y1f ();
22155 int
22156 main ()
22157 {
22158 y1f ();
22159   ;
22160   return 0;
22161 }
22162 _ACEOF
22163 rm -f conftest.$ac_objext conftest$ac_exeext
22164 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22165   (eval $ac_link) 2>conftest.er1
22166   ac_status=$?
22167   grep -v '^ *+' conftest.er1 >conftest.err
22168   rm -f conftest.er1
22169   cat conftest.err >&5
22170   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22171   (exit $ac_status); } &&
22172          { ac_try='test -z "$ac_c_werror_flag"
22173                          || test ! -s conftest.err'
22174   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22175   (eval $ac_try) 2>&5
22176   ac_status=$?
22177   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22178   (exit $ac_status); }; } &&
22179          { ac_try='test -s conftest$ac_exeext'
22180   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22181   (eval $ac_try) 2>&5
22182   ac_status=$?
22183   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22184   (exit $ac_status); }; }; then
22185   ac_cv_lib_m_y1f=yes
22186 else
22187   echo "$as_me: failed program was:" >&5
22188 sed 's/^/| /' conftest.$ac_ext >&5
22189
22190 ac_cv_lib_m_y1f=no
22191 fi
22192 rm -f conftest.err conftest.$ac_objext \
22193       conftest$ac_exeext conftest.$ac_ext
22194 LIBS=$ac_check_lib_save_LIBS
22195 fi
22196 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1f" >&5
22197 echo "${ECHO_T}$ac_cv_lib_m_y1f" >&6
22198 if test $ac_cv_lib_m_y1f = yes; then
22199
22200 cat >>confdefs.h <<\_ACEOF
22201 #define HAVE_Y1F 1
22202 _ACEOF
22203
22204 fi
22205
22206 echo "$as_me:$LINENO: checking for y1 in -lm" >&5
22207 echo $ECHO_N "checking for y1 in -lm... $ECHO_C" >&6
22208 if test "${ac_cv_lib_m_y1+set}" = set; then
22209   echo $ECHO_N "(cached) $ECHO_C" >&6
22210 else
22211   ac_check_lib_save_LIBS=$LIBS
22212 LIBS="-lm  $LIBS"
22213 if test x$gcc_no_link = xyes; then
22214   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22215 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22216    { (exit 1); exit 1; }; }
22217 fi
22218 cat >conftest.$ac_ext <<_ACEOF
22219 /* confdefs.h.  */
22220 _ACEOF
22221 cat confdefs.h >>conftest.$ac_ext
22222 cat >>conftest.$ac_ext <<_ACEOF
22223 /* end confdefs.h.  */
22224
22225 /* Override any gcc2 internal prototype to avoid an error.  */
22226 #ifdef __cplusplus
22227 extern "C"
22228 #endif
22229 /* We use char because int might match the return type of a gcc2
22230    builtin and then its argument prototype would still apply.  */
22231 char y1 ();
22232 int
22233 main ()
22234 {
22235 y1 ();
22236   ;
22237   return 0;
22238 }
22239 _ACEOF
22240 rm -f conftest.$ac_objext conftest$ac_exeext
22241 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22242   (eval $ac_link) 2>conftest.er1
22243   ac_status=$?
22244   grep -v '^ *+' conftest.er1 >conftest.err
22245   rm -f conftest.er1
22246   cat conftest.err >&5
22247   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22248   (exit $ac_status); } &&
22249          { ac_try='test -z "$ac_c_werror_flag"
22250                          || test ! -s conftest.err'
22251   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22252   (eval $ac_try) 2>&5
22253   ac_status=$?
22254   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22255   (exit $ac_status); }; } &&
22256          { ac_try='test -s conftest$ac_exeext'
22257   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22258   (eval $ac_try) 2>&5
22259   ac_status=$?
22260   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22261   (exit $ac_status); }; }; then
22262   ac_cv_lib_m_y1=yes
22263 else
22264   echo "$as_me: failed program was:" >&5
22265 sed 's/^/| /' conftest.$ac_ext >&5
22266
22267 ac_cv_lib_m_y1=no
22268 fi
22269 rm -f conftest.err conftest.$ac_objext \
22270       conftest$ac_exeext conftest.$ac_ext
22271 LIBS=$ac_check_lib_save_LIBS
22272 fi
22273 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1" >&5
22274 echo "${ECHO_T}$ac_cv_lib_m_y1" >&6
22275 if test $ac_cv_lib_m_y1 = yes; then
22276
22277 cat >>confdefs.h <<\_ACEOF
22278 #define HAVE_Y1 1
22279 _ACEOF
22280
22281 fi
22282
22283 echo "$as_me:$LINENO: checking for y1l in -lm" >&5
22284 echo $ECHO_N "checking for y1l in -lm... $ECHO_C" >&6
22285 if test "${ac_cv_lib_m_y1l+set}" = set; then
22286   echo $ECHO_N "(cached) $ECHO_C" >&6
22287 else
22288   ac_check_lib_save_LIBS=$LIBS
22289 LIBS="-lm  $LIBS"
22290 if test x$gcc_no_link = xyes; then
22291   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22292 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22293    { (exit 1); exit 1; }; }
22294 fi
22295 cat >conftest.$ac_ext <<_ACEOF
22296 /* confdefs.h.  */
22297 _ACEOF
22298 cat confdefs.h >>conftest.$ac_ext
22299 cat >>conftest.$ac_ext <<_ACEOF
22300 /* end confdefs.h.  */
22301
22302 /* Override any gcc2 internal prototype to avoid an error.  */
22303 #ifdef __cplusplus
22304 extern "C"
22305 #endif
22306 /* We use char because int might match the return type of a gcc2
22307    builtin and then its argument prototype would still apply.  */
22308 char y1l ();
22309 int
22310 main ()
22311 {
22312 y1l ();
22313   ;
22314   return 0;
22315 }
22316 _ACEOF
22317 rm -f conftest.$ac_objext conftest$ac_exeext
22318 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22319   (eval $ac_link) 2>conftest.er1
22320   ac_status=$?
22321   grep -v '^ *+' conftest.er1 >conftest.err
22322   rm -f conftest.er1
22323   cat conftest.err >&5
22324   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22325   (exit $ac_status); } &&
22326          { ac_try='test -z "$ac_c_werror_flag"
22327                          || test ! -s conftest.err'
22328   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22329   (eval $ac_try) 2>&5
22330   ac_status=$?
22331   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22332   (exit $ac_status); }; } &&
22333          { ac_try='test -s conftest$ac_exeext'
22334   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22335   (eval $ac_try) 2>&5
22336   ac_status=$?
22337   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22338   (exit $ac_status); }; }; then
22339   ac_cv_lib_m_y1l=yes
22340 else
22341   echo "$as_me: failed program was:" >&5
22342 sed 's/^/| /' conftest.$ac_ext >&5
22343
22344 ac_cv_lib_m_y1l=no
22345 fi
22346 rm -f conftest.err conftest.$ac_objext \
22347       conftest$ac_exeext conftest.$ac_ext
22348 LIBS=$ac_check_lib_save_LIBS
22349 fi
22350 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1l" >&5
22351 echo "${ECHO_T}$ac_cv_lib_m_y1l" >&6
22352 if test $ac_cv_lib_m_y1l = yes; then
22353
22354 cat >>confdefs.h <<\_ACEOF
22355 #define HAVE_Y1L 1
22356 _ACEOF
22357
22358 fi
22359
22360 echo "$as_me:$LINENO: checking for ynf in -lm" >&5
22361 echo $ECHO_N "checking for ynf in -lm... $ECHO_C" >&6
22362 if test "${ac_cv_lib_m_ynf+set}" = set; then
22363   echo $ECHO_N "(cached) $ECHO_C" >&6
22364 else
22365   ac_check_lib_save_LIBS=$LIBS
22366 LIBS="-lm  $LIBS"
22367 if test x$gcc_no_link = xyes; then
22368   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22369 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22370    { (exit 1); exit 1; }; }
22371 fi
22372 cat >conftest.$ac_ext <<_ACEOF
22373 /* confdefs.h.  */
22374 _ACEOF
22375 cat confdefs.h >>conftest.$ac_ext
22376 cat >>conftest.$ac_ext <<_ACEOF
22377 /* end confdefs.h.  */
22378
22379 /* Override any gcc2 internal prototype to avoid an error.  */
22380 #ifdef __cplusplus
22381 extern "C"
22382 #endif
22383 /* We use char because int might match the return type of a gcc2
22384    builtin and then its argument prototype would still apply.  */
22385 char ynf ();
22386 int
22387 main ()
22388 {
22389 ynf ();
22390   ;
22391   return 0;
22392 }
22393 _ACEOF
22394 rm -f conftest.$ac_objext conftest$ac_exeext
22395 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22396   (eval $ac_link) 2>conftest.er1
22397   ac_status=$?
22398   grep -v '^ *+' conftest.er1 >conftest.err
22399   rm -f conftest.er1
22400   cat conftest.err >&5
22401   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22402   (exit $ac_status); } &&
22403          { ac_try='test -z "$ac_c_werror_flag"
22404                          || test ! -s conftest.err'
22405   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22406   (eval $ac_try) 2>&5
22407   ac_status=$?
22408   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22409   (exit $ac_status); }; } &&
22410          { ac_try='test -s conftest$ac_exeext'
22411   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22412   (eval $ac_try) 2>&5
22413   ac_status=$?
22414   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22415   (exit $ac_status); }; }; then
22416   ac_cv_lib_m_ynf=yes
22417 else
22418   echo "$as_me: failed program was:" >&5
22419 sed 's/^/| /' conftest.$ac_ext >&5
22420
22421 ac_cv_lib_m_ynf=no
22422 fi
22423 rm -f conftest.err conftest.$ac_objext \
22424       conftest$ac_exeext conftest.$ac_ext
22425 LIBS=$ac_check_lib_save_LIBS
22426 fi
22427 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ynf" >&5
22428 echo "${ECHO_T}$ac_cv_lib_m_ynf" >&6
22429 if test $ac_cv_lib_m_ynf = yes; then
22430
22431 cat >>confdefs.h <<\_ACEOF
22432 #define HAVE_YNF 1
22433 _ACEOF
22434
22435 fi
22436
22437 echo "$as_me:$LINENO: checking for yn in -lm" >&5
22438 echo $ECHO_N "checking for yn in -lm... $ECHO_C" >&6
22439 if test "${ac_cv_lib_m_yn+set}" = set; then
22440   echo $ECHO_N "(cached) $ECHO_C" >&6
22441 else
22442   ac_check_lib_save_LIBS=$LIBS
22443 LIBS="-lm  $LIBS"
22444 if test x$gcc_no_link = xyes; then
22445   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22446 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22447    { (exit 1); exit 1; }; }
22448 fi
22449 cat >conftest.$ac_ext <<_ACEOF
22450 /* confdefs.h.  */
22451 _ACEOF
22452 cat confdefs.h >>conftest.$ac_ext
22453 cat >>conftest.$ac_ext <<_ACEOF
22454 /* end confdefs.h.  */
22455
22456 /* Override any gcc2 internal prototype to avoid an error.  */
22457 #ifdef __cplusplus
22458 extern "C"
22459 #endif
22460 /* We use char because int might match the return type of a gcc2
22461    builtin and then its argument prototype would still apply.  */
22462 char yn ();
22463 int
22464 main ()
22465 {
22466 yn ();
22467   ;
22468   return 0;
22469 }
22470 _ACEOF
22471 rm -f conftest.$ac_objext conftest$ac_exeext
22472 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22473   (eval $ac_link) 2>conftest.er1
22474   ac_status=$?
22475   grep -v '^ *+' conftest.er1 >conftest.err
22476   rm -f conftest.er1
22477   cat conftest.err >&5
22478   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22479   (exit $ac_status); } &&
22480          { ac_try='test -z "$ac_c_werror_flag"
22481                          || test ! -s conftest.err'
22482   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22483   (eval $ac_try) 2>&5
22484   ac_status=$?
22485   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22486   (exit $ac_status); }; } &&
22487          { ac_try='test -s conftest$ac_exeext'
22488   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22489   (eval $ac_try) 2>&5
22490   ac_status=$?
22491   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22492   (exit $ac_status); }; }; then
22493   ac_cv_lib_m_yn=yes
22494 else
22495   echo "$as_me: failed program was:" >&5
22496 sed 's/^/| /' conftest.$ac_ext >&5
22497
22498 ac_cv_lib_m_yn=no
22499 fi
22500 rm -f conftest.err conftest.$ac_objext \
22501       conftest$ac_exeext conftest.$ac_ext
22502 LIBS=$ac_check_lib_save_LIBS
22503 fi
22504 echo "$as_me:$LINENO: result: $ac_cv_lib_m_yn" >&5
22505 echo "${ECHO_T}$ac_cv_lib_m_yn" >&6
22506 if test $ac_cv_lib_m_yn = yes; then
22507
22508 cat >>confdefs.h <<\_ACEOF
22509 #define HAVE_YN 1
22510 _ACEOF
22511
22512 fi
22513
22514 echo "$as_me:$LINENO: checking for ynl in -lm" >&5
22515 echo $ECHO_N "checking for ynl in -lm... $ECHO_C" >&6
22516 if test "${ac_cv_lib_m_ynl+set}" = set; then
22517   echo $ECHO_N "(cached) $ECHO_C" >&6
22518 else
22519   ac_check_lib_save_LIBS=$LIBS
22520 LIBS="-lm  $LIBS"
22521 if test x$gcc_no_link = xyes; then
22522   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22523 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22524    { (exit 1); exit 1; }; }
22525 fi
22526 cat >conftest.$ac_ext <<_ACEOF
22527 /* confdefs.h.  */
22528 _ACEOF
22529 cat confdefs.h >>conftest.$ac_ext
22530 cat >>conftest.$ac_ext <<_ACEOF
22531 /* end confdefs.h.  */
22532
22533 /* Override any gcc2 internal prototype to avoid an error.  */
22534 #ifdef __cplusplus
22535 extern "C"
22536 #endif
22537 /* We use char because int might match the return type of a gcc2
22538    builtin and then its argument prototype would still apply.  */
22539 char ynl ();
22540 int
22541 main ()
22542 {
22543 ynl ();
22544   ;
22545   return 0;
22546 }
22547 _ACEOF
22548 rm -f conftest.$ac_objext conftest$ac_exeext
22549 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22550   (eval $ac_link) 2>conftest.er1
22551   ac_status=$?
22552   grep -v '^ *+' conftest.er1 >conftest.err
22553   rm -f conftest.er1
22554   cat conftest.err >&5
22555   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22556   (exit $ac_status); } &&
22557          { ac_try='test -z "$ac_c_werror_flag"
22558                          || test ! -s conftest.err'
22559   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22560   (eval $ac_try) 2>&5
22561   ac_status=$?
22562   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22563   (exit $ac_status); }; } &&
22564          { ac_try='test -s conftest$ac_exeext'
22565   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22566   (eval $ac_try) 2>&5
22567   ac_status=$?
22568   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22569   (exit $ac_status); }; }; then
22570   ac_cv_lib_m_ynl=yes
22571 else
22572   echo "$as_me: failed program was:" >&5
22573 sed 's/^/| /' conftest.$ac_ext >&5
22574
22575 ac_cv_lib_m_ynl=no
22576 fi
22577 rm -f conftest.err conftest.$ac_objext \
22578       conftest$ac_exeext conftest.$ac_ext
22579 LIBS=$ac_check_lib_save_LIBS
22580 fi
22581 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ynl" >&5
22582 echo "${ECHO_T}$ac_cv_lib_m_ynl" >&6
22583 if test $ac_cv_lib_m_ynl = yes; then
22584
22585 cat >>confdefs.h <<\_ACEOF
22586 #define HAVE_YNL 1
22587 _ACEOF
22588
22589 fi
22590
22591
22592 # On AIX, clog is present in libm as __clog
22593 echo "$as_me:$LINENO: checking for __clog in -lm" >&5
22594 echo $ECHO_N "checking for __clog in -lm... $ECHO_C" >&6
22595 if test "${ac_cv_lib_m___clog+set}" = set; then
22596   echo $ECHO_N "(cached) $ECHO_C" >&6
22597 else
22598   ac_check_lib_save_LIBS=$LIBS
22599 LIBS="-lm  $LIBS"
22600 if test x$gcc_no_link = xyes; then
22601   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22602 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22603    { (exit 1); exit 1; }; }
22604 fi
22605 cat >conftest.$ac_ext <<_ACEOF
22606 /* confdefs.h.  */
22607 _ACEOF
22608 cat confdefs.h >>conftest.$ac_ext
22609 cat >>conftest.$ac_ext <<_ACEOF
22610 /* end confdefs.h.  */
22611
22612 /* Override any gcc2 internal prototype to avoid an error.  */
22613 #ifdef __cplusplus
22614 extern "C"
22615 #endif
22616 /* We use char because int might match the return type of a gcc2
22617    builtin and then its argument prototype would still apply.  */
22618 char __clog ();
22619 int
22620 main ()
22621 {
22622 __clog ();
22623   ;
22624   return 0;
22625 }
22626 _ACEOF
22627 rm -f conftest.$ac_objext conftest$ac_exeext
22628 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22629   (eval $ac_link) 2>conftest.er1
22630   ac_status=$?
22631   grep -v '^ *+' conftest.er1 >conftest.err
22632   rm -f conftest.er1
22633   cat conftest.err >&5
22634   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22635   (exit $ac_status); } &&
22636          { ac_try='test -z "$ac_c_werror_flag"
22637                          || test ! -s conftest.err'
22638   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22639   (eval $ac_try) 2>&5
22640   ac_status=$?
22641   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22642   (exit $ac_status); }; } &&
22643          { ac_try='test -s conftest$ac_exeext'
22644   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22645   (eval $ac_try) 2>&5
22646   ac_status=$?
22647   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22648   (exit $ac_status); }; }; then
22649   ac_cv_lib_m___clog=yes
22650 else
22651   echo "$as_me: failed program was:" >&5
22652 sed 's/^/| /' conftest.$ac_ext >&5
22653
22654 ac_cv_lib_m___clog=no
22655 fi
22656 rm -f conftest.err conftest.$ac_objext \
22657       conftest$ac_exeext conftest.$ac_ext
22658 LIBS=$ac_check_lib_save_LIBS
22659 fi
22660 echo "$as_me:$LINENO: result: $ac_cv_lib_m___clog" >&5
22661 echo "${ECHO_T}$ac_cv_lib_m___clog" >&6
22662 if test $ac_cv_lib_m___clog = yes; then
22663
22664 cat >>confdefs.h <<\_ACEOF
22665 #define HAVE_CLOG 1
22666 _ACEOF
22667
22668 fi
22669
22670
22671 # Check for a isfinite macro that works on long doubles.
22672
22673   echo "$as_me:$LINENO: checking whether isfinite is broken" >&5
22674 echo $ECHO_N "checking whether isfinite is broken... $ECHO_C" >&6
22675 if test "${have_broken_isfinite+set}" = set; then
22676   echo $ECHO_N "(cached) $ECHO_C" >&6
22677 else
22678
22679   libgfor_check_for_broken_isfinite_save_LIBS=$LIBS
22680   LIBS="$LIBS -lm"
22681   if test "$cross_compiling" = yes; then
22682
22683 case "${target}" in
22684   hppa*-*-hpux*) have_broken_isfinite=yes ;;
22685   *) have_broken_isfinite=no ;;
22686 esac
22687 else
22688   cat >conftest.$ac_ext <<_ACEOF
22689 /* confdefs.h.  */
22690 _ACEOF
22691 cat confdefs.h >>conftest.$ac_ext
22692 cat >>conftest.$ac_ext <<_ACEOF
22693 /* end confdefs.h.  */
22694
22695 #ifdef HAVE_MATH_H
22696 #include <math.h>
22697 #endif
22698 #include <float.h>
22699 int main ()
22700 {
22701 #ifdef isfinite
22702 #ifdef LDBL_MAX
22703   if (!isfinite(LDBL_MAX)) return 1;
22704 #endif
22705 #ifdef DBL_MAX
22706   if (!isfinite(DBL_MAX)) return 1;
22707 #endif
22708 #endif
22709 return 0;
22710 }
22711 _ACEOF
22712 rm -f conftest$ac_exeext
22713 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22714   (eval $ac_link) 2>&5
22715   ac_status=$?
22716   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22717   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
22718   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22719   (eval $ac_try) 2>&5
22720   ac_status=$?
22721   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22722   (exit $ac_status); }; }; then
22723   have_broken_isfinite=no
22724 else
22725   echo "$as_me: program exited with status $ac_status" >&5
22726 echo "$as_me: failed program was:" >&5
22727 sed 's/^/| /' conftest.$ac_ext >&5
22728
22729 ( exit $ac_status )
22730 have_broken_isfinite=yes
22731 fi
22732 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
22733 fi
22734   LIBS=$libgfor_check_for_broken_isfinite_save_LIBS
22735 fi
22736 echo "$as_me:$LINENO: result: $have_broken_isfinite" >&5
22737 echo "${ECHO_T}$have_broken_isfinite" >&6
22738 if test x"$have_broken_isfinite" = xyes; then
22739
22740 cat >>confdefs.h <<\_ACEOF
22741 #define HAVE_BROKEN_ISFINITE 1
22742 _ACEOF
22743
22744 fi
22745
22746 # Check for a isnan macro that works on long doubles.
22747
22748   echo "$as_me:$LINENO: checking whether isnan is broken" >&5
22749 echo $ECHO_N "checking whether isnan is broken... $ECHO_C" >&6
22750 if test "${have_broken_isnan+set}" = set; then
22751   echo $ECHO_N "(cached) $ECHO_C" >&6
22752 else
22753
22754   libgfor_check_for_broken_isnan_save_LIBS=$LIBS
22755   LIBS="$LIBS -lm"
22756   if test "$cross_compiling" = yes; then
22757
22758 case "${target}" in
22759   hppa*-*-hpux*) have_broken_isnan=yes ;;
22760   *) have_broken_isnan=no ;;
22761 esac
22762 else
22763   cat >conftest.$ac_ext <<_ACEOF
22764 /* confdefs.h.  */
22765 _ACEOF
22766 cat confdefs.h >>conftest.$ac_ext
22767 cat >>conftest.$ac_ext <<_ACEOF
22768 /* end confdefs.h.  */
22769
22770 #ifdef HAVE_MATH_H
22771 #include <math.h>
22772 #endif
22773 #include <float.h>
22774 int main ()
22775 {
22776 #ifdef isnan
22777 #ifdef LDBL_MAX
22778   {
22779     long double x;
22780     x = __builtin_nanl ("");
22781     if (!isnan(x)) return 1;
22782     if (isnan(LDBL_MAX)) return 1;
22783 #ifdef NAN
22784     x = (long double) NAN;
22785     if (!isnan(x)) return 1;
22786 #endif
22787   }
22788 #endif
22789 #ifdef DBL_MAX
22790   {
22791     double y;
22792     y = __builtin_nan ("");
22793     if (!isnan(y)) return 1;
22794     if (isnan(DBL_MAX)) return 1;
22795 #ifdef NAN
22796     y = (double) NAN;
22797     if (!isnan(y)) return 1;
22798 #endif
22799   }
22800 #endif
22801 #endif
22802 return 0;
22803 }
22804 _ACEOF
22805 rm -f conftest$ac_exeext
22806 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22807   (eval $ac_link) 2>&5
22808   ac_status=$?
22809   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22810   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
22811   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22812   (eval $ac_try) 2>&5
22813   ac_status=$?
22814   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22815   (exit $ac_status); }; }; then
22816   have_broken_isnan=no
22817 else
22818   echo "$as_me: program exited with status $ac_status" >&5
22819 echo "$as_me: failed program was:" >&5
22820 sed 's/^/| /' conftest.$ac_ext >&5
22821
22822 ( exit $ac_status )
22823 have_broken_isnan=yes
22824 fi
22825 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
22826 fi
22827   LIBS=$libgfor_check_for_broken_isnan_save_LIBS
22828 fi
22829 echo "$as_me:$LINENO: result: $have_broken_isnan" >&5
22830 echo "${ECHO_T}$have_broken_isnan" >&6
22831 if test x"$have_broken_isnan" = xyes; then
22832
22833 cat >>confdefs.h <<\_ACEOF
22834 #define HAVE_BROKEN_ISNAN 1
22835 _ACEOF
22836
22837 fi
22838
22839 # Check for a fpclassify macro that works on long doubles.
22840
22841   echo "$as_me:$LINENO: checking whether fpclassify is broken" >&5
22842 echo $ECHO_N "checking whether fpclassify is broken... $ECHO_C" >&6
22843 if test "${have_broken_fpclassify+set}" = set; then
22844   echo $ECHO_N "(cached) $ECHO_C" >&6
22845 else
22846
22847   libgfor_check_for_broken_fpclassify_save_LIBS=$LIBS
22848   LIBS="$LIBS -lm"
22849   if test "$cross_compiling" = yes; then
22850
22851 case "${target}" in
22852   hppa*-*-hpux*) have_broken_fpclassify=yes ;;
22853   *) have_broken_fpclassify=no ;;
22854 esac
22855 else
22856   cat >conftest.$ac_ext <<_ACEOF
22857 /* confdefs.h.  */
22858 _ACEOF
22859 cat confdefs.h >>conftest.$ac_ext
22860 cat >>conftest.$ac_ext <<_ACEOF
22861 /* end confdefs.h.  */
22862
22863 #ifdef HAVE_MATH_H
22864 #include <math.h>
22865 #endif
22866 #include <float.h>
22867 int main ()
22868 {
22869 #ifdef fpclassify
22870 #ifdef LDBL_MAX
22871         if (fpclassify(LDBL_MAX) == FP_NAN
22872             || fpclassify(LDBL_MAX) == FP_INFINITE) return 1;
22873 #endif
22874 #ifdef DBL_MAX
22875         if (fpclassify(DBL_MAX) == FP_NAN
22876             || fpclassify(DBL_MAX) == FP_INFINITE) return 1;
22877 #endif
22878 #endif
22879 return 0;
22880 }
22881 _ACEOF
22882 rm -f conftest$ac_exeext
22883 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22884   (eval $ac_link) 2>&5
22885   ac_status=$?
22886   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22887   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
22888   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22889   (eval $ac_try) 2>&5
22890   ac_status=$?
22891   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22892   (exit $ac_status); }; }; then
22893   have_broken_fpclassify=no
22894 else
22895   echo "$as_me: program exited with status $ac_status" >&5
22896 echo "$as_me: failed program was:" >&5
22897 sed 's/^/| /' conftest.$ac_ext >&5
22898
22899 ( exit $ac_status )
22900 have_broken_fpclassify=yes
22901 fi
22902 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
22903 fi
22904   LIBS=$libgfor_check_for_broken_fpclassify_save_LIBS
22905 fi
22906 echo "$as_me:$LINENO: result: $have_broken_fpclassify" >&5
22907 echo "${ECHO_T}$have_broken_fpclassify" >&6
22908 if test x"$have_broken_fpclassify" = xyes; then
22909
22910 cat >>confdefs.h <<\_ACEOF
22911 #define HAVE_BROKEN_FPCLASSIFY 1
22912 _ACEOF
22913
22914 fi
22915
22916 # Check whether the system has a working stat()
22917
22918   echo "$as_me:$LINENO: checking whether the target stat is reliable" >&5
22919 echo $ECHO_N "checking whether the target stat is reliable... $ECHO_C" >&6
22920 if test "${have_working_stat+set}" = set; then
22921   echo $ECHO_N "(cached) $ECHO_C" >&6
22922 else
22923
22924   if test "$cross_compiling" = yes; then
22925
22926 case "${target}" in
22927   *mingw*) have_working_stat=no ;;
22928   *) have_working_stat=yes;;
22929 esac
22930 else
22931   cat >conftest.$ac_ext <<_ACEOF
22932 /* confdefs.h.  */
22933 _ACEOF
22934 cat confdefs.h >>conftest.$ac_ext
22935 cat >>conftest.$ac_ext <<_ACEOF
22936 /* end confdefs.h.  */
22937
22938 #include <stdio.h>
22939 #include <sys/types.h>
22940 #include <sys/stat.h>
22941 #include <unistd.h>
22942
22943 int main ()
22944 {
22945   FILE *f, *g;
22946   struct stat st1, st2;
22947
22948   f = fopen ("foo", "w");
22949   g = fopen ("bar", "w");
22950   if (stat ("foo", &st1) != 0 || stat ("bar", &st2))
22951     return 1;
22952   if (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino)
22953     return 1;
22954   fclose(f);
22955   fclose(g);
22956   return 0;
22957 }
22958 _ACEOF
22959 rm -f conftest$ac_exeext
22960 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22961   (eval $ac_link) 2>&5
22962   ac_status=$?
22963   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22964   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
22965   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22966   (eval $ac_try) 2>&5
22967   ac_status=$?
22968   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22969   (exit $ac_status); }; }; then
22970   have_working_stat=yes
22971 else
22972   echo "$as_me: program exited with status $ac_status" >&5
22973 echo "$as_me: failed program was:" >&5
22974 sed 's/^/| /' conftest.$ac_ext >&5
22975
22976 ( exit $ac_status )
22977 have_working_stat=no
22978 fi
22979 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
22980 fi
22981 fi
22982 echo "$as_me:$LINENO: result: $have_working_stat" >&5
22983 echo "${ECHO_T}$have_working_stat" >&6
22984 if test x"$have_working_stat" = xyes; then
22985
22986 cat >>confdefs.h <<\_ACEOF
22987 #define HAVE_WORKING_STAT 1
22988 _ACEOF
22989
22990 fi
22991
22992 # Fallback in case isfinite is not available.
22993 echo "$as_me:$LINENO: checking for finite in -lm" >&5
22994 echo $ECHO_N "checking for finite in -lm... $ECHO_C" >&6
22995 if test "${ac_cv_lib_m_finite+set}" = set; then
22996   echo $ECHO_N "(cached) $ECHO_C" >&6
22997 else
22998   ac_check_lib_save_LIBS=$LIBS
22999 LIBS="-lm  $LIBS"
23000 if test x$gcc_no_link = xyes; then
23001   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23002 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23003    { (exit 1); exit 1; }; }
23004 fi
23005 cat >conftest.$ac_ext <<_ACEOF
23006 /* confdefs.h.  */
23007 _ACEOF
23008 cat confdefs.h >>conftest.$ac_ext
23009 cat >>conftest.$ac_ext <<_ACEOF
23010 /* end confdefs.h.  */
23011
23012 /* Override any gcc2 internal prototype to avoid an error.  */
23013 #ifdef __cplusplus
23014 extern "C"
23015 #endif
23016 /* We use char because int might match the return type of a gcc2
23017    builtin and then its argument prototype would still apply.  */
23018 char finite ();
23019 int
23020 main ()
23021 {
23022 finite ();
23023   ;
23024   return 0;
23025 }
23026 _ACEOF
23027 rm -f conftest.$ac_objext conftest$ac_exeext
23028 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23029   (eval $ac_link) 2>conftest.er1
23030   ac_status=$?
23031   grep -v '^ *+' conftest.er1 >conftest.err
23032   rm -f conftest.er1
23033   cat conftest.err >&5
23034   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23035   (exit $ac_status); } &&
23036          { ac_try='test -z "$ac_c_werror_flag"
23037                          || test ! -s conftest.err'
23038   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23039   (eval $ac_try) 2>&5
23040   ac_status=$?
23041   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23042   (exit $ac_status); }; } &&
23043          { ac_try='test -s conftest$ac_exeext'
23044   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23045   (eval $ac_try) 2>&5
23046   ac_status=$?
23047   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23048   (exit $ac_status); }; }; then
23049   ac_cv_lib_m_finite=yes
23050 else
23051   echo "$as_me: failed program was:" >&5
23052 sed 's/^/| /' conftest.$ac_ext >&5
23053
23054 ac_cv_lib_m_finite=no
23055 fi
23056 rm -f conftest.err conftest.$ac_objext \
23057       conftest$ac_exeext conftest.$ac_ext
23058 LIBS=$ac_check_lib_save_LIBS
23059 fi
23060 echo "$as_me:$LINENO: result: $ac_cv_lib_m_finite" >&5
23061 echo "${ECHO_T}$ac_cv_lib_m_finite" >&6
23062 if test $ac_cv_lib_m_finite = yes; then
23063
23064 cat >>confdefs.h <<\_ACEOF
23065 #define HAVE_FINITE 1
23066 _ACEOF
23067
23068 fi
23069
23070
23071 # Check for GNU libc feenableexcept
23072 echo "$as_me:$LINENO: checking for feenableexcept in -lm" >&5
23073 echo $ECHO_N "checking for feenableexcept in -lm... $ECHO_C" >&6
23074 if test "${ac_cv_lib_m_feenableexcept+set}" = set; then
23075   echo $ECHO_N "(cached) $ECHO_C" >&6
23076 else
23077   ac_check_lib_save_LIBS=$LIBS
23078 LIBS="-lm  $LIBS"
23079 if test x$gcc_no_link = xyes; then
23080   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23081 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23082    { (exit 1); exit 1; }; }
23083 fi
23084 cat >conftest.$ac_ext <<_ACEOF
23085 /* confdefs.h.  */
23086 _ACEOF
23087 cat confdefs.h >>conftest.$ac_ext
23088 cat >>conftest.$ac_ext <<_ACEOF
23089 /* end confdefs.h.  */
23090
23091 /* Override any gcc2 internal prototype to avoid an error.  */
23092 #ifdef __cplusplus
23093 extern "C"
23094 #endif
23095 /* We use char because int might match the return type of a gcc2
23096    builtin and then its argument prototype would still apply.  */
23097 char feenableexcept ();
23098 int
23099 main ()
23100 {
23101 feenableexcept ();
23102   ;
23103   return 0;
23104 }
23105 _ACEOF
23106 rm -f conftest.$ac_objext conftest$ac_exeext
23107 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23108   (eval $ac_link) 2>conftest.er1
23109   ac_status=$?
23110   grep -v '^ *+' conftest.er1 >conftest.err
23111   rm -f conftest.er1
23112   cat conftest.err >&5
23113   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23114   (exit $ac_status); } &&
23115          { ac_try='test -z "$ac_c_werror_flag"
23116                          || test ! -s conftest.err'
23117   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23118   (eval $ac_try) 2>&5
23119   ac_status=$?
23120   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23121   (exit $ac_status); }; } &&
23122          { ac_try='test -s conftest$ac_exeext'
23123   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23124   (eval $ac_try) 2>&5
23125   ac_status=$?
23126   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23127   (exit $ac_status); }; }; then
23128   ac_cv_lib_m_feenableexcept=yes
23129 else
23130   echo "$as_me: failed program was:" >&5
23131 sed 's/^/| /' conftest.$ac_ext >&5
23132
23133 ac_cv_lib_m_feenableexcept=no
23134 fi
23135 rm -f conftest.err conftest.$ac_objext \
23136       conftest$ac_exeext conftest.$ac_ext
23137 LIBS=$ac_check_lib_save_LIBS
23138 fi
23139 echo "$as_me:$LINENO: result: $ac_cv_lib_m_feenableexcept" >&5
23140 echo "${ECHO_T}$ac_cv_lib_m_feenableexcept" >&6
23141 if test $ac_cv_lib_m_feenableexcept = yes; then
23142   have_feenableexcept=yes
23143 cat >>confdefs.h <<\_ACEOF
23144 #define HAVE_FEENABLEEXCEPT 1
23145 _ACEOF
23146
23147 fi
23148
23149
23150 # Check for SysV fpsetmask
23151
23152   echo "$as_me:$LINENO: checking whether fpsetmask is present" >&5
23153 echo $ECHO_N "checking whether fpsetmask is present... $ECHO_C" >&6
23154 if test "${have_fpsetmask+set}" = set; then
23155   echo $ECHO_N "(cached) $ECHO_C" >&6
23156 else
23157
23158     if test x$gcc_no_link = xyes; then
23159   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23160 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23161    { (exit 1); exit 1; }; }
23162 fi
23163 cat >conftest.$ac_ext <<_ACEOF
23164 /* confdefs.h.  */
23165 _ACEOF
23166 cat confdefs.h >>conftest.$ac_ext
23167 cat >>conftest.$ac_ext <<_ACEOF
23168 /* end confdefs.h.  */
23169
23170 #if HAVE_FLOATINGPOINT_H
23171 # include <floatingpoint.h>
23172 #endif /* HAVE_FLOATINGPOINT_H */
23173 #if HAVE_IEEEFP_H
23174 # include <ieeefp.h>
23175 #endif /* HAVE_IEEEFP_H */
23176 int
23177 main ()
23178 {
23179 fpsetmask(0);
23180   ;
23181   return 0;
23182 }
23183 _ACEOF
23184 rm -f conftest.$ac_objext conftest$ac_exeext
23185 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23186   (eval $ac_link) 2>conftest.er1
23187   ac_status=$?
23188   grep -v '^ *+' conftest.er1 >conftest.err
23189   rm -f conftest.er1
23190   cat conftest.err >&5
23191   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23192   (exit $ac_status); } &&
23193          { ac_try='test -z "$ac_c_werror_flag"
23194                          || test ! -s conftest.err'
23195   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23196   (eval $ac_try) 2>&5
23197   ac_status=$?
23198   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23199   (exit $ac_status); }; } &&
23200          { ac_try='test -s conftest$ac_exeext'
23201   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23202   (eval $ac_try) 2>&5
23203   ac_status=$?
23204   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23205   (exit $ac_status); }; }; then
23206   eval "have_fpsetmask=yes"
23207 else
23208   echo "$as_me: failed program was:" >&5
23209 sed 's/^/| /' conftest.$ac_ext >&5
23210
23211 eval "have_fpsetmask=no"
23212 fi
23213 rm -f conftest.err conftest.$ac_objext \
23214       conftest$ac_exeext conftest.$ac_ext
23215
23216 fi
23217 echo "$as_me:$LINENO: result: $have_fpsetmask" >&5
23218 echo "${ECHO_T}$have_fpsetmask" >&6
23219   if test x"$have_fpsetmask" = xyes; then
23220
23221 cat >>confdefs.h <<\_ACEOF
23222 #define HAVE_FPSETMASK 1
23223 _ACEOF
23224
23225   fi
23226
23227
23228 # Check for AIX fp_trap and fp_enable
23229 echo "$as_me:$LINENO: checking for fp_trap" >&5
23230 echo $ECHO_N "checking for fp_trap... $ECHO_C" >&6
23231 if test "${ac_cv_func_fp_trap+set}" = set; then
23232   echo $ECHO_N "(cached) $ECHO_C" >&6
23233 else
23234   if test x$gcc_no_link = xyes; then
23235   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23236 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23237    { (exit 1); exit 1; }; }
23238 fi
23239 cat >conftest.$ac_ext <<_ACEOF
23240 /* confdefs.h.  */
23241 _ACEOF
23242 cat confdefs.h >>conftest.$ac_ext
23243 cat >>conftest.$ac_ext <<_ACEOF
23244 /* end confdefs.h.  */
23245 /* Define fp_trap to an innocuous variant, in case <limits.h> declares fp_trap.
23246    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
23247 #define fp_trap innocuous_fp_trap
23248
23249 /* System header to define __stub macros and hopefully few prototypes,
23250     which can conflict with char fp_trap (); below.
23251     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
23252     <limits.h> exists even on freestanding compilers.  */
23253
23254 #ifdef __STDC__
23255 # include <limits.h>
23256 #else
23257 # include <assert.h>
23258 #endif
23259
23260 #undef fp_trap
23261
23262 /* Override any gcc2 internal prototype to avoid an error.  */
23263 #ifdef __cplusplus
23264 extern "C"
23265 {
23266 #endif
23267 /* We use char because int might match the return type of a gcc2
23268    builtin and then its argument prototype would still apply.  */
23269 char fp_trap ();
23270 /* The GNU C library defines this for functions which it implements
23271     to always fail with ENOSYS.  Some functions are actually named
23272     something starting with __ and the normal name is an alias.  */
23273 #if defined (__stub_fp_trap) || defined (__stub___fp_trap)
23274 choke me
23275 #else
23276 char (*f) () = fp_trap;
23277 #endif
23278 #ifdef __cplusplus
23279 }
23280 #endif
23281
23282 int
23283 main ()
23284 {
23285 return f != fp_trap;
23286   ;
23287   return 0;
23288 }
23289 _ACEOF
23290 rm -f conftest.$ac_objext conftest$ac_exeext
23291 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23292   (eval $ac_link) 2>conftest.er1
23293   ac_status=$?
23294   grep -v '^ *+' conftest.er1 >conftest.err
23295   rm -f conftest.er1
23296   cat conftest.err >&5
23297   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23298   (exit $ac_status); } &&
23299          { ac_try='test -z "$ac_c_werror_flag"
23300                          || test ! -s conftest.err'
23301   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23302   (eval $ac_try) 2>&5
23303   ac_status=$?
23304   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23305   (exit $ac_status); }; } &&
23306          { ac_try='test -s conftest$ac_exeext'
23307   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23308   (eval $ac_try) 2>&5
23309   ac_status=$?
23310   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23311   (exit $ac_status); }; }; then
23312   ac_cv_func_fp_trap=yes
23313 else
23314   echo "$as_me: failed program was:" >&5
23315 sed 's/^/| /' conftest.$ac_ext >&5
23316
23317 ac_cv_func_fp_trap=no
23318 fi
23319 rm -f conftest.err conftest.$ac_objext \
23320       conftest$ac_exeext conftest.$ac_ext
23321 fi
23322 echo "$as_me:$LINENO: result: $ac_cv_func_fp_trap" >&5
23323 echo "${ECHO_T}$ac_cv_func_fp_trap" >&6
23324 if test $ac_cv_func_fp_trap = yes; then
23325   have_fp_trap=yes
23326 cat >>confdefs.h <<\_ACEOF
23327 #define HAVE_FP_TRAP 1
23328 _ACEOF
23329
23330 fi
23331
23332 echo "$as_me:$LINENO: checking for fp_enable" >&5
23333 echo $ECHO_N "checking for fp_enable... $ECHO_C" >&6
23334 if test "${ac_cv_func_fp_enable+set}" = set; then
23335   echo $ECHO_N "(cached) $ECHO_C" >&6
23336 else
23337   if test x$gcc_no_link = xyes; then
23338   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23339 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23340    { (exit 1); exit 1; }; }
23341 fi
23342 cat >conftest.$ac_ext <<_ACEOF
23343 /* confdefs.h.  */
23344 _ACEOF
23345 cat confdefs.h >>conftest.$ac_ext
23346 cat >>conftest.$ac_ext <<_ACEOF
23347 /* end confdefs.h.  */
23348 /* Define fp_enable to an innocuous variant, in case <limits.h> declares fp_enable.
23349    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
23350 #define fp_enable innocuous_fp_enable
23351
23352 /* System header to define __stub macros and hopefully few prototypes,
23353     which can conflict with char fp_enable (); below.
23354     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
23355     <limits.h> exists even on freestanding compilers.  */
23356
23357 #ifdef __STDC__
23358 # include <limits.h>
23359 #else
23360 # include <assert.h>
23361 #endif
23362
23363 #undef fp_enable
23364
23365 /* Override any gcc2 internal prototype to avoid an error.  */
23366 #ifdef __cplusplus
23367 extern "C"
23368 {
23369 #endif
23370 /* We use char because int might match the return type of a gcc2
23371    builtin and then its argument prototype would still apply.  */
23372 char fp_enable ();
23373 /* The GNU C library defines this for functions which it implements
23374     to always fail with ENOSYS.  Some functions are actually named
23375     something starting with __ and the normal name is an alias.  */
23376 #if defined (__stub_fp_enable) || defined (__stub___fp_enable)
23377 choke me
23378 #else
23379 char (*f) () = fp_enable;
23380 #endif
23381 #ifdef __cplusplus
23382 }
23383 #endif
23384
23385 int
23386 main ()
23387 {
23388 return f != fp_enable;
23389   ;
23390   return 0;
23391 }
23392 _ACEOF
23393 rm -f conftest.$ac_objext conftest$ac_exeext
23394 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23395   (eval $ac_link) 2>conftest.er1
23396   ac_status=$?
23397   grep -v '^ *+' conftest.er1 >conftest.err
23398   rm -f conftest.er1
23399   cat conftest.err >&5
23400   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23401   (exit $ac_status); } &&
23402          { ac_try='test -z "$ac_c_werror_flag"
23403                          || test ! -s conftest.err'
23404   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23405   (eval $ac_try) 2>&5
23406   ac_status=$?
23407   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23408   (exit $ac_status); }; } &&
23409          { ac_try='test -s conftest$ac_exeext'
23410   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23411   (eval $ac_try) 2>&5
23412   ac_status=$?
23413   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23414   (exit $ac_status); }; }; then
23415   ac_cv_func_fp_enable=yes
23416 else
23417   echo "$as_me: failed program was:" >&5
23418 sed 's/^/| /' conftest.$ac_ext >&5
23419
23420 ac_cv_func_fp_enable=no
23421 fi
23422 rm -f conftest.err conftest.$ac_objext \
23423       conftest$ac_exeext conftest.$ac_ext
23424 fi
23425 echo "$as_me:$LINENO: result: $ac_cv_func_fp_enable" >&5
23426 echo "${ECHO_T}$ac_cv_func_fp_enable" >&6
23427 if test $ac_cv_func_fp_enable = yes; then
23428   have_fp_enable=yes
23429 cat >>confdefs.h <<\_ACEOF
23430 #define HAVE_FP_ENABLE 1
23431 _ACEOF
23432
23433 fi
23434
23435
23436 # Runs configure.host to set up necessary host-dependent shell variables.
23437 # We then display a message about it, and propagate them through the
23438 # build chain.
23439 . ${srcdir}/configure.host
23440 { echo "$as_me:$LINENO: FPU dependent file will be ${fpu_host}.h" >&5
23441 echo "$as_me: FPU dependent file will be ${fpu_host}.h" >&6;}
23442 FPU_HOST_HEADER=config/${fpu_host}.h
23443
23444
23445 # Attempt to assert that the target is of common type in case we don't
23446 # have C99 integer types at all.
23447
23448   echo "$as_me:$LINENO: checking whether the target is ILP32" >&5
23449 echo $ECHO_N "checking whether the target is ILP32... $ECHO_C" >&6
23450 if test "${target_ilp32+set}" = set; then
23451   echo $ECHO_N "(cached) $ECHO_C" >&6
23452 else
23453
23454   save_CFLAGS="$CFLAGS"
23455   CFLAGS="-O2"
23456   if test x$gcc_no_link = xyes; then
23457   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23458 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23459    { (exit 1); exit 1; }; }
23460 fi
23461 cat >conftest.$ac_ext <<_ACEOF
23462 /* confdefs.h.  */
23463 _ACEOF
23464 cat confdefs.h >>conftest.$ac_ext
23465 cat >>conftest.$ac_ext <<_ACEOF
23466 /* end confdefs.h.  */
23467
23468 int
23469 main ()
23470 {
23471
23472 if (sizeof(int) == 4 && sizeof(long) == 4 && sizeof(void *) == 4)
23473   ;
23474 else
23475   undefined_function ();
23476
23477   ;
23478   return 0;
23479 }
23480 _ACEOF
23481 rm -f conftest.$ac_objext conftest$ac_exeext
23482 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23483   (eval $ac_link) 2>conftest.er1
23484   ac_status=$?
23485   grep -v '^ *+' conftest.er1 >conftest.err
23486   rm -f conftest.er1
23487   cat conftest.err >&5
23488   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23489   (exit $ac_status); } &&
23490          { ac_try='test -z "$ac_c_werror_flag"
23491                          || test ! -s conftest.err'
23492   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23493   (eval $ac_try) 2>&5
23494   ac_status=$?
23495   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23496   (exit $ac_status); }; } &&
23497          { ac_try='test -s conftest$ac_exeext'
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); }; }; then
23503   target_ilp32=yes
23504 else
23505   echo "$as_me: failed program was:" >&5
23506 sed 's/^/| /' conftest.$ac_ext >&5
23507
23508 target_ilp32=no
23509 fi
23510 rm -f conftest.err conftest.$ac_objext \
23511       conftest$ac_exeext conftest.$ac_ext
23512   CFLAGS="$save_CFLAGS"
23513 fi
23514 echo "$as_me:$LINENO: result: $target_ilp32" >&5
23515 echo "${ECHO_T}$target_ilp32" >&6
23516   if test $target_ilp32 = yes; then
23517
23518 cat >>confdefs.h <<\_ACEOF
23519 #define TARGET_ILP32 1
23520 _ACEOF
23521
23522   fi
23523
23524
23525 # Check out attribute support.
23526
23527   echo "$as_me:$LINENO: checking whether the target supports hidden visibility" >&5
23528 echo $ECHO_N "checking whether the target supports hidden visibility... $ECHO_C" >&6
23529 if test "${have_attribute_visibility+set}" = set; then
23530   echo $ECHO_N "(cached) $ECHO_C" >&6
23531 else
23532
23533   save_CFLAGS="$CFLAGS"
23534   CFLAGS="$CFLAGS -Werror"
23535   cat >conftest.$ac_ext <<_ACEOF
23536 /* confdefs.h.  */
23537 _ACEOF
23538 cat confdefs.h >>conftest.$ac_ext
23539 cat >>conftest.$ac_ext <<_ACEOF
23540 /* end confdefs.h.  */
23541 void __attribute__((visibility("hidden"))) foo(void) { }
23542 int
23543 main ()
23544 {
23545
23546   ;
23547   return 0;
23548 }
23549 _ACEOF
23550 rm -f conftest.$ac_objext
23551 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
23552   (eval $ac_compile) 2>conftest.er1
23553   ac_status=$?
23554   grep -v '^ *+' conftest.er1 >conftest.err
23555   rm -f conftest.er1
23556   cat conftest.err >&5
23557   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23558   (exit $ac_status); } &&
23559          { ac_try='test -z "$ac_c_werror_flag"
23560                          || test ! -s conftest.err'
23561   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23562   (eval $ac_try) 2>&5
23563   ac_status=$?
23564   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23565   (exit $ac_status); }; } &&
23566          { ac_try='test -s conftest.$ac_objext'
23567   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23568   (eval $ac_try) 2>&5
23569   ac_status=$?
23570   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23571   (exit $ac_status); }; }; then
23572   have_attribute_visibility=yes
23573 else
23574   echo "$as_me: failed program was:" >&5
23575 sed 's/^/| /' conftest.$ac_ext >&5
23576
23577 have_attribute_visibility=no
23578 fi
23579 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
23580   CFLAGS="$save_CFLAGS"
23581 fi
23582 echo "$as_me:$LINENO: result: $have_attribute_visibility" >&5
23583 echo "${ECHO_T}$have_attribute_visibility" >&6
23584   if test $have_attribute_visibility = yes; then
23585
23586 cat >>confdefs.h <<\_ACEOF
23587 #define HAVE_ATTRIBUTE_VISIBILITY 1
23588 _ACEOF
23589
23590   fi
23591
23592   echo "$as_me:$LINENO: checking whether the target supports dllexport" >&5
23593 echo $ECHO_N "checking whether the target supports dllexport... $ECHO_C" >&6
23594 if test "${have_attribute_dllexport+set}" = set; then
23595   echo $ECHO_N "(cached) $ECHO_C" >&6
23596 else
23597
23598   save_CFLAGS="$CFLAGS"
23599   CFLAGS="$CFLAGS -Werror"
23600   cat >conftest.$ac_ext <<_ACEOF
23601 /* confdefs.h.  */
23602 _ACEOF
23603 cat confdefs.h >>conftest.$ac_ext
23604 cat >>conftest.$ac_ext <<_ACEOF
23605 /* end confdefs.h.  */
23606 void __attribute__((dllexport)) foo(void) { }
23607 int
23608 main ()
23609 {
23610
23611   ;
23612   return 0;
23613 }
23614 _ACEOF
23615 rm -f conftest.$ac_objext
23616 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
23617   (eval $ac_compile) 2>conftest.er1
23618   ac_status=$?
23619   grep -v '^ *+' conftest.er1 >conftest.err
23620   rm -f conftest.er1
23621   cat conftest.err >&5
23622   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23623   (exit $ac_status); } &&
23624          { ac_try='test -z "$ac_c_werror_flag"
23625                          || test ! -s conftest.err'
23626   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23627   (eval $ac_try) 2>&5
23628   ac_status=$?
23629   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23630   (exit $ac_status); }; } &&
23631          { ac_try='test -s conftest.$ac_objext'
23632   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23633   (eval $ac_try) 2>&5
23634   ac_status=$?
23635   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23636   (exit $ac_status); }; }; then
23637   have_attribute_dllexport=yes
23638 else
23639   echo "$as_me: failed program was:" >&5
23640 sed 's/^/| /' conftest.$ac_ext >&5
23641
23642 have_attribute_dllexport=no
23643 fi
23644 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
23645   CFLAGS="$save_CFLAGS"
23646 fi
23647 echo "$as_me:$LINENO: result: $have_attribute_dllexport" >&5
23648 echo "${ECHO_T}$have_attribute_dllexport" >&6
23649   if test $have_attribute_dllexport = yes; then
23650
23651 cat >>confdefs.h <<\_ACEOF
23652 #define HAVE_ATTRIBUTE_DLLEXPORT 1
23653 _ACEOF
23654
23655   fi
23656
23657   echo "$as_me:$LINENO: checking whether the target supports symbol aliases" >&5
23658 echo $ECHO_N "checking whether the target supports symbol aliases... $ECHO_C" >&6
23659 if test "${have_attribute_alias+set}" = set; then
23660   echo $ECHO_N "(cached) $ECHO_C" >&6
23661 else
23662
23663   if test x$gcc_no_link = xyes; then
23664   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23665 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23666    { (exit 1); exit 1; }; }
23667 fi
23668 cat >conftest.$ac_ext <<_ACEOF
23669 /* confdefs.h.  */
23670 _ACEOF
23671 cat confdefs.h >>conftest.$ac_ext
23672 cat >>conftest.$ac_ext <<_ACEOF
23673 /* end confdefs.h.  */
23674
23675 void foo(void) { }
23676 extern void bar(void) __attribute__((alias("foo")));
23677 int
23678 main ()
23679 {
23680 bar();
23681   ;
23682   return 0;
23683 }
23684 _ACEOF
23685 rm -f conftest.$ac_objext conftest$ac_exeext
23686 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23687   (eval $ac_link) 2>conftest.er1
23688   ac_status=$?
23689   grep -v '^ *+' conftest.er1 >conftest.err
23690   rm -f conftest.er1
23691   cat conftest.err >&5
23692   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23693   (exit $ac_status); } &&
23694          { ac_try='test -z "$ac_c_werror_flag"
23695                          || test ! -s conftest.err'
23696   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23697   (eval $ac_try) 2>&5
23698   ac_status=$?
23699   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23700   (exit $ac_status); }; } &&
23701          { ac_try='test -s conftest$ac_exeext'
23702   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23703   (eval $ac_try) 2>&5
23704   ac_status=$?
23705   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23706   (exit $ac_status); }; }; then
23707   have_attribute_alias=yes
23708 else
23709   echo "$as_me: failed program was:" >&5
23710 sed 's/^/| /' conftest.$ac_ext >&5
23711
23712 have_attribute_alias=no
23713 fi
23714 rm -f conftest.err conftest.$ac_objext \
23715       conftest$ac_exeext conftest.$ac_ext
23716 fi
23717 echo "$as_me:$LINENO: result: $have_attribute_alias" >&5
23718 echo "${ECHO_T}$have_attribute_alias" >&6
23719   if test $have_attribute_alias = yes; then
23720
23721 cat >>confdefs.h <<\_ACEOF
23722 #define HAVE_ATTRIBUTE_ALIAS 1
23723 _ACEOF
23724
23725   fi
23726
23727 # Check out sync builtins support.
23728
23729   echo "$as_me:$LINENO: checking whether the target supports __sync_fetch_and_add" >&5
23730 echo $ECHO_N "checking whether the target supports __sync_fetch_and_add... $ECHO_C" >&6
23731 if test "${have_sync_fetch_and_add+set}" = set; then
23732   echo $ECHO_N "(cached) $ECHO_C" >&6
23733 else
23734
23735   if test x$gcc_no_link = xyes; then
23736   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23737 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23738    { (exit 1); exit 1; }; }
23739 fi
23740 cat >conftest.$ac_ext <<_ACEOF
23741 /* confdefs.h.  */
23742 _ACEOF
23743 cat confdefs.h >>conftest.$ac_ext
23744 cat >>conftest.$ac_ext <<_ACEOF
23745 /* end confdefs.h.  */
23746 int foovar = 0;
23747 int
23748 main ()
23749 {
23750
23751 if (foovar <= 0) return __sync_fetch_and_add (&foovar, 1);
23752 if (foovar > 10) return __sync_add_and_fetch (&foovar, -1);
23753   ;
23754   return 0;
23755 }
23756 _ACEOF
23757 rm -f conftest.$ac_objext conftest$ac_exeext
23758 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23759   (eval $ac_link) 2>conftest.er1
23760   ac_status=$?
23761   grep -v '^ *+' conftest.er1 >conftest.err
23762   rm -f conftest.er1
23763   cat conftest.err >&5
23764   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23765   (exit $ac_status); } &&
23766          { ac_try='test -z "$ac_c_werror_flag"
23767                          || test ! -s conftest.err'
23768   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23769   (eval $ac_try) 2>&5
23770   ac_status=$?
23771   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23772   (exit $ac_status); }; } &&
23773          { ac_try='test -s conftest$ac_exeext'
23774   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23775   (eval $ac_try) 2>&5
23776   ac_status=$?
23777   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23778   (exit $ac_status); }; }; then
23779   have_sync_fetch_and_add=yes
23780 else
23781   echo "$as_me: failed program was:" >&5
23782 sed 's/^/| /' conftest.$ac_ext >&5
23783
23784 have_sync_fetch_and_add=no
23785 fi
23786 rm -f conftest.err conftest.$ac_objext \
23787       conftest$ac_exeext conftest.$ac_ext
23788 fi
23789 echo "$as_me:$LINENO: result: $have_sync_fetch_and_add" >&5
23790 echo "${ECHO_T}$have_sync_fetch_and_add" >&6
23791   if test $have_sync_fetch_and_add = yes; then
23792
23793 cat >>confdefs.h <<\_ACEOF
23794 #define HAVE_SYNC_FETCH_AND_ADD 1
23795 _ACEOF
23796
23797   fi
23798
23799 # Check out thread support.
23800
23801   echo "$as_me:$LINENO: checking configured target thread model" >&5
23802 echo $ECHO_N "checking configured target thread model... $ECHO_C" >&6
23803 if test "${target_thread_file+set}" = set; then
23804   echo $ECHO_N "(cached) $ECHO_C" >&6
23805 else
23806
23807 target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`
23808 fi
23809 echo "$as_me:$LINENO: result: $target_thread_file" >&5
23810 echo "${ECHO_T}$target_thread_file" >&6
23811
23812   if test $target_thread_file != single; then
23813
23814 cat >>confdefs.h <<\_ACEOF
23815 #define HAVE_GTHR_DEFAULT 1
23816 _ACEOF
23817
23818   fi
23819
23820 # Check out #pragma weak.
23821
23822   echo "$as_me:$LINENO: checking whether pragma weak works" >&5
23823 echo $ECHO_N "checking whether pragma weak works... $ECHO_C" >&6
23824 if test "${have_pragma_weak+set}" = set; then
23825   echo $ECHO_N "(cached) $ECHO_C" >&6
23826 else
23827
23828   gfor_save_CFLAGS="$CFLAGS"
23829   CFLAGS="$CFLAGS -Wunknown-pragmas"
23830   cat >conftest.$ac_ext <<_ACEOF
23831 /* confdefs.h.  */
23832 _ACEOF
23833 cat confdefs.h >>conftest.$ac_ext
23834 cat >>conftest.$ac_ext <<_ACEOF
23835 /* end confdefs.h.  */
23836 void foo (void);
23837 #pragma weak foo
23838 int
23839 main ()
23840 {
23841 if (foo) foo ();
23842   ;
23843   return 0;
23844 }
23845 _ACEOF
23846 rm -f conftest.$ac_objext
23847 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
23848   (eval $ac_compile) 2>conftest.er1
23849   ac_status=$?
23850   grep -v '^ *+' conftest.er1 >conftest.err
23851   rm -f conftest.er1
23852   cat conftest.err >&5
23853   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23854   (exit $ac_status); } &&
23855          { ac_try='test -z "$ac_c_werror_flag"
23856                          || test ! -s conftest.err'
23857   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23858   (eval $ac_try) 2>&5
23859   ac_status=$?
23860   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23861   (exit $ac_status); }; } &&
23862          { ac_try='test -s conftest.$ac_objext'
23863   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23864   (eval $ac_try) 2>&5
23865   ac_status=$?
23866   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23867   (exit $ac_status); }; }; then
23868   have_pragma_weak=yes
23869 else
23870   echo "$as_me: failed program was:" >&5
23871 sed 's/^/| /' conftest.$ac_ext >&5
23872
23873 have_pragma_weak=no
23874 fi
23875 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
23876 fi
23877 echo "$as_me:$LINENO: result: $have_pragma_weak" >&5
23878 echo "${ECHO_T}$have_pragma_weak" >&6
23879   if test $have_pragma_weak = yes; then
23880
23881 cat >>confdefs.h <<\_ACEOF
23882 #define SUPPORTS_WEAK 1
23883 _ACEOF
23884
23885   fi
23886   case "$host" in
23887     *-*-darwin* | *-*-hpux* | *-*-cygwin*)
23888
23889 cat >>confdefs.h <<\_ACEOF
23890 #define GTHREAD_USE_WEAK 0
23891 _ACEOF
23892
23893       ;;
23894   esac
23895
23896 # Various other checks on target
23897
23898   echo "$as_me:$LINENO: checking whether the target can unlink an open file" >&5
23899 echo $ECHO_N "checking whether the target can unlink an open file... $ECHO_C" >&6
23900 if test "${have_unlink_open_file+set}" = set; then
23901   echo $ECHO_N "(cached) $ECHO_C" >&6
23902 else
23903
23904   if test "$cross_compiling" = yes; then
23905
23906 case "${target}" in
23907   *mingw*) have_unlink_open_file=no ;;
23908   *) have_unlink_open_file=yes;;
23909 esac
23910 else
23911   cat >conftest.$ac_ext <<_ACEOF
23912 /* confdefs.h.  */
23913 _ACEOF
23914 cat confdefs.h >>conftest.$ac_ext
23915 cat >>conftest.$ac_ext <<_ACEOF
23916 /* end confdefs.h.  */
23917
23918 #include <errno.h>
23919 #include <fcntl.h>
23920 #include <unistd.h>
23921 #include <sys/stat.h>
23922
23923 int main ()
23924 {
23925   int fd;
23926
23927   fd = open ("testfile", O_RDWR | O_CREAT, S_IWRITE | S_IREAD);
23928   if (fd <= 0)
23929     return 0;
23930   if (unlink ("testfile") == -1)
23931     return 1;
23932   write (fd, "This is a test\n", 15);
23933   close (fd);
23934
23935   if (open ("testfile", O_RDONLY, S_IWRITE | S_IREAD) == -1 && errno == ENOENT)
23936     return 0;
23937   else
23938     return 1;
23939 }
23940 _ACEOF
23941 rm -f conftest$ac_exeext
23942 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23943   (eval $ac_link) 2>&5
23944   ac_status=$?
23945   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23946   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
23947   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23948   (eval $ac_try) 2>&5
23949   ac_status=$?
23950   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23951   (exit $ac_status); }; }; then
23952   have_unlink_open_file=yes
23953 else
23954   echo "$as_me: program exited with status $ac_status" >&5
23955 echo "$as_me: failed program was:" >&5
23956 sed 's/^/| /' conftest.$ac_ext >&5
23957
23958 ( exit $ac_status )
23959 have_unlink_open_file=no
23960 fi
23961 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23962 fi
23963 fi
23964 echo "$as_me:$LINENO: result: $have_unlink_open_file" >&5
23965 echo "${ECHO_T}$have_unlink_open_file" >&6
23966 if test x"$have_unlink_open_file" = xyes; then
23967
23968 cat >>confdefs.h <<\_ACEOF
23969 #define HAVE_UNLINK_OPEN_FILE 1
23970 _ACEOF
23971
23972 fi
23973
23974 # Check whether line terminator is LF or CRLF
23975
23976   echo "$as_me:$LINENO: checking whether the target has CRLF as line terminator" >&5
23977 echo $ECHO_N "checking whether the target has CRLF as line terminator... $ECHO_C" >&6
23978 if test "${have_crlf+set}" = set; then
23979   echo $ECHO_N "(cached) $ECHO_C" >&6
23980 else
23981
23982   if test "$cross_compiling" = yes; then
23983
23984 case "${target}" in
23985   *mingw*) have_crlf=yes ;;
23986   *) have_crlf=no;;
23987 esac
23988 else
23989   cat >conftest.$ac_ext <<_ACEOF
23990 /* confdefs.h.  */
23991 _ACEOF
23992 cat confdefs.h >>conftest.$ac_ext
23993 cat >>conftest.$ac_ext <<_ACEOF
23994 /* end confdefs.h.  */
23995
23996 /* This test program should exit with status 0 if system uses a CRLF as
23997    line terminator, and status 1 otherwise.
23998    Since it is used to check for mingw systems, and should return 0 in any
23999    other case, in case of a failure we will not use CRLF.  */
24000 #include <sys/stat.h>
24001 #include <stdlib.h>
24002 #include <fcntl.h>
24003 #include <stdio.h>
24004
24005 int main ()
24006 {
24007 #ifndef O_BINARY
24008   exit(1);
24009 #else
24010   int fd, bytes;
24011   char buff[5];
24012
24013   fd = open ("foo", O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
24014   if (fd < 0)
24015     exit(1);
24016   if (write (fd, "\n", 1) < 0)
24017     perror ("write");
24018
24019   close (fd);
24020
24021   if ((fd = open ("foo", O_RDONLY | O_BINARY, S_IRWXU)) < 0)
24022     exit(1);
24023   bytes = read (fd, buff, 5);
24024   if (bytes == 2 && buff[0] == '\r' && buff[1] == '\n')
24025     exit(0);
24026   else
24027     exit(1);
24028 #endif
24029 }
24030 _ACEOF
24031 rm -f conftest$ac_exeext
24032 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
24033   (eval $ac_link) 2>&5
24034   ac_status=$?
24035   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24036   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
24037   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24038   (eval $ac_try) 2>&5
24039   ac_status=$?
24040   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24041   (exit $ac_status); }; }; then
24042   have_crlf=yes
24043 else
24044   echo "$as_me: program exited with status $ac_status" >&5
24045 echo "$as_me: failed program was:" >&5
24046 sed 's/^/| /' conftest.$ac_ext >&5
24047
24048 ( exit $ac_status )
24049 have_crlf=no
24050 fi
24051 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
24052 fi
24053 fi
24054 echo "$as_me:$LINENO: result: $have_crlf" >&5
24055 echo "${ECHO_T}$have_crlf" >&6
24056 if test x"$have_crlf" = xyes; then
24057
24058 cat >>confdefs.h <<\_ACEOF
24059 #define HAVE_CRLF 1
24060 _ACEOF
24061
24062 fi
24063
24064 cat >confcache <<\_ACEOF
24065 # This file is a shell script that caches the results of configure
24066 # tests run on this system so they can be shared between configure
24067 # scripts and configure runs, see configure's option --config-cache.
24068 # It is not useful on other systems.  If it contains results you don't
24069 # want to keep, you may remove or edit it.
24070 #
24071 # config.status only pays attention to the cache file if you give it
24072 # the --recheck option to rerun configure.
24073 #
24074 # `ac_cv_env_foo' variables (set or unset) will be overridden when
24075 # loading this file, other *unset* `ac_cv_foo' will be assigned the
24076 # following values.
24077
24078 _ACEOF
24079
24080 # The following way of writing the cache mishandles newlines in values,
24081 # but we know of no workaround that is simple, portable, and efficient.
24082 # So, don't put newlines in cache variables' values.
24083 # Ultrix sh set writes to stderr and can't be redirected directly,
24084 # and sets the high bit in the cache file unless we assign to the vars.
24085 {
24086   (set) 2>&1 |
24087     case `(ac_space=' '; set | grep ac_space) 2>&1` in
24088     *ac_space=\ *)
24089       # `set' does not quote correctly, so add quotes (double-quote
24090       # substitution turns \\\\ into \\, and sed turns \\ into \).
24091       sed -n \
24092         "s/'/'\\\\''/g;
24093           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
24094       ;;
24095     *)
24096       # `set' quotes correctly as required by POSIX, so do not add quotes.
24097       sed -n \
24098         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
24099       ;;
24100     esac;
24101 } |
24102   sed '
24103      t clear
24104      : clear
24105      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
24106      t end
24107      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
24108      : end' >>confcache
24109 if diff $cache_file confcache >/dev/null 2>&1; then :; else
24110   if test -w $cache_file; then
24111     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
24112     cat confcache >$cache_file
24113   else
24114     echo "not updating unwritable cache $cache_file"
24115   fi
24116 fi
24117 rm -f confcache
24118
24119 if test ${multilib} = yes; then
24120   multilib_arg="--enable-multilib"
24121 else
24122   multilib_arg=
24123 fi
24124
24125 # Write our Makefile.
24126           ac_config_files="$ac_config_files Makefile"
24127
24128 cat >confcache <<\_ACEOF
24129 # This file is a shell script that caches the results of configure
24130 # tests run on this system so they can be shared between configure
24131 # scripts and configure runs, see configure's option --config-cache.
24132 # It is not useful on other systems.  If it contains results you don't
24133 # want to keep, you may remove or edit it.
24134 #
24135 # config.status only pays attention to the cache file if you give it
24136 # the --recheck option to rerun configure.
24137 #
24138 # `ac_cv_env_foo' variables (set or unset) will be overridden when
24139 # loading this file, other *unset* `ac_cv_foo' will be assigned the
24140 # following values.
24141
24142 _ACEOF
24143
24144 # The following way of writing the cache mishandles newlines in values,
24145 # but we know of no workaround that is simple, portable, and efficient.
24146 # So, don't put newlines in cache variables' values.
24147 # Ultrix sh set writes to stderr and can't be redirected directly,
24148 # and sets the high bit in the cache file unless we assign to the vars.
24149 {
24150   (set) 2>&1 |
24151     case `(ac_space=' '; set | grep ac_space) 2>&1` in
24152     *ac_space=\ *)
24153       # `set' does not quote correctly, so add quotes (double-quote
24154       # substitution turns \\\\ into \\, and sed turns \\ into \).
24155       sed -n \
24156         "s/'/'\\\\''/g;
24157           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
24158       ;;
24159     *)
24160       # `set' quotes correctly as required by POSIX, so do not add quotes.
24161       sed -n \
24162         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
24163       ;;
24164     esac;
24165 } |
24166   sed '
24167      t clear
24168      : clear
24169      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
24170      t end
24171      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
24172      : end' >>confcache
24173 if diff $cache_file confcache >/dev/null 2>&1; then :; else
24174   if test -w $cache_file; then
24175     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
24176     cat confcache >$cache_file
24177   else
24178     echo "not updating unwritable cache $cache_file"
24179   fi
24180 fi
24181 rm -f confcache
24182
24183 test "x$prefix" = xNONE && prefix=$ac_default_prefix
24184 # Let make expand exec_prefix.
24185 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
24186
24187 # VPATH may cause trouble with some makes, so we remove $(srcdir),
24188 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
24189 # trailing colons and then remove the whole line if VPATH becomes empty
24190 # (actually we leave an empty line to preserve line numbers).
24191 if test "x$srcdir" = x.; then
24192   ac_vpsub='/^[  ]*VPATH[        ]*=/{
24193 s/:*\$(srcdir):*/:/;
24194 s/:*\${srcdir}:*/:/;
24195 s/:*@srcdir@:*/:/;
24196 s/^\([^=]*=[     ]*\):*/\1/;
24197 s/:*$//;
24198 s/^[^=]*=[       ]*$//;
24199 }'
24200 fi
24201
24202 DEFS=-DHAVE_CONFIG_H
24203
24204 ac_libobjs=
24205 ac_ltlibobjs=
24206 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
24207   # 1. Remove the extension, and $U if already installed.
24208   ac_i=`echo "$ac_i" |
24209          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
24210   # 2. Add them.
24211   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
24212   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
24213 done
24214 LIBOBJS=$ac_libobjs
24215
24216 LTLIBOBJS=$ac_ltlibobjs
24217
24218
24219 if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then
24220   { { echo "$as_me:$LINENO: error: conditional \"MAINTAINER_MODE\" was never defined.
24221 Usually this means the macro was only invoked conditionally." >&5
24222 echo "$as_me: error: conditional \"MAINTAINER_MODE\" was never defined.
24223 Usually this means the macro was only invoked conditionally." >&2;}
24224    { (exit 1); exit 1; }; }
24225 fi
24226 if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
24227   { { echo "$as_me:$LINENO: error: conditional \"AMDEP\" was never defined.
24228 Usually this means the macro was only invoked conditionally." >&5
24229 echo "$as_me: error: conditional \"AMDEP\" was never defined.
24230 Usually this means the macro was only invoked conditionally." >&2;}
24231    { (exit 1); exit 1; }; }
24232 fi
24233 if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
24234   { { echo "$as_me:$LINENO: error: conditional \"am__fastdepCC\" was never defined.
24235 Usually this means the macro was only invoked conditionally." >&5
24236 echo "$as_me: error: conditional \"am__fastdepCC\" was never defined.
24237 Usually this means the macro was only invoked conditionally." >&2;}
24238    { (exit 1); exit 1; }; }
24239 fi
24240
24241 : ${CONFIG_STATUS=./config.status}
24242 ac_clean_files_save=$ac_clean_files
24243 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
24244 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
24245 echo "$as_me: creating $CONFIG_STATUS" >&6;}
24246 cat >$CONFIG_STATUS <<_ACEOF
24247 #! $SHELL
24248 # Generated by $as_me.
24249 # Run this file to recreate the current configuration.
24250 # Compiler output produced by configure, useful for debugging
24251 # configure, is in config.log if it exists.
24252
24253 debug=false
24254 ac_cs_recheck=false
24255 ac_cs_silent=false
24256 SHELL=\${CONFIG_SHELL-$SHELL}
24257 _ACEOF
24258
24259 cat >>$CONFIG_STATUS <<\_ACEOF
24260 ## --------------------- ##
24261 ## M4sh Initialization.  ##
24262 ## --------------------- ##
24263
24264 # Be Bourne compatible
24265 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
24266   emulate sh
24267   NULLCMD=:
24268   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
24269   # is contrary to our usage.  Disable this feature.
24270   alias -g '${1+"$@"}'='"$@"'
24271 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
24272   set -o posix
24273 fi
24274 DUALCASE=1; export DUALCASE # for MKS sh
24275
24276 # Support unset when possible.
24277 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
24278   as_unset=unset
24279 else
24280   as_unset=false
24281 fi
24282
24283
24284 # Work around bugs in pre-3.0 UWIN ksh.
24285 $as_unset ENV MAIL MAILPATH
24286 PS1='$ '
24287 PS2='> '
24288 PS4='+ '
24289
24290 # NLS nuisances.
24291 for as_var in \
24292   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
24293   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
24294   LC_TELEPHONE LC_TIME
24295 do
24296   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
24297     eval $as_var=C; export $as_var
24298   else
24299     $as_unset $as_var
24300   fi
24301 done
24302
24303 # Required to use basename.
24304 if expr a : '\(a\)' >/dev/null 2>&1; then
24305   as_expr=expr
24306 else
24307   as_expr=false
24308 fi
24309
24310 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
24311   as_basename=basename
24312 else
24313   as_basename=false
24314 fi
24315
24316
24317 # Name of the executable.
24318 as_me=`$as_basename "$0" ||
24319 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
24320          X"$0" : 'X\(//\)$' \| \
24321          X"$0" : 'X\(/\)$' \| \
24322          .     : '\(.\)' 2>/dev/null ||
24323 echo X/"$0" |
24324     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
24325           /^X\/\(\/\/\)$/{ s//\1/; q; }
24326           /^X\/\(\/\).*/{ s//\1/; q; }
24327           s/.*/./; q'`
24328
24329
24330 # PATH needs CR, and LINENO needs CR and PATH.
24331 # Avoid depending upon Character Ranges.
24332 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
24333 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
24334 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
24335 as_cr_digits='0123456789'
24336 as_cr_alnum=$as_cr_Letters$as_cr_digits
24337
24338 # The user is always right.
24339 if test "${PATH_SEPARATOR+set}" != set; then
24340   echo "#! /bin/sh" >conf$$.sh
24341   echo  "exit 0"   >>conf$$.sh
24342   chmod +x conf$$.sh
24343   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
24344     PATH_SEPARATOR=';'
24345   else
24346     PATH_SEPARATOR=:
24347   fi
24348   rm -f conf$$.sh
24349 fi
24350
24351
24352   as_lineno_1=$LINENO
24353   as_lineno_2=$LINENO
24354   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
24355   test "x$as_lineno_1" != "x$as_lineno_2" &&
24356   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
24357   # Find who we are.  Look in the path if we contain no path at all
24358   # relative or not.
24359   case $0 in
24360     *[\\/]* ) as_myself=$0 ;;
24361     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24362 for as_dir in $PATH
24363 do
24364   IFS=$as_save_IFS
24365   test -z "$as_dir" && as_dir=.
24366   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
24367 done
24368
24369        ;;
24370   esac
24371   # We did not find ourselves, most probably we were run as `sh COMMAND'
24372   # in which case we are not to be found in the path.
24373   if test "x$as_myself" = x; then
24374     as_myself=$0
24375   fi
24376   if test ! -f "$as_myself"; then
24377     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
24378 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
24379    { (exit 1); exit 1; }; }
24380   fi
24381   case $CONFIG_SHELL in
24382   '')
24383     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24384 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
24385 do
24386   IFS=$as_save_IFS
24387   test -z "$as_dir" && as_dir=.
24388   for as_base in sh bash ksh sh5; do
24389          case $as_dir in
24390          /*)
24391            if ("$as_dir/$as_base" -c '
24392   as_lineno_1=$LINENO
24393   as_lineno_2=$LINENO
24394   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
24395   test "x$as_lineno_1" != "x$as_lineno_2" &&
24396   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
24397              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
24398              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
24399              CONFIG_SHELL=$as_dir/$as_base
24400              export CONFIG_SHELL
24401              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
24402            fi;;
24403          esac
24404        done
24405 done
24406 ;;
24407   esac
24408
24409   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
24410   # uniformly replaced by the line number.  The first 'sed' inserts a
24411   # line-number line before each line; the second 'sed' does the real
24412   # work.  The second script uses 'N' to pair each line-number line
24413   # with the numbered line, and appends trailing '-' during
24414   # substitution so that $LINENO is not a special case at line end.
24415   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
24416   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
24417   sed '=' <$as_myself |
24418     sed '
24419       N
24420       s,$,-,
24421       : loop
24422       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
24423       t loop
24424       s,-$,,
24425       s,^['$as_cr_digits']*\n,,
24426     ' >$as_me.lineno &&
24427   chmod +x $as_me.lineno ||
24428     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
24429 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
24430    { (exit 1); exit 1; }; }
24431
24432   # Don't try to exec as it changes $[0], causing all sort of problems
24433   # (the dirname of $[0] is not the place where we might find the
24434   # original and so on.  Autoconf is especially sensible to this).
24435   . ./$as_me.lineno
24436   # Exit status is that of the last command.
24437   exit
24438 }
24439
24440
24441 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
24442   *c*,-n*) ECHO_N= ECHO_C='
24443 ' ECHO_T='      ' ;;
24444   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
24445   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
24446 esac
24447
24448 if expr a : '\(a\)' >/dev/null 2>&1; then
24449   as_expr=expr
24450 else
24451   as_expr=false
24452 fi
24453
24454 rm -f conf$$ conf$$.exe conf$$.file
24455 echo >conf$$.file
24456 if ln -s conf$$.file conf$$ 2>/dev/null; then
24457   # We could just check for DJGPP; but this test a) works b) is more generic
24458   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
24459   if test -f conf$$.exe; then
24460     # Don't use ln at all; we don't have any links
24461     as_ln_s='cp -p'
24462   else
24463     as_ln_s='ln -s'
24464   fi
24465 elif ln conf$$.file conf$$ 2>/dev/null; then
24466   as_ln_s=ln
24467 else
24468   as_ln_s='cp -p'
24469 fi
24470 rm -f conf$$ conf$$.exe conf$$.file
24471
24472 if mkdir -p . 2>/dev/null; then
24473   as_mkdir_p=:
24474 else
24475   test -d ./-p && rmdir ./-p
24476   as_mkdir_p=false
24477 fi
24478
24479 as_executable_p="test -f"
24480
24481 # Sed expression to map a string onto a valid CPP name.
24482 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
24483
24484 # Sed expression to map a string onto a valid variable name.
24485 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
24486
24487
24488 # IFS
24489 # We need space, tab and new line, in precisely that order.
24490 as_nl='
24491 '
24492 IFS="   $as_nl"
24493
24494 # CDPATH.
24495 $as_unset CDPATH
24496
24497 exec 6>&1
24498
24499 # Open the log real soon, to keep \$[0] and so on meaningful, and to
24500 # report actual input values of CONFIG_FILES etc. instead of their
24501 # values after options handling.  Logging --version etc. is OK.
24502 exec 5>>config.log
24503 {
24504   echo
24505   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
24506 ## Running $as_me. ##
24507 _ASBOX
24508 } >&5
24509 cat >&5 <<_CSEOF
24510
24511 This file was extended by GNU Fortran Runtime Library $as_me 0.3, which was
24512 generated by GNU Autoconf 2.59.  Invocation command line was
24513
24514   CONFIG_FILES    = $CONFIG_FILES
24515   CONFIG_HEADERS  = $CONFIG_HEADERS
24516   CONFIG_LINKS    = $CONFIG_LINKS
24517   CONFIG_COMMANDS = $CONFIG_COMMANDS
24518   $ $0 $@
24519
24520 _CSEOF
24521 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
24522 echo >&5
24523 _ACEOF
24524
24525 # Files that config.status was made for.
24526 if test -n "$ac_config_files"; then
24527   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
24528 fi
24529
24530 if test -n "$ac_config_headers"; then
24531   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
24532 fi
24533
24534 if test -n "$ac_config_links"; then
24535   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
24536 fi
24537
24538 if test -n "$ac_config_commands"; then
24539   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
24540 fi
24541
24542 cat >>$CONFIG_STATUS <<\_ACEOF
24543
24544 ac_cs_usage="\
24545 \`$as_me' instantiates files from templates according to the
24546 current configuration.
24547
24548 Usage: $0 [OPTIONS] [FILE]...
24549
24550   -h, --help       print this help, then exit
24551   -V, --version    print version number, then exit
24552   -q, --quiet      do not print progress messages
24553   -d, --debug      don't remove temporary files
24554       --recheck    update $as_me by reconfiguring in the same conditions
24555   --file=FILE[:TEMPLATE]
24556                    instantiate the configuration file FILE
24557   --header=FILE[:TEMPLATE]
24558                    instantiate the configuration header FILE
24559
24560 Configuration files:
24561 $config_files
24562
24563 Configuration headers:
24564 $config_headers
24565
24566 Configuration commands:
24567 $config_commands
24568
24569 Report bugs to <bug-autoconf@gnu.org>."
24570 _ACEOF
24571
24572 cat >>$CONFIG_STATUS <<_ACEOF
24573 ac_cs_version="\\
24574 GNU Fortran Runtime Library config.status 0.3
24575 configured by $0, generated by GNU Autoconf 2.59,
24576   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
24577
24578 Copyright (C) 2003 Free Software Foundation, Inc.
24579 This config.status script is free software; the Free Software Foundation
24580 gives unlimited permission to copy, distribute and modify it."
24581 srcdir=$srcdir
24582 INSTALL="$INSTALL"
24583 _ACEOF
24584
24585 cat >>$CONFIG_STATUS <<\_ACEOF
24586 # If no file are specified by the user, then we need to provide default
24587 # value.  By we need to know if files were specified by the user.
24588 ac_need_defaults=:
24589 while test $# != 0
24590 do
24591   case $1 in
24592   --*=*)
24593     ac_option=`expr "x$1" : 'x\([^=]*\)='`
24594     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
24595     ac_shift=:
24596     ;;
24597   -*)
24598     ac_option=$1
24599     ac_optarg=$2
24600     ac_shift=shift
24601     ;;
24602   *) # This is not an option, so the user has probably given explicit
24603      # arguments.
24604      ac_option=$1
24605      ac_need_defaults=false;;
24606   esac
24607
24608   case $ac_option in
24609   # Handling of the options.
24610 _ACEOF
24611 cat >>$CONFIG_STATUS <<\_ACEOF
24612   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
24613     ac_cs_recheck=: ;;
24614   --version | --vers* | -V )
24615     echo "$ac_cs_version"; exit 0 ;;
24616   --he | --h)
24617     # Conflict between --help and --header
24618     { { echo "$as_me:$LINENO: error: ambiguous option: $1
24619 Try \`$0 --help' for more information." >&5
24620 echo "$as_me: error: ambiguous option: $1
24621 Try \`$0 --help' for more information." >&2;}
24622    { (exit 1); exit 1; }; };;
24623   --help | --hel | -h )
24624     echo "$ac_cs_usage"; exit 0 ;;
24625   --debug | --d* | -d )
24626     debug=: ;;
24627   --file | --fil | --fi | --f )
24628     $ac_shift
24629     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
24630     ac_need_defaults=false;;
24631   --header | --heade | --head | --hea )
24632     $ac_shift
24633     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
24634     ac_need_defaults=false;;
24635   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
24636   | -silent | --silent | --silen | --sile | --sil | --si | --s)
24637     ac_cs_silent=: ;;
24638
24639   # This is an error.
24640   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
24641 Try \`$0 --help' for more information." >&5
24642 echo "$as_me: error: unrecognized option: $1
24643 Try \`$0 --help' for more information." >&2;}
24644    { (exit 1); exit 1; }; } ;;
24645
24646   *) ac_config_targets="$ac_config_targets $1" ;;
24647
24648   esac
24649   shift
24650 done
24651
24652 ac_configure_extra_args=
24653
24654 if $ac_cs_silent; then
24655   exec 6>/dev/null
24656   ac_configure_extra_args="$ac_configure_extra_args --silent"
24657 fi
24658
24659 _ACEOF
24660 cat >>$CONFIG_STATUS <<_ACEOF
24661 if \$ac_cs_recheck; then
24662   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
24663   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
24664 fi
24665
24666 _ACEOF
24667
24668 cat >>$CONFIG_STATUS <<_ACEOF
24669 #
24670 # INIT-COMMANDS section.
24671 #
24672
24673
24674 srcdir="$srcdir"
24675 host="$host"
24676 target="$target"
24677 with_multisubdir="$with_multisubdir"
24678 with_multisrctop="$with_multisrctop"
24679 with_target_subdir="$with_target_subdir"
24680 ac_configure_args="${multilib_arg} ${ac_configure_args}"
24681 multi_basedir="$multi_basedir"
24682 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
24683 CC="$CC"
24684 AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
24685
24686 GCC="$GCC"
24687 CC="$CC"
24688 acx_cv_header_stdint="$acx_cv_header_stdint"
24689 acx_cv_type_int8_t="$acx_cv_type_int8_t"
24690 acx_cv_type_int16_t="$acx_cv_type_int16_t"
24691 acx_cv_type_int32_t="$acx_cv_type_int32_t"
24692 acx_cv_type_int64_t="$acx_cv_type_int64_t"
24693 acx_cv_type_intptr_t="$acx_cv_type_intptr_t"
24694 ac_cv_type_uintmax_t="$ac_cv_type_uintmax_t"
24695 ac_cv_type_uintptr_t="$ac_cv_type_uintptr_t"
24696 ac_cv_type_uint64_t="$ac_cv_type_uint64_t"
24697 ac_cv_type_u_int64_t="$ac_cv_type_u_int64_t"
24698 ac_cv_type_u_int32_t="$ac_cv_type_u_int32_t"
24699 ac_cv_type_int_least32_t="$ac_cv_type_int_least32_t"
24700 ac_cv_type_int_fast32_t="$ac_cv_type_int_fast32_t"
24701 ac_cv_sizeof_void_p="$ac_cv_sizeof_void_p"
24702
24703
24704 _ACEOF
24705
24706
24707
24708 cat >>$CONFIG_STATUS <<\_ACEOF
24709 for ac_config_target in $ac_config_targets
24710 do
24711   case "$ac_config_target" in
24712   # Handling of arguments.
24713   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
24714   "default-1" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default-1" ;;
24715   "depfiles" ) CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
24716   "gstdint.h" ) CONFIG_COMMANDS="$CONFIG_COMMANDS gstdint.h" ;;
24717   "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
24718   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
24719 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
24720    { (exit 1); exit 1; }; };;
24721   esac
24722 done
24723
24724 # If the user did not use the arguments to specify the items to instantiate,
24725 # then the envvar interface is used.  Set only those that are not.
24726 # We use the long form for the default assignment because of an extremely
24727 # bizarre bug on SunOS 4.1.3.
24728 if $ac_need_defaults; then
24729   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
24730   test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
24731   test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
24732 fi
24733
24734 # Have a temporary directory for convenience.  Make it in the build tree
24735 # simply because there is no reason to put it here, and in addition,
24736 # creating and moving files from /tmp can sometimes cause problems.
24737 # Create a temporary directory, and hook for its removal unless debugging.
24738 $debug ||
24739 {
24740   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
24741   trap '{ (exit 1); exit 1; }' 1 2 13 15
24742 }
24743
24744 # Create a (secure) tmp directory for tmp files.
24745
24746 {
24747   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
24748   test -n "$tmp" && test -d "$tmp"
24749 }  ||
24750 {
24751   tmp=./confstat$$-$RANDOM
24752   (umask 077 && mkdir $tmp)
24753 } ||
24754 {
24755    echo "$me: cannot create a temporary directory in ." >&2
24756    { (exit 1); exit 1; }
24757 }
24758
24759 _ACEOF
24760
24761 cat >>$CONFIG_STATUS <<_ACEOF
24762
24763 #
24764 # CONFIG_FILES section.
24765 #
24766
24767 # No need to generate the scripts if there are no CONFIG_FILES.
24768 # This happens for instance when ./config.status config.h
24769 if test -n "\$CONFIG_FILES"; then
24770   # Protect against being on the right side of a sed subst in config.status.
24771   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
24772    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
24773 s,@SHELL@,$SHELL,;t t
24774 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
24775 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
24776 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
24777 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
24778 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
24779 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
24780 s,@exec_prefix@,$exec_prefix,;t t
24781 s,@prefix@,$prefix,;t t
24782 s,@program_transform_name@,$program_transform_name,;t t
24783 s,@bindir@,$bindir,;t t
24784 s,@sbindir@,$sbindir,;t t
24785 s,@libexecdir@,$libexecdir,;t t
24786 s,@datadir@,$datadir,;t t
24787 s,@sysconfdir@,$sysconfdir,;t t
24788 s,@sharedstatedir@,$sharedstatedir,;t t
24789 s,@localstatedir@,$localstatedir,;t t
24790 s,@libdir@,$libdir,;t t
24791 s,@includedir@,$includedir,;t t
24792 s,@oldincludedir@,$oldincludedir,;t t
24793 s,@infodir@,$infodir,;t t
24794 s,@mandir@,$mandir,;t t
24795 s,@build_alias@,$build_alias,;t t
24796 s,@host_alias@,$host_alias,;t t
24797 s,@target_alias@,$target_alias,;t t
24798 s,@DEFS@,$DEFS,;t t
24799 s,@ECHO_C@,$ECHO_C,;t t
24800 s,@ECHO_N@,$ECHO_N,;t t
24801 s,@ECHO_T@,$ECHO_T,;t t
24802 s,@LIBS@,$LIBS,;t t
24803 s,@build@,$build,;t t
24804 s,@build_cpu@,$build_cpu,;t t
24805 s,@build_vendor@,$build_vendor,;t t
24806 s,@build_os@,$build_os,;t t
24807 s,@build_libsubdir@,$build_libsubdir,;t t
24808 s,@build_subdir@,$build_subdir,;t t
24809 s,@host_subdir@,$host_subdir,;t t
24810 s,@target_subdir@,$target_subdir,;t t
24811 s,@host@,$host,;t t
24812 s,@host_cpu@,$host_cpu,;t t
24813 s,@host_vendor@,$host_vendor,;t t
24814 s,@host_os@,$host_os,;t t
24815 s,@target@,$target,;t t
24816 s,@target_cpu@,$target_cpu,;t t
24817 s,@target_vendor@,$target_vendor,;t t
24818 s,@target_os@,$target_os,;t t
24819 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
24820 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
24821 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
24822 s,@CYGPATH_W@,$CYGPATH_W,;t t
24823 s,@PACKAGE@,$PACKAGE,;t t
24824 s,@VERSION@,$VERSION,;t t
24825 s,@ACLOCAL@,$ACLOCAL,;t t
24826 s,@AUTOCONF@,$AUTOCONF,;t t
24827 s,@AUTOMAKE@,$AUTOMAKE,;t t
24828 s,@AUTOHEADER@,$AUTOHEADER,;t t
24829 s,@MAKEINFO@,$MAKEINFO,;t t
24830 s,@install_sh@,$install_sh,;t t
24831 s,@STRIP@,$STRIP,;t t
24832 s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t
24833 s,@INSTALL_STRIP_PROGRAM@,$INSTALL_STRIP_PROGRAM,;t t
24834 s,@mkdir_p@,$mkdir_p,;t t
24835 s,@AWK@,$AWK,;t t
24836 s,@SET_MAKE@,$SET_MAKE,;t t
24837 s,@am__leading_dot@,$am__leading_dot,;t t
24838 s,@AMTAR@,$AMTAR,;t t
24839 s,@am__tar@,$am__tar,;t t
24840 s,@am__untar@,$am__untar,;t t
24841 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
24842 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
24843 s,@MAINT@,$MAINT,;t t
24844 s,@multi_basedir@,$multi_basedir,;t t
24845 s,@toolexecdir@,$toolexecdir,;t t
24846 s,@toolexeclibdir@,$toolexeclibdir,;t t
24847 s,@CC@,$CC,;t t
24848 s,@ac_ct_CC@,$ac_ct_CC,;t t
24849 s,@EXEEXT@,$EXEEXT,;t t
24850 s,@OBJEXT@,$OBJEXT,;t t
24851 s,@DEPDIR@,$DEPDIR,;t t
24852 s,@am__include@,$am__include,;t t
24853 s,@am__quote@,$am__quote,;t t
24854 s,@AMDEP_TRUE@,$AMDEP_TRUE,;t t
24855 s,@AMDEP_FALSE@,$AMDEP_FALSE,;t t
24856 s,@AMDEPBACKSLASH@,$AMDEPBACKSLASH,;t t
24857 s,@CCDEPMODE@,$CCDEPMODE,;t t
24858 s,@am__fastdepCC_TRUE@,$am__fastdepCC_TRUE,;t t
24859 s,@am__fastdepCC_FALSE@,$am__fastdepCC_FALSE,;t t
24860 s,@AM_FCFLAGS@,$AM_FCFLAGS,;t t
24861 s,@AM_CFLAGS@,$AM_CFLAGS,;t t
24862 s,@AS@,$AS,;t t
24863 s,@ac_ct_AS@,$ac_ct_AS,;t t
24864 s,@AR@,$AR,;t t
24865 s,@ac_ct_AR@,$ac_ct_AR,;t t
24866 s,@RANLIB@,$RANLIB,;t t
24867 s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
24868 s,@LN_S@,$LN_S,;t t
24869 s,@LIBTOOL@,$LIBTOOL,;t t
24870 s,@enable_shared@,$enable_shared,;t t
24871 s,@enable_static@,$enable_static,;t t
24872 s,@FC@,$FC,;t t
24873 s,@FCFLAGS@,$FCFLAGS,;t t
24874 s,@LDFLAGS@,$LDFLAGS,;t t
24875 s,@ac_ct_FC@,$ac_ct_FC,;t t
24876 s,@extra_ldflags_libgfortran@,$extra_ldflags_libgfortran,;t t
24877 s,@CPP@,$CPP,;t t
24878 s,@CPPFLAGS@,$CPPFLAGS,;t t
24879 s,@EGREP@,$EGREP,;t t
24880 s,@FPU_HOST_HEADER@,$FPU_HOST_HEADER,;t t
24881 s,@LIBOBJS@,$LIBOBJS,;t t
24882 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
24883 CEOF
24884
24885 _ACEOF
24886
24887   cat >>$CONFIG_STATUS <<\_ACEOF
24888   # Split the substitutions into bite-sized pieces for seds with
24889   # small command number limits, like on Digital OSF/1 and HP-UX.
24890   ac_max_sed_lines=48
24891   ac_sed_frag=1 # Number of current file.
24892   ac_beg=1 # First line for current file.
24893   ac_end=$ac_max_sed_lines # Line after last line for current file.
24894   ac_more_lines=:
24895   ac_sed_cmds=
24896   while $ac_more_lines; do
24897     if test $ac_beg -gt 1; then
24898       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
24899     else
24900       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
24901     fi
24902     if test ! -s $tmp/subs.frag; then
24903       ac_more_lines=false
24904     else
24905       # The purpose of the label and of the branching condition is to
24906       # speed up the sed processing (if there are no `@' at all, there
24907       # is no need to browse any of the substitutions).
24908       # These are the two extra sed commands mentioned above.
24909       (echo ':t
24910   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
24911       if test -z "$ac_sed_cmds"; then
24912         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
24913       else
24914         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
24915       fi
24916       ac_sed_frag=`expr $ac_sed_frag + 1`
24917       ac_beg=$ac_end
24918       ac_end=`expr $ac_end + $ac_max_sed_lines`
24919     fi
24920   done
24921   if test -z "$ac_sed_cmds"; then
24922     ac_sed_cmds=cat
24923   fi
24924 fi # test -n "$CONFIG_FILES"
24925
24926 _ACEOF
24927 cat >>$CONFIG_STATUS <<\_ACEOF
24928 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
24929   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
24930   case $ac_file in
24931   - | *:- | *:-:* ) # input from stdin
24932         cat >$tmp/stdin
24933         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
24934         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
24935   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
24936         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
24937   * )   ac_file_in=$ac_file.in ;;
24938   esac
24939
24940   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
24941   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
24942 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
24943          X"$ac_file" : 'X\(//\)[^/]' \| \
24944          X"$ac_file" : 'X\(//\)$' \| \
24945          X"$ac_file" : 'X\(/\)' \| \
24946          .     : '\(.\)' 2>/dev/null ||
24947 echo X"$ac_file" |
24948     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
24949           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
24950           /^X\(\/\/\)$/{ s//\1/; q; }
24951           /^X\(\/\).*/{ s//\1/; q; }
24952           s/.*/./; q'`
24953   { if $as_mkdir_p; then
24954     mkdir -p "$ac_dir"
24955   else
24956     as_dir="$ac_dir"
24957     as_dirs=
24958     while test ! -d "$as_dir"; do
24959       as_dirs="$as_dir $as_dirs"
24960       as_dir=`(dirname "$as_dir") 2>/dev/null ||
24961 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
24962          X"$as_dir" : 'X\(//\)[^/]' \| \
24963          X"$as_dir" : 'X\(//\)$' \| \
24964          X"$as_dir" : 'X\(/\)' \| \
24965          .     : '\(.\)' 2>/dev/null ||
24966 echo X"$as_dir" |
24967     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
24968           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
24969           /^X\(\/\/\)$/{ s//\1/; q; }
24970           /^X\(\/\).*/{ s//\1/; q; }
24971           s/.*/./; q'`
24972     done
24973     test ! -n "$as_dirs" || mkdir $as_dirs
24974   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
24975 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
24976    { (exit 1); exit 1; }; }; }
24977
24978   ac_builddir=.
24979
24980 if test "$ac_dir" != .; then
24981   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
24982   # A "../" for each directory in $ac_dir_suffix.
24983   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
24984 else
24985   ac_dir_suffix= ac_top_builddir=
24986 fi
24987
24988 case $srcdir in
24989   .)  # No --srcdir option.  We are building in place.
24990     ac_srcdir=.
24991     if test -z "$ac_top_builddir"; then
24992        ac_top_srcdir=.
24993     else
24994        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
24995     fi ;;
24996   [\\/]* | ?:[\\/]* )  # Absolute path.
24997     ac_srcdir=$srcdir$ac_dir_suffix;
24998     ac_top_srcdir=$srcdir ;;
24999   *) # Relative path.
25000     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
25001     ac_top_srcdir=$ac_top_builddir$srcdir ;;
25002 esac
25003
25004 # Do not use `cd foo && pwd` to compute absolute paths, because
25005 # the directories may not exist.
25006 case `pwd` in
25007 .) ac_abs_builddir="$ac_dir";;
25008 *)
25009   case "$ac_dir" in
25010   .) ac_abs_builddir=`pwd`;;
25011   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
25012   *) ac_abs_builddir=`pwd`/"$ac_dir";;
25013   esac;;
25014 esac
25015 case $ac_abs_builddir in
25016 .) ac_abs_top_builddir=${ac_top_builddir}.;;
25017 *)
25018   case ${ac_top_builddir}. in
25019   .) ac_abs_top_builddir=$ac_abs_builddir;;
25020   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
25021   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
25022   esac;;
25023 esac
25024 case $ac_abs_builddir in
25025 .) ac_abs_srcdir=$ac_srcdir;;
25026 *)
25027   case $ac_srcdir in
25028   .) ac_abs_srcdir=$ac_abs_builddir;;
25029   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
25030   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
25031   esac;;
25032 esac
25033 case $ac_abs_builddir in
25034 .) ac_abs_top_srcdir=$ac_top_srcdir;;
25035 *)
25036   case $ac_top_srcdir in
25037   .) ac_abs_top_srcdir=$ac_abs_builddir;;
25038   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
25039   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
25040   esac;;
25041 esac
25042
25043
25044   case $INSTALL in
25045   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
25046   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
25047   esac
25048
25049   if test x"$ac_file" != x-; then
25050     { echo "$as_me:$LINENO: creating $ac_file" >&5
25051 echo "$as_me: creating $ac_file" >&6;}
25052     rm -f "$ac_file"
25053   fi
25054   # Let's still pretend it is `configure' which instantiates (i.e., don't
25055   # use $as_me), people would be surprised to read:
25056   #    /* config.h.  Generated by config.status.  */
25057   if test x"$ac_file" = x-; then
25058     configure_input=
25059   else
25060     configure_input="$ac_file.  "
25061   fi
25062   configure_input=$configure_input"Generated from `echo $ac_file_in |
25063                                      sed 's,.*/,,'` by configure."
25064
25065   # First look for the input files in the build tree, otherwise in the
25066   # src tree.
25067   ac_file_inputs=`IFS=:
25068     for f in $ac_file_in; do
25069       case $f in
25070       -) echo $tmp/stdin ;;
25071       [\\/$]*)
25072          # Absolute (can't be DOS-style, as IFS=:)
25073          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25074 echo "$as_me: error: cannot find input file: $f" >&2;}
25075    { (exit 1); exit 1; }; }
25076          echo "$f";;
25077       *) # Relative
25078          if test -f "$f"; then
25079            # Build tree
25080            echo "$f"
25081          elif test -f "$srcdir/$f"; then
25082            # Source tree
25083            echo "$srcdir/$f"
25084          else
25085            # /dev/null tree
25086            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25087 echo "$as_me: error: cannot find input file: $f" >&2;}
25088    { (exit 1); exit 1; }; }
25089          fi;;
25090       esac
25091     done` || { (exit 1); exit 1; }
25092 _ACEOF
25093 cat >>$CONFIG_STATUS <<_ACEOF
25094   sed "$ac_vpsub
25095 $extrasub
25096 _ACEOF
25097 cat >>$CONFIG_STATUS <<\_ACEOF
25098 :t
25099 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
25100 s,@configure_input@,$configure_input,;t t
25101 s,@srcdir@,$ac_srcdir,;t t
25102 s,@abs_srcdir@,$ac_abs_srcdir,;t t
25103 s,@top_srcdir@,$ac_top_srcdir,;t t
25104 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
25105 s,@builddir@,$ac_builddir,;t t
25106 s,@abs_builddir@,$ac_abs_builddir,;t t
25107 s,@top_builddir@,$ac_top_builddir,;t t
25108 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
25109 s,@INSTALL@,$ac_INSTALL,;t t
25110 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
25111   rm -f $tmp/stdin
25112   if test x"$ac_file" != x-; then
25113     mv $tmp/out $ac_file
25114   else
25115     cat $tmp/out
25116     rm -f $tmp/out
25117   fi
25118
25119 done
25120 _ACEOF
25121 cat >>$CONFIG_STATUS <<\_ACEOF
25122
25123 #
25124 # CONFIG_HEADER section.
25125 #
25126
25127 # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
25128 # NAME is the cpp macro being defined and VALUE is the value it is being given.
25129 #
25130 # ac_d sets the value in "#define NAME VALUE" lines.
25131 ac_dA='s,^\([    ]*\)#\([        ]*define[       ][      ]*\)'
25132 ac_dB='[         ].*$,\1#\2'
25133 ac_dC=' '
25134 ac_dD=',;t'
25135 # ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
25136 ac_uA='s,^\([    ]*\)#\([        ]*\)undef\([    ][      ]*\)'
25137 ac_uB='$,\1#\2define\3'
25138 ac_uC=' '
25139 ac_uD=',;t'
25140
25141 for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue
25142   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
25143   case $ac_file in
25144   - | *:- | *:-:* ) # input from stdin
25145         cat >$tmp/stdin
25146         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25147         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25148   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25149         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25150   * )   ac_file_in=$ac_file.in ;;
25151   esac
25152
25153   test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5
25154 echo "$as_me: creating $ac_file" >&6;}
25155
25156   # First look for the input files in the build tree, otherwise in the
25157   # src tree.
25158   ac_file_inputs=`IFS=:
25159     for f in $ac_file_in; do
25160       case $f in
25161       -) echo $tmp/stdin ;;
25162       [\\/$]*)
25163          # Absolute (can't be DOS-style, as IFS=:)
25164          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25165 echo "$as_me: error: cannot find input file: $f" >&2;}
25166    { (exit 1); exit 1; }; }
25167          # Do quote $f, to prevent DOS paths from being IFS'd.
25168          echo "$f";;
25169       *) # Relative
25170          if test -f "$f"; then
25171            # Build tree
25172            echo "$f"
25173          elif test -f "$srcdir/$f"; then
25174            # Source tree
25175            echo "$srcdir/$f"
25176          else
25177            # /dev/null tree
25178            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25179 echo "$as_me: error: cannot find input file: $f" >&2;}
25180    { (exit 1); exit 1; }; }
25181          fi;;
25182       esac
25183     done` || { (exit 1); exit 1; }
25184   # Remove the trailing spaces.
25185   sed 's/[       ]*$//' $ac_file_inputs >$tmp/in
25186
25187 _ACEOF
25188
25189 # Transform confdefs.h into two sed scripts, `conftest.defines' and
25190 # `conftest.undefs', that substitutes the proper values into
25191 # config.h.in to produce config.h.  The first handles `#define'
25192 # templates, and the second `#undef' templates.
25193 # And first: Protect against being on the right side of a sed subst in
25194 # config.status.  Protect against being in an unquoted here document
25195 # in config.status.
25196 rm -f conftest.defines conftest.undefs
25197 # Using a here document instead of a string reduces the quoting nightmare.
25198 # Putting comments in sed scripts is not portable.
25199 #
25200 # `end' is used to avoid that the second main sed command (meant for
25201 # 0-ary CPP macros) applies to n-ary macro definitions.
25202 # See the Autoconf documentation for `clear'.
25203 cat >confdef2sed.sed <<\_ACEOF
25204 s/[\\&,]/\\&/g
25205 s,[\\$`],\\&,g
25206 t clear
25207 : clear
25208 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
25209 t end
25210 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
25211 : end
25212 _ACEOF
25213 # If some macros were called several times there might be several times
25214 # the same #defines, which is useless.  Nevertheless, we may not want to
25215 # sort them, since we want the *last* AC-DEFINE to be honored.
25216 uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines
25217 sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs
25218 rm -f confdef2sed.sed
25219
25220 # This sed command replaces #undef with comments.  This is necessary, for
25221 # example, in the case of _POSIX_SOURCE, which is predefined and required
25222 # on some systems where configure will not decide to define it.
25223 cat >>conftest.undefs <<\_ACEOF
25224 s,^[     ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
25225 _ACEOF
25226
25227 # Break up conftest.defines because some shells have a limit on the size
25228 # of here documents, and old seds have small limits too (100 cmds).
25229 echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
25230 echo '  if grep "^[      ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
25231 echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
25232 echo '  :' >>$CONFIG_STATUS
25233 rm -f conftest.tail
25234 while grep . conftest.defines >/dev/null
25235 do
25236   # Write a limited-size here document to $tmp/defines.sed.
25237   echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
25238   # Speed up: don't consider the non `#define' lines.
25239   echo '/^[      ]*#[    ]*define/!b' >>$CONFIG_STATUS
25240   # Work around the forget-to-reset-the-flag bug.
25241   echo 't clr' >>$CONFIG_STATUS
25242   echo ': clr' >>$CONFIG_STATUS
25243   sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS
25244   echo 'CEOF
25245   sed -f $tmp/defines.sed $tmp/in >$tmp/out
25246   rm -f $tmp/in
25247   mv $tmp/out $tmp/in
25248 ' >>$CONFIG_STATUS
25249   sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail
25250   rm -f conftest.defines
25251   mv conftest.tail conftest.defines
25252 done
25253 rm -f conftest.defines
25254 echo '  fi # grep' >>$CONFIG_STATUS
25255 echo >>$CONFIG_STATUS
25256
25257 # Break up conftest.undefs because some shells have a limit on the size
25258 # of here documents, and old seds have small limits too (100 cmds).
25259 echo '  # Handle all the #undef templates' >>$CONFIG_STATUS
25260 rm -f conftest.tail
25261 while grep . conftest.undefs >/dev/null
25262 do
25263   # Write a limited-size here document to $tmp/undefs.sed.
25264   echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
25265   # Speed up: don't consider the non `#undef'
25266   echo '/^[      ]*#[    ]*undef/!b' >>$CONFIG_STATUS
25267   # Work around the forget-to-reset-the-flag bug.
25268   echo 't clr' >>$CONFIG_STATUS
25269   echo ': clr' >>$CONFIG_STATUS
25270   sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS
25271   echo 'CEOF
25272   sed -f $tmp/undefs.sed $tmp/in >$tmp/out
25273   rm -f $tmp/in
25274   mv $tmp/out $tmp/in
25275 ' >>$CONFIG_STATUS
25276   sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail
25277   rm -f conftest.undefs
25278   mv conftest.tail conftest.undefs
25279 done
25280 rm -f conftest.undefs
25281
25282 cat >>$CONFIG_STATUS <<\_ACEOF
25283   # Let's still pretend it is `configure' which instantiates (i.e., don't
25284   # use $as_me), people would be surprised to read:
25285   #    /* config.h.  Generated by config.status.  */
25286   if test x"$ac_file" = x-; then
25287     echo "/* Generated by configure.  */" >$tmp/config.h
25288   else
25289     echo "/* $ac_file.  Generated by configure.  */" >$tmp/config.h
25290   fi
25291   cat $tmp/in >>$tmp/config.h
25292   rm -f $tmp/in
25293   if test x"$ac_file" != x-; then
25294     if diff $ac_file $tmp/config.h >/dev/null 2>&1; then
25295       { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
25296 echo "$as_me: $ac_file is unchanged" >&6;}
25297     else
25298       ac_dir=`(dirname "$ac_file") 2>/dev/null ||
25299 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25300          X"$ac_file" : 'X\(//\)[^/]' \| \
25301          X"$ac_file" : 'X\(//\)$' \| \
25302          X"$ac_file" : 'X\(/\)' \| \
25303          .     : '\(.\)' 2>/dev/null ||
25304 echo X"$ac_file" |
25305     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25306           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25307           /^X\(\/\/\)$/{ s//\1/; q; }
25308           /^X\(\/\).*/{ s//\1/; q; }
25309           s/.*/./; q'`
25310       { if $as_mkdir_p; then
25311     mkdir -p "$ac_dir"
25312   else
25313     as_dir="$ac_dir"
25314     as_dirs=
25315     while test ! -d "$as_dir"; do
25316       as_dirs="$as_dir $as_dirs"
25317       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25318 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25319          X"$as_dir" : 'X\(//\)[^/]' \| \
25320          X"$as_dir" : 'X\(//\)$' \| \
25321          X"$as_dir" : 'X\(/\)' \| \
25322          .     : '\(.\)' 2>/dev/null ||
25323 echo X"$as_dir" |
25324     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25325           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25326           /^X\(\/\/\)$/{ s//\1/; q; }
25327           /^X\(\/\).*/{ s//\1/; q; }
25328           s/.*/./; q'`
25329     done
25330     test ! -n "$as_dirs" || mkdir $as_dirs
25331   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
25332 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
25333    { (exit 1); exit 1; }; }; }
25334
25335       rm -f $ac_file
25336       mv $tmp/config.h $ac_file
25337     fi
25338   else
25339     cat $tmp/config.h
25340     rm -f $tmp/config.h
25341   fi
25342 # Compute $ac_file's index in $config_headers.
25343 _am_stamp_count=1
25344 for _am_header in $config_headers :; do
25345   case $_am_header in
25346     $ac_file | $ac_file:* )
25347       break ;;
25348     * )
25349       _am_stamp_count=`expr $_am_stamp_count + 1` ;;
25350   esac
25351 done
25352 echo "timestamp for $ac_file" >`(dirname $ac_file) 2>/dev/null ||
25353 $as_expr X$ac_file : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25354          X$ac_file : 'X\(//\)[^/]' \| \
25355          X$ac_file : 'X\(//\)$' \| \
25356          X$ac_file : 'X\(/\)' \| \
25357          .     : '\(.\)' 2>/dev/null ||
25358 echo X$ac_file |
25359     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25360           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25361           /^X\(\/\/\)$/{ s//\1/; q; }
25362           /^X\(\/\).*/{ s//\1/; q; }
25363           s/.*/./; q'`/stamp-h$_am_stamp_count
25364 done
25365 _ACEOF
25366 cat >>$CONFIG_STATUS <<\_ACEOF
25367
25368 #
25369 # CONFIG_COMMANDS section.
25370 #
25371 for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue
25372   ac_dest=`echo "$ac_file" | sed 's,:.*,,'`
25373   ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`
25374   ac_dir=`(dirname "$ac_dest") 2>/dev/null ||
25375 $as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25376          X"$ac_dest" : 'X\(//\)[^/]' \| \
25377          X"$ac_dest" : 'X\(//\)$' \| \
25378          X"$ac_dest" : 'X\(/\)' \| \
25379          .     : '\(.\)' 2>/dev/null ||
25380 echo X"$ac_dest" |
25381     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25382           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25383           /^X\(\/\/\)$/{ s//\1/; q; }
25384           /^X\(\/\).*/{ s//\1/; q; }
25385           s/.*/./; q'`
25386   { if $as_mkdir_p; then
25387     mkdir -p "$ac_dir"
25388   else
25389     as_dir="$ac_dir"
25390     as_dirs=
25391     while test ! -d "$as_dir"; do
25392       as_dirs="$as_dir $as_dirs"
25393       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25394 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25395          X"$as_dir" : 'X\(//\)[^/]' \| \
25396          X"$as_dir" : 'X\(//\)$' \| \
25397          X"$as_dir" : 'X\(/\)' \| \
25398          .     : '\(.\)' 2>/dev/null ||
25399 echo X"$as_dir" |
25400     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25401           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25402           /^X\(\/\/\)$/{ s//\1/; q; }
25403           /^X\(\/\).*/{ s//\1/; q; }
25404           s/.*/./; q'`
25405     done
25406     test ! -n "$as_dirs" || mkdir $as_dirs
25407   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
25408 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
25409    { (exit 1); exit 1; }; }; }
25410
25411   ac_builddir=.
25412
25413 if test "$ac_dir" != .; then
25414   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
25415   # A "../" for each directory in $ac_dir_suffix.
25416   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
25417 else
25418   ac_dir_suffix= ac_top_builddir=
25419 fi
25420
25421 case $srcdir in
25422   .)  # No --srcdir option.  We are building in place.
25423     ac_srcdir=.
25424     if test -z "$ac_top_builddir"; then
25425        ac_top_srcdir=.
25426     else
25427        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
25428     fi ;;
25429   [\\/]* | ?:[\\/]* )  # Absolute path.
25430     ac_srcdir=$srcdir$ac_dir_suffix;
25431     ac_top_srcdir=$srcdir ;;
25432   *) # Relative path.
25433     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
25434     ac_top_srcdir=$ac_top_builddir$srcdir ;;
25435 esac
25436
25437 # Do not use `cd foo && pwd` to compute absolute paths, because
25438 # the directories may not exist.
25439 case `pwd` in
25440 .) ac_abs_builddir="$ac_dir";;
25441 *)
25442   case "$ac_dir" in
25443   .) ac_abs_builddir=`pwd`;;
25444   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
25445   *) ac_abs_builddir=`pwd`/"$ac_dir";;
25446   esac;;
25447 esac
25448 case $ac_abs_builddir in
25449 .) ac_abs_top_builddir=${ac_top_builddir}.;;
25450 *)
25451   case ${ac_top_builddir}. in
25452   .) ac_abs_top_builddir=$ac_abs_builddir;;
25453   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
25454   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
25455   esac;;
25456 esac
25457 case $ac_abs_builddir in
25458 .) ac_abs_srcdir=$ac_srcdir;;
25459 *)
25460   case $ac_srcdir in
25461   .) ac_abs_srcdir=$ac_abs_builddir;;
25462   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
25463   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
25464   esac;;
25465 esac
25466 case $ac_abs_builddir in
25467 .) ac_abs_top_srcdir=$ac_top_srcdir;;
25468 *)
25469   case $ac_top_srcdir in
25470   .) ac_abs_top_srcdir=$ac_abs_builddir;;
25471   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
25472   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
25473   esac;;
25474 esac
25475
25476
25477   { echo "$as_me:$LINENO: executing $ac_dest commands" >&5
25478 echo "$as_me: executing $ac_dest commands" >&6;}
25479   case $ac_dest in
25480     default-1 )
25481 # Only add multilib support code if we just rebuilt the top-level
25482 # Makefile.
25483 case " $CONFIG_FILES " in
25484  *" Makefile "*)
25485    ac_file=Makefile . ${multi_basedir}/config-ml.in
25486    ;;
25487 esac ;;
25488     depfiles ) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do
25489   # Strip MF so we end up with the name of the file.
25490   mf=`echo "$mf" | sed -e 's/:.*$//'`
25491   # Check whether this is an Automake generated Makefile or not.
25492   # We used to match only the files named `Makefile.in', but
25493   # some people rename them; so instead we look at the file content.
25494   # Grep'ing the first line is not enough: some people post-process
25495   # each Makefile.in and add a new line on top of each file to say so.
25496   # So let's grep whole file.
25497   if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then
25498     dirpart=`(dirname "$mf") 2>/dev/null ||
25499 $as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25500          X"$mf" : 'X\(//\)[^/]' \| \
25501          X"$mf" : 'X\(//\)$' \| \
25502          X"$mf" : 'X\(/\)' \| \
25503          .     : '\(.\)' 2>/dev/null ||
25504 echo X"$mf" |
25505     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25506           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25507           /^X\(\/\/\)$/{ s//\1/; q; }
25508           /^X\(\/\).*/{ s//\1/; q; }
25509           s/.*/./; q'`
25510   else
25511     continue
25512   fi
25513   # Extract the definition of DEPDIR, am__include, and am__quote
25514   # from the Makefile without running `make'.
25515   DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
25516   test -z "$DEPDIR" && continue
25517   am__include=`sed -n 's/^am__include = //p' < "$mf"`
25518   test -z "am__include" && continue
25519   am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
25520   # When using ansi2knr, U may be empty or an underscore; expand it
25521   U=`sed -n 's/^U = //p' < "$mf"`
25522   # Find all dependency output files, they are included files with
25523   # $(DEPDIR) in their names.  We invoke sed twice because it is the
25524   # simplest approach to changing $(DEPDIR) to its actual value in the
25525   # expansion.
25526   for file in `sed -n "
25527     s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
25528        sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
25529     # Make sure the directory exists.
25530     test -f "$dirpart/$file" && continue
25531     fdir=`(dirname "$file") 2>/dev/null ||
25532 $as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25533          X"$file" : 'X\(//\)[^/]' \| \
25534          X"$file" : 'X\(//\)$' \| \
25535          X"$file" : 'X\(/\)' \| \
25536          .     : '\(.\)' 2>/dev/null ||
25537 echo X"$file" |
25538     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25539           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25540           /^X\(\/\/\)$/{ s//\1/; q; }
25541           /^X\(\/\).*/{ s//\1/; q; }
25542           s/.*/./; q'`
25543     { if $as_mkdir_p; then
25544     mkdir -p $dirpart/$fdir
25545   else
25546     as_dir=$dirpart/$fdir
25547     as_dirs=
25548     while test ! -d "$as_dir"; do
25549       as_dirs="$as_dir $as_dirs"
25550       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25551 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25552          X"$as_dir" : 'X\(//\)[^/]' \| \
25553          X"$as_dir" : 'X\(//\)$' \| \
25554          X"$as_dir" : 'X\(/\)' \| \
25555          .     : '\(.\)' 2>/dev/null ||
25556 echo X"$as_dir" |
25557     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25558           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25559           /^X\(\/\/\)$/{ s//\1/; q; }
25560           /^X\(\/\).*/{ s//\1/; q; }
25561           s/.*/./; q'`
25562     done
25563     test ! -n "$as_dirs" || mkdir $as_dirs
25564   fi || { { echo "$as_me:$LINENO: error: cannot create directory $dirpart/$fdir" >&5
25565 echo "$as_me: error: cannot create directory $dirpart/$fdir" >&2;}
25566    { (exit 1); exit 1; }; }; }
25567
25568     # echo "creating $dirpart/$file"
25569     echo '# dummy' > "$dirpart/$file"
25570   done
25571 done
25572  ;;
25573     gstdint.h )
25574 if test "$GCC" = yes; then
25575   echo "/* generated for " `$CC --version | sed 1q` "*/" > tmp-stdint.h
25576 else
25577   echo "/* generated for $CC */" > tmp-stdint.h
25578 fi
25579
25580 sed 's/^ *//' >> tmp-stdint.h <<EOF
25581
25582   #ifndef GCC_GENERATED_STDINT_H
25583   #define GCC_GENERATED_STDINT_H 1
25584
25585   #include <sys/types.h>
25586 EOF
25587
25588 if test "$acx_cv_header_stdint" != stdint.h; then
25589   echo "#include <stddef.h>" >> tmp-stdint.h
25590 fi
25591 if test "$acx_cv_header_stdint" != stddef.h; then
25592   echo "#include <$acx_cv_header_stdint>" >> tmp-stdint.h
25593 fi
25594
25595 sed 's/^ *//' >> tmp-stdint.h <<EOF
25596   /* glibc uses these symbols as guards to prevent redefinitions.  */
25597   #ifdef __int8_t_defined
25598   #define _INT8_T
25599   #define _INT16_T
25600   #define _INT32_T
25601   #endif
25602   #ifdef __uint32_t_defined
25603   #define _UINT32_T
25604   #endif
25605
25606 EOF
25607
25608 # ----------------- done header, emit basic int types -------------
25609 if test "$acx_cv_header_stdint" = stddef.h; then
25610   sed 's/^ *//' >> tmp-stdint.h <<EOF
25611
25612     #ifndef _UINT8_T
25613     #define _UINT8_T
25614     typedef unsigned $acx_cv_type_int8_t uint8_t;
25615     #endif
25616
25617     #ifndef _UINT16_T
25618     #define _UINT16_T
25619     typedef unsigned $acx_cv_type_int16_t uint16_t;
25620     #endif
25621
25622     #ifndef _UINT32_T
25623     #define _UINT32_T
25624     typedef unsigned $acx_cv_type_int32_t uint32_t;
25625     #endif
25626
25627     #ifndef _INT8_T
25628     #define _INT8_T
25629     typedef $acx_cv_type_int8_t int8_t;
25630     #endif
25631
25632     #ifndef _INT16_T
25633     #define _INT16_T
25634     typedef $acx_cv_type_int16_t int16_t;
25635     #endif
25636
25637     #ifndef _INT32_T
25638     #define _INT32_T
25639     typedef $acx_cv_type_int32_t int32_t;
25640     #endif
25641 EOF
25642 elif test "$ac_cv_type_u_int32_t" = yes; then
25643   sed 's/^ *//' >> tmp-stdint.h <<EOF
25644
25645     /* int8_t int16_t int32_t defined by inet code, we do the u_intXX types */
25646     #ifndef _INT8_T
25647     #define _INT8_T
25648     #endif
25649     #ifndef _INT16_T
25650     #define _INT16_T
25651     #endif
25652     #ifndef _INT32_T
25653     #define _INT32_T
25654     #endif
25655
25656     #ifndef _UINT8_T
25657     #define _UINT8_T
25658     typedef u_int8_t uint8_t;
25659     #endif
25660
25661     #ifndef _UINT16_T
25662     #define _UINT16_T
25663     typedef u_int16_t uint16_t;
25664     #endif
25665
25666     #ifndef _UINT32_T
25667     #define _UINT32_T
25668     typedef u_int32_t uint32_t;
25669     #endif
25670 EOF
25671 else
25672   sed 's/^ *//' >> tmp-stdint.h <<EOF
25673
25674     /* Some systems have guard macros to prevent redefinitions, define them.  */
25675     #ifndef _INT8_T
25676     #define _INT8_T
25677     #endif
25678     #ifndef _INT16_T
25679     #define _INT16_T
25680     #endif
25681     #ifndef _INT32_T
25682     #define _INT32_T
25683     #endif
25684     #ifndef _UINT8_T
25685     #define _UINT8_T
25686     #endif
25687     #ifndef _UINT16_T
25688     #define _UINT16_T
25689     #endif
25690     #ifndef _UINT32_T
25691     #define _UINT32_T
25692     #endif
25693 EOF
25694 fi
25695
25696 # ------------- done basic int types, emit int64_t types ------------
25697 if test "$ac_cv_type_uint64_t" = yes; then
25698   sed 's/^ *//' >> tmp-stdint.h <<EOF
25699
25700     /* system headers have good uint64_t and int64_t */
25701     #ifndef _INT64_T
25702     #define _INT64_T
25703     #endif
25704     #ifndef _UINT64_T
25705     #define _UINT64_T
25706     #endif
25707 EOF
25708 elif test "$ac_cv_type_u_int64_t" = yes; then
25709   sed 's/^ *//' >> tmp-stdint.h <<EOF
25710
25711     /* system headers have an u_int64_t (and int64_t) */
25712     #ifndef _INT64_T
25713     #define _INT64_T
25714     #endif
25715     #ifndef _UINT64_T
25716     #define _UINT64_T
25717     typedef u_int64_t uint64_t;
25718     #endif
25719 EOF
25720 elif test -n "$acx_cv_type_int64_t"; then
25721   sed 's/^ *//' >> tmp-stdint.h <<EOF
25722
25723     /* architecture has a 64-bit type, $acx_cv_type_int64_t */
25724     #ifndef _INT64_T
25725     #define _INT64_T
25726     typedef $acx_cv_type_int64_t int64_t;
25727     #endif
25728     #ifndef _UINT64_T
25729     #define _UINT64_T
25730     typedef unsigned $acx_cv_type_int64_t uint64_t;
25731     #endif
25732 EOF
25733 else
25734   sed 's/^ *//' >> tmp-stdint.h <<EOF
25735
25736     /* some common heuristics for int64_t, using compiler-specific tests */
25737     #if defined __STDC_VERSION__ && (__STDC_VERSION__-0) >= 199901L
25738     #ifndef _INT64_T
25739     #define _INT64_T
25740     typedef long long int64_t;
25741     #endif
25742     #ifndef _UINT64_T
25743     #define _UINT64_T
25744     typedef unsigned long long uint64_t;
25745     #endif
25746
25747     #elif defined __GNUC__ && defined (__STDC__) && __STDC__-0
25748     /* NextStep 2.0 cc is really gcc 1.93 but it defines __GNUC__ = 2 and
25749        does not implement __extension__.  But that compiler doesn't define
25750        __GNUC_MINOR__.  */
25751     # if __GNUC__ < 2 || (__NeXT__ && !__GNUC_MINOR__)
25752     # define __extension__
25753     # endif
25754
25755     # ifndef _INT64_T
25756     # define _INT64_T
25757     __extension__ typedef long long int64_t;
25758     # endif
25759     # ifndef _UINT64_T
25760     # define _UINT64_T
25761     __extension__ typedef unsigned long long uint64_t;
25762     # endif
25763
25764     #elif !defined __STRICT_ANSI__
25765     # if defined _MSC_VER || defined __WATCOMC__ || defined __BORLANDC__
25766
25767     #  ifndef _INT64_T
25768     #  define _INT64_T
25769     typedef __int64 int64_t;
25770     #  endif
25771     #  ifndef _UINT64_T
25772     #  define _UINT64_T
25773     typedef unsigned __int64 uint64_t;
25774     #  endif
25775     # endif /* compiler */
25776
25777     #endif /* ANSI version */
25778 EOF
25779 fi
25780
25781 # ------------- done int64_t types, emit intptr types ------------
25782 if test "$ac_cv_type_uintptr_t" != yes; then
25783   sed 's/^ *//' >> tmp-stdint.h <<EOF
25784
25785     /* Define intptr_t based on sizeof(void*) = $ac_cv_sizeof_void_p */
25786     typedef u$acx_cv_type_intptr_t uintptr_t;
25787     typedef $acx_cv_type_intptr_t  intptr_t;
25788 EOF
25789 fi
25790
25791 # ------------- done intptr types, emit int_least types ------------
25792 if test "$ac_cv_type_int_least32_t" != yes; then
25793   sed 's/^ *//' >> tmp-stdint.h <<EOF
25794
25795     /* Define int_least types */
25796     typedef int8_t     int_least8_t;
25797     typedef int16_t    int_least16_t;
25798     typedef int32_t    int_least32_t;
25799     #ifdef _INT64_T
25800     typedef int64_t    int_least64_t;
25801     #endif
25802
25803     typedef uint8_t    uint_least8_t;
25804     typedef uint16_t   uint_least16_t;
25805     typedef uint32_t   uint_least32_t;
25806     #ifdef _UINT64_T
25807     typedef uint64_t   uint_least64_t;
25808     #endif
25809 EOF
25810 fi
25811
25812 # ------------- done intptr types, emit int_fast types ------------
25813 if test "$ac_cv_type_int_fast32_t" != yes; then
25814       sed 's/^ *//' >> tmp-stdint.h <<EOF
25815
25816     /* Define int_fast types.  short is often slow */
25817     typedef int8_t       int_fast8_t;
25818     typedef int          int_fast16_t;
25819     typedef int32_t      int_fast32_t;
25820     #ifdef _INT64_T
25821     typedef int64_t      int_fast64_t;
25822     #endif
25823
25824     typedef uint8_t      uint_fast8_t;
25825     typedef unsigned int uint_fast16_t;
25826     typedef uint32_t     uint_fast32_t;
25827     #ifdef _UINT64_T
25828     typedef uint64_t     uint_fast64_t;
25829     #endif
25830 EOF
25831 fi
25832
25833 if test "$ac_cv_type_uintmax_t" != yes; then
25834   sed 's/^ *//' >> tmp-stdint.h <<EOF
25835
25836     /* Define intmax based on what we found */
25837     #ifdef _INT64_T
25838     typedef int64_t       intmax_t;
25839     #else
25840     typedef long          intmax_t;
25841     #endif
25842     #ifdef _UINT64_T
25843     typedef uint64_t      uintmax_t;
25844     #else
25845     typedef unsigned long uintmax_t;
25846     #endif
25847 EOF
25848 fi
25849
25850 sed 's/^ *//' >> tmp-stdint.h <<EOF
25851
25852   #endif /* GCC_GENERATED_STDINT_H */
25853 EOF
25854
25855 if test -r gstdint.h && cmp -s tmp-stdint.h gstdint.h; then
25856   rm -f tmp-stdint.h
25857 else
25858   mv -f tmp-stdint.h gstdint.h
25859 fi
25860
25861  ;;
25862   esac
25863 done
25864 _ACEOF
25865
25866 cat >>$CONFIG_STATUS <<\_ACEOF
25867
25868 { (exit 0); exit 0; }
25869 _ACEOF
25870 chmod +x $CONFIG_STATUS
25871 ac_clean_files=$ac_clean_files_save
25872
25873
25874 # configure is writing to config.log, and then calls config.status.
25875 # config.status does its own redirection, appending to config.log.
25876 # Unfortunately, on DOS this fails, as config.log is still kept open
25877 # by configure, so config.status won't be able to write to it; its
25878 # output is simply discarded.  So we exec the FD to /dev/null,
25879 # effectively closing config.log, so it can be properly (re)opened and
25880 # appended to by config.status.  When coming back to configure, we
25881 # need to make the FD available again.
25882 if test "$no_create" != yes; then
25883   ac_cs_success=:
25884   ac_config_status_args=
25885   test "$silent" = yes &&
25886     ac_config_status_args="$ac_config_status_args --quiet"
25887   exec 5>/dev/null
25888   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
25889   exec 5>>config.log
25890   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
25891   # would make configure fail if this is the last instruction.
25892   $ac_cs_success || { (exit 1); exit 1; }
25893 fi
25894