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 LIBGFOR_USE_SYMVER_TRUE LIBGFOR_USE_SYMVER_FALSE 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 # Check for symbol versioning (copied from libssp).
3210 echo "$as_me:$LINENO: checking whether symbol versioning is supported" >&5
3211 echo $ECHO_N "checking whether symbol versioning is supported... $ECHO_C" >&6
3212 cat > conftest.map <<EOF
3213 FOO_1.0 {
3214   global: *foo*; bar; local: *;
3215 };
3216 EOF
3217 save_LDFLAGS="$LDFLAGS"
3218 LDFLAGS="$LDFLAGS -fPIC -shared -Wl,--version-script,./conftest.map"
3219
3220 if test x$gcc_no_link = xyes; then
3221   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
3222 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
3223    { (exit 1); exit 1; }; }
3224 fi
3225 cat >conftest.$ac_ext <<_ACEOF
3226 /* confdefs.h.  */
3227 _ACEOF
3228 cat confdefs.h >>conftest.$ac_ext
3229 cat >>conftest.$ac_ext <<_ACEOF
3230 /* end confdefs.h.  */
3231 int foo;
3232 int
3233 main ()
3234 {
3235
3236   ;
3237   return 0;
3238 }
3239 _ACEOF
3240 rm -f conftest.$ac_objext conftest$ac_exeext
3241 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3242   (eval $ac_link) 2>conftest.er1
3243   ac_status=$?
3244   grep -v '^ *+' conftest.er1 >conftest.err
3245   rm -f conftest.er1
3246   cat conftest.err >&5
3247   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3248   (exit $ac_status); } &&
3249          { ac_try='test -z "$ac_c_werror_flag"
3250                          || test ! -s conftest.err'
3251   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3252   (eval $ac_try) 2>&5
3253   ac_status=$?
3254   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3255   (exit $ac_status); }; } &&
3256          { ac_try='test -s conftest$ac_exeext'
3257   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3258   (eval $ac_try) 2>&5
3259   ac_status=$?
3260   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3261   (exit $ac_status); }; }; then
3262   gfortran_use_symver=yes
3263 else
3264   echo "$as_me: failed program was:" >&5
3265 sed 's/^/| /' conftest.$ac_ext >&5
3266
3267 gfortran_use_symver=no
3268 fi
3269 rm -f conftest.err conftest.$ac_objext \
3270       conftest$ac_exeext conftest.$ac_ext
3271 LDFLAGS="$save_LDFLAGS"
3272 echo "$as_me:$LINENO: result: $gfortran_use_symver" >&5
3273 echo "${ECHO_T}$gfortran_use_symver" >&6
3274
3275
3276 if test "x$gfortran_use_symver" = xyes; then
3277   LIBGFOR_USE_SYMVER_TRUE=
3278   LIBGFOR_USE_SYMVER_FALSE='#'
3279 else
3280   LIBGFOR_USE_SYMVER_TRUE='#'
3281   LIBGFOR_USE_SYMVER_FALSE=
3282 fi
3283
3284
3285 # Find other programs we need.
3286 if test -n "$ac_tool_prefix"; then
3287   # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
3288 set dummy ${ac_tool_prefix}as; ac_word=$2
3289 echo "$as_me:$LINENO: checking for $ac_word" >&5
3290 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3291 if test "${ac_cv_prog_AS+set}" = set; then
3292   echo $ECHO_N "(cached) $ECHO_C" >&6
3293 else
3294   if test -n "$AS"; then
3295   ac_cv_prog_AS="$AS" # Let the user override the test.
3296 else
3297 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3298 for as_dir in $PATH
3299 do
3300   IFS=$as_save_IFS
3301   test -z "$as_dir" && as_dir=.
3302   for ac_exec_ext in '' $ac_executable_extensions; do
3303   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3304     ac_cv_prog_AS="${ac_tool_prefix}as"
3305     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3306     break 2
3307   fi
3308 done
3309 done
3310
3311 fi
3312 fi
3313 AS=$ac_cv_prog_AS
3314 if test -n "$AS"; then
3315   echo "$as_me:$LINENO: result: $AS" >&5
3316 echo "${ECHO_T}$AS" >&6
3317 else
3318   echo "$as_me:$LINENO: result: no" >&5
3319 echo "${ECHO_T}no" >&6
3320 fi
3321
3322 fi
3323 if test -z "$ac_cv_prog_AS"; then
3324   ac_ct_AS=$AS
3325   # Extract the first word of "as", so it can be a program name with args.
3326 set dummy as; ac_word=$2
3327 echo "$as_me:$LINENO: checking for $ac_word" >&5
3328 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3329 if test "${ac_cv_prog_ac_ct_AS+set}" = set; then
3330   echo $ECHO_N "(cached) $ECHO_C" >&6
3331 else
3332   if test -n "$ac_ct_AS"; then
3333   ac_cv_prog_ac_ct_AS="$ac_ct_AS" # Let the user override the test.
3334 else
3335 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3336 for as_dir in $PATH
3337 do
3338   IFS=$as_save_IFS
3339   test -z "$as_dir" && as_dir=.
3340   for ac_exec_ext in '' $ac_executable_extensions; do
3341   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3342     ac_cv_prog_ac_ct_AS="as"
3343     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3344     break 2
3345   fi
3346 done
3347 done
3348
3349 fi
3350 fi
3351 ac_ct_AS=$ac_cv_prog_ac_ct_AS
3352 if test -n "$ac_ct_AS"; then
3353   echo "$as_me:$LINENO: result: $ac_ct_AS" >&5
3354 echo "${ECHO_T}$ac_ct_AS" >&6
3355 else
3356   echo "$as_me:$LINENO: result: no" >&5
3357 echo "${ECHO_T}no" >&6
3358 fi
3359
3360   AS=$ac_ct_AS
3361 else
3362   AS="$ac_cv_prog_AS"
3363 fi
3364
3365 if test -n "$ac_tool_prefix"; then
3366   # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
3367 set dummy ${ac_tool_prefix}ar; ac_word=$2
3368 echo "$as_me:$LINENO: checking for $ac_word" >&5
3369 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3370 if test "${ac_cv_prog_AR+set}" = set; then
3371   echo $ECHO_N "(cached) $ECHO_C" >&6
3372 else
3373   if test -n "$AR"; then
3374   ac_cv_prog_AR="$AR" # Let the user override the test.
3375 else
3376 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3377 for as_dir in $PATH
3378 do
3379   IFS=$as_save_IFS
3380   test -z "$as_dir" && as_dir=.
3381   for ac_exec_ext in '' $ac_executable_extensions; do
3382   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3383     ac_cv_prog_AR="${ac_tool_prefix}ar"
3384     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3385     break 2
3386   fi
3387 done
3388 done
3389
3390 fi
3391 fi
3392 AR=$ac_cv_prog_AR
3393 if test -n "$AR"; then
3394   echo "$as_me:$LINENO: result: $AR" >&5
3395 echo "${ECHO_T}$AR" >&6
3396 else
3397   echo "$as_me:$LINENO: result: no" >&5
3398 echo "${ECHO_T}no" >&6
3399 fi
3400
3401 fi
3402 if test -z "$ac_cv_prog_AR"; then
3403   ac_ct_AR=$AR
3404   # Extract the first word of "ar", so it can be a program name with args.
3405 set dummy ar; ac_word=$2
3406 echo "$as_me:$LINENO: checking for $ac_word" >&5
3407 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3408 if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
3409   echo $ECHO_N "(cached) $ECHO_C" >&6
3410 else
3411   if test -n "$ac_ct_AR"; then
3412   ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
3413 else
3414 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3415 for as_dir in $PATH
3416 do
3417   IFS=$as_save_IFS
3418   test -z "$as_dir" && as_dir=.
3419   for ac_exec_ext in '' $ac_executable_extensions; do
3420   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3421     ac_cv_prog_ac_ct_AR="ar"
3422     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3423     break 2
3424   fi
3425 done
3426 done
3427
3428 fi
3429 fi
3430 ac_ct_AR=$ac_cv_prog_ac_ct_AR
3431 if test -n "$ac_ct_AR"; then
3432   echo "$as_me:$LINENO: result: $ac_ct_AR" >&5
3433 echo "${ECHO_T}$ac_ct_AR" >&6
3434 else
3435   echo "$as_me:$LINENO: result: no" >&5
3436 echo "${ECHO_T}no" >&6
3437 fi
3438
3439   AR=$ac_ct_AR
3440 else
3441   AR="$ac_cv_prog_AR"
3442 fi
3443
3444 if test -n "$ac_tool_prefix"; then
3445   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3446 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3447 echo "$as_me:$LINENO: checking for $ac_word" >&5
3448 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3449 if test "${ac_cv_prog_RANLIB+set}" = set; then
3450   echo $ECHO_N "(cached) $ECHO_C" >&6
3451 else
3452   if test -n "$RANLIB"; then
3453   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3454 else
3455 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3456 for as_dir in $PATH
3457 do
3458   IFS=$as_save_IFS
3459   test -z "$as_dir" && as_dir=.
3460   for ac_exec_ext in '' $ac_executable_extensions; do
3461   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3462     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3463     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3464     break 2
3465   fi
3466 done
3467 done
3468
3469 fi
3470 fi
3471 RANLIB=$ac_cv_prog_RANLIB
3472 if test -n "$RANLIB"; then
3473   echo "$as_me:$LINENO: result: $RANLIB" >&5
3474 echo "${ECHO_T}$RANLIB" >&6
3475 else
3476   echo "$as_me:$LINENO: result: no" >&5
3477 echo "${ECHO_T}no" >&6
3478 fi
3479
3480 fi
3481 if test -z "$ac_cv_prog_RANLIB"; then
3482   ac_ct_RANLIB=$RANLIB
3483   # Extract the first word of "ranlib", so it can be a program name with args.
3484 set dummy ranlib; ac_word=$2
3485 echo "$as_me:$LINENO: checking for $ac_word" >&5
3486 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3487 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3488   echo $ECHO_N "(cached) $ECHO_C" >&6
3489 else
3490   if test -n "$ac_ct_RANLIB"; then
3491   ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3492 else
3493 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3494 for as_dir in $PATH
3495 do
3496   IFS=$as_save_IFS
3497   test -z "$as_dir" && as_dir=.
3498   for ac_exec_ext in '' $ac_executable_extensions; do
3499   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3500     ac_cv_prog_ac_ct_RANLIB="ranlib"
3501     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3502     break 2
3503   fi
3504 done
3505 done
3506
3507   test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB="ranlib-not-found-in-path-error"
3508 fi
3509 fi
3510 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3511 if test -n "$ac_ct_RANLIB"; then
3512   echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3513 echo "${ECHO_T}$ac_ct_RANLIB" >&6
3514 else
3515   echo "$as_me:$LINENO: result: no" >&5
3516 echo "${ECHO_T}no" >&6
3517 fi
3518
3519   RANLIB=$ac_ct_RANLIB
3520 else
3521   RANLIB="$ac_cv_prog_RANLIB"
3522 fi
3523
3524 echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3525 echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3526 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3527 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3528   echo $ECHO_N "(cached) $ECHO_C" >&6
3529 else
3530   cat >conftest.make <<\_ACEOF
3531 all:
3532         @echo 'ac_maketemp="$(MAKE)"'
3533 _ACEOF
3534 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3535 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3536 if test -n "$ac_maketemp"; then
3537   eval ac_cv_prog_make_${ac_make}_set=yes
3538 else
3539   eval ac_cv_prog_make_${ac_make}_set=no
3540 fi
3541 rm -f conftest.make
3542 fi
3543 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3544   echo "$as_me:$LINENO: result: yes" >&5
3545 echo "${ECHO_T}yes" >&6
3546   SET_MAKE=
3547 else
3548   echo "$as_me:$LINENO: result: no" >&5
3549 echo "${ECHO_T}no" >&6
3550   SET_MAKE="MAKE=${MAKE-make}"
3551 fi
3552
3553 # Find a good install program.  We prefer a C program (faster),
3554 # so one script is as good as another.  But avoid the broken or
3555 # incompatible versions:
3556 # SysV /etc/install, /usr/sbin/install
3557 # SunOS /usr/etc/install
3558 # IRIX /sbin/install
3559 # AIX /bin/install
3560 # AmigaOS /C/install, which installs bootblocks on floppy discs
3561 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3562 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3563 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3564 # OS/2's system install, which has a completely different semantic
3565 # ./install, which can be erroneously created by make from ./install.sh.
3566 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3567 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3568 if test -z "$INSTALL"; then
3569 if test "${ac_cv_path_install+set}" = set; then
3570   echo $ECHO_N "(cached) $ECHO_C" >&6
3571 else
3572   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3573 for as_dir in $PATH
3574 do
3575   IFS=$as_save_IFS
3576   test -z "$as_dir" && as_dir=.
3577   # Account for people who put trailing slashes in PATH elements.
3578 case $as_dir/ in
3579   ./ | .// | /cC/* | \
3580   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3581   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3582   /usr/ucb/* ) ;;
3583   *)
3584     # OSF1 and SCO ODT 3.0 have their own names for install.
3585     # Don't use installbsd from OSF since it installs stuff as root
3586     # by default.
3587     for ac_prog in ginstall scoinst install; do
3588       for ac_exec_ext in '' $ac_executable_extensions; do
3589         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3590           if test $ac_prog = install &&
3591             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3592             # AIX install.  It has an incompatible calling convention.
3593             :
3594           elif test $ac_prog = install &&
3595             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3596             # program-specific install script used by HP pwplus--don't use.
3597             :
3598           else
3599             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3600             break 3
3601           fi
3602         fi
3603       done
3604     done
3605     ;;
3606 esac
3607 done
3608
3609
3610 fi
3611   if test "${ac_cv_path_install+set}" = set; then
3612     INSTALL=$ac_cv_path_install
3613   else
3614     # As a last resort, use the slow shell script.  We don't cache a
3615     # path for INSTALL within a source directory, because that will
3616     # break other packages using the cache if that directory is
3617     # removed, or if the path is relative.
3618     INSTALL=$ac_install_sh
3619   fi
3620 fi
3621 echo "$as_me:$LINENO: result: $INSTALL" >&5
3622 echo "${ECHO_T}$INSTALL" >&6
3623
3624 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3625 # It thinks the first close brace ends the variable substitution.
3626 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3627
3628 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3629
3630 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3631
3632
3633 # Configure libtool
3634 #AC_MSG_NOTICE([====== Starting libtool configuration])
3635
3636 # Check whether --enable-shared or --disable-shared was given.
3637 if test "${enable_shared+set}" = set; then
3638   enableval="$enable_shared"
3639   p=${PACKAGE-default}
3640 case $enableval in
3641 yes) enable_shared=yes ;;
3642 no) enable_shared=no ;;
3643 *)
3644   enable_shared=no
3645   # Look at the argument we got.  We use all the common list separators.
3646   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3647   for pkg in $enableval; do
3648     if test "X$pkg" = "X$p"; then
3649       enable_shared=yes
3650     fi
3651   done
3652   IFS="$ac_save_ifs"
3653   ;;
3654 esac
3655 else
3656   enable_shared=yes
3657 fi;
3658 # Check whether --enable-static or --disable-static was given.
3659 if test "${enable_static+set}" = set; then
3660   enableval="$enable_static"
3661   p=${PACKAGE-default}
3662 case $enableval in
3663 yes) enable_static=yes ;;
3664 no) enable_static=no ;;
3665 *)
3666   enable_static=no
3667   # Look at the argument we got.  We use all the common list separators.
3668   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3669   for pkg in $enableval; do
3670     if test "X$pkg" = "X$p"; then
3671       enable_static=yes
3672     fi
3673   done
3674   IFS="$ac_save_ifs"
3675   ;;
3676 esac
3677 else
3678   enable_static=yes
3679 fi;
3680 # Check whether --enable-fast-install or --disable-fast-install was given.
3681 if test "${enable_fast_install+set}" = set; then
3682   enableval="$enable_fast_install"
3683   p=${PACKAGE-default}
3684 case $enableval in
3685 yes) enable_fast_install=yes ;;
3686 no) enable_fast_install=no ;;
3687 *)
3688   enable_fast_install=no
3689   # Look at the argument we got.  We use all the common list separators.
3690   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3691   for pkg in $enableval; do
3692     if test "X$pkg" = "X$p"; then
3693       enable_fast_install=yes
3694     fi
3695   done
3696   IFS="$ac_save_ifs"
3697   ;;
3698 esac
3699 else
3700   enable_fast_install=yes
3701 fi;
3702
3703 # Check whether --with-gnu-ld or --without-gnu-ld was given.
3704 if test "${with_gnu_ld+set}" = set; then
3705   withval="$with_gnu_ld"
3706   test "$withval" = no || with_gnu_ld=yes
3707 else
3708   with_gnu_ld=no
3709 fi;
3710 ac_prog=ld
3711 if test "$GCC" = yes; then
3712   # Check if gcc -print-prog-name=ld gives a path.
3713   echo "$as_me:$LINENO: checking for ld used by GCC" >&5
3714 echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6
3715   case $host in
3716   *-*-mingw*)
3717     # gcc leaves a trailing carriage return which upsets mingw
3718     ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
3719   *)
3720     ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
3721   esac
3722   case $ac_prog in
3723     # Accept absolute paths.
3724     [\\/]* | [A-Za-z]:[\\/]*)
3725       re_direlt='/[^/][^/]*/\.\./'
3726       # Canonicalize the path of ld
3727       ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
3728       while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
3729         ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
3730       done
3731       test -z "$LD" && LD="$ac_prog"
3732       ;;
3733   "")
3734     # If it fails, then pretend we aren't using GCC.
3735     ac_prog=ld
3736     ;;
3737   *)
3738     # If it is relative, then search for the first ld in PATH.
3739     with_gnu_ld=unknown
3740     ;;
3741   esac
3742 elif test "$with_gnu_ld" = yes; then
3743   echo "$as_me:$LINENO: checking for GNU ld" >&5
3744 echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6
3745 else
3746   echo "$as_me:$LINENO: checking for non-GNU ld" >&5
3747 echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6
3748 fi
3749 if test "${lt_cv_path_LD+set}" = set; then
3750   echo $ECHO_N "(cached) $ECHO_C" >&6
3751 else
3752   if test -z "$LD"; then
3753   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
3754   for ac_dir in $PATH; do
3755     test -z "$ac_dir" && ac_dir=.
3756     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
3757       lt_cv_path_LD="$ac_dir/$ac_prog"
3758       # Check to see if the program is GNU ld.  I'd rather use --version,
3759       # but apparently some GNU ld's only accept -v.
3760       # Break only if it was the GNU/non-GNU ld that we prefer.
3761       if "$lt_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
3762         test "$with_gnu_ld" != no && break
3763       else
3764         test "$with_gnu_ld" != yes && break
3765       fi
3766     fi
3767   done
3768   IFS="$ac_save_ifs"
3769 else
3770   lt_cv_path_LD="$LD" # Let the user override the test with a path.
3771 fi
3772 fi
3773
3774 LD="$lt_cv_path_LD"
3775 if test -n "$LD"; then
3776   echo "$as_me:$LINENO: result: $LD" >&5
3777 echo "${ECHO_T}$LD" >&6
3778 else
3779   echo "$as_me:$LINENO: result: no" >&5
3780 echo "${ECHO_T}no" >&6
3781 fi
3782 test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5
3783 echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}
3784    { (exit 1); exit 1; }; }
3785 echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
3786 echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6
3787 if test "${lt_cv_prog_gnu_ld+set}" = set; then
3788   echo $ECHO_N "(cached) $ECHO_C" >&6
3789 else
3790   # I'd rather use --version here, but apparently some GNU ld's only accept -v.
3791 if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
3792   lt_cv_prog_gnu_ld=yes
3793 else
3794   lt_cv_prog_gnu_ld=no
3795 fi
3796 fi
3797 echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
3798 echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6
3799 with_gnu_ld=$lt_cv_prog_gnu_ld
3800
3801
3802 echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
3803 echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6
3804 if test "${lt_cv_ld_reload_flag+set}" = set; then
3805   echo $ECHO_N "(cached) $ECHO_C" >&6
3806 else
3807   lt_cv_ld_reload_flag='-r'
3808 fi
3809 echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
3810 echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6
3811 reload_flag=$lt_cv_ld_reload_flag
3812 test -n "$reload_flag" && reload_flag=" $reload_flag"
3813
3814 echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
3815 echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6
3816 if test "${lt_cv_path_NM+set}" = set; then
3817   echo $ECHO_N "(cached) $ECHO_C" >&6
3818 else
3819   if test -n "$NM"; then
3820   # Let the user override the test.
3821   lt_cv_path_NM="$NM"
3822 else
3823   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
3824   for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
3825     test -z "$ac_dir" && ac_dir=.
3826     tmp_nm=$ac_dir/${ac_tool_prefix}nm
3827     if test -f $tmp_nm || test -f $tmp_nm$ac_exeext ; then
3828       # Check to see if the nm accepts a BSD-compat flag.
3829       # Adding the `sed 1q' prevents false positives on HP-UX, which says:
3830       #   nm: unknown option "B" ignored
3831       # Tru64's nm complains that /dev/null is an invalid object file
3832       if ($tmp_nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep '(/dev/null|Invalid file or object type)' >/dev/null; then
3833         lt_cv_path_NM="$tmp_nm -B"
3834         break
3835       elif ($tmp_nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
3836         lt_cv_path_NM="$tmp_nm -p"
3837         break
3838       else
3839         lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
3840         continue # so that we can try to find one that supports BSD flags
3841       fi
3842     fi
3843   done
3844   IFS="$ac_save_ifs"
3845   test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm
3846 fi
3847 fi
3848
3849 NM="$lt_cv_path_NM"
3850 echo "$as_me:$LINENO: result: $NM" >&5
3851 echo "${ECHO_T}$NM" >&6
3852
3853 echo "$as_me:$LINENO: checking whether ln -s works" >&5
3854 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3855 LN_S=$as_ln_s
3856 if test "$LN_S" = "ln -s"; then
3857   echo "$as_me:$LINENO: result: yes" >&5
3858 echo "${ECHO_T}yes" >&6
3859 else
3860   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3861 echo "${ECHO_T}no, using $LN_S" >&6
3862 fi
3863
3864 echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5
3865 echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6
3866 if test "${lt_cv_deplibs_check_method+set}" = set; then
3867   echo $ECHO_N "(cached) $ECHO_C" >&6
3868 else
3869   lt_cv_file_magic_cmd='$MAGIC_CMD'
3870 lt_cv_file_magic_test_file=
3871 lt_cv_deplibs_check_method='unknown'
3872 # Need to set the preceding variable on all platforms that support
3873 # interlibrary dependencies.
3874 # 'none' -- dependencies not supported.
3875 # `unknown' -- same as none, but documents that we really don't know.
3876 # 'pass_all' -- all dependencies passed with no checks.
3877 # 'test_compile' -- check by making test program.
3878 # 'file_magic [regex]' -- check by looking for files in library path
3879 # which responds to the $file_magic_cmd with a given egrep regex.
3880 # If you have `file' or equivalent on your system and you're not sure
3881 # whether `pass_all' will *always* work, you probably want this one.
3882
3883 case $host_os in
3884 aix*)
3885   lt_cv_deplibs_check_method=pass_all
3886   ;;
3887
3888 beos*)
3889   lt_cv_deplibs_check_method=pass_all
3890   ;;
3891
3892 bsdi4*)
3893   lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
3894   lt_cv_file_magic_cmd='/usr/bin/file -L'
3895   lt_cv_file_magic_test_file=/shlib/libc.so
3896   ;;
3897
3898 cygwin* | mingw* |pw32*)
3899   lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
3900   lt_cv_file_magic_cmd='$OBJDUMP -f'
3901   ;;
3902
3903 darwin* | rhapsody*)
3904   # this will be overwritten by pass_all, but leave it in just in case
3905   lt_cv_deplibs_check_method='file_magic Mach-O dynamically linked shared library'
3906   lt_cv_file_magic_cmd='/usr/bin/file -L'
3907   case "$host_os" in
3908   rhapsody* | darwin1.012)
3909     lt_cv_file_magic_test_file='/System/Library/Frameworks/System.framework/System'
3910     ;;
3911   *) # Darwin 1.3 on
3912     lt_cv_file_magic_test_file='/usr/lib/libSystem.dylib'
3913     ;;
3914   esac
3915   lt_cv_deplibs_check_method=pass_all
3916   ;;
3917
3918 freebsd* | kfreebsd*-gnu)
3919   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
3920     case $host_cpu in
3921     i*86 )
3922       # Not sure whether the presence of OpenBSD here was a mistake.
3923       # Let's accept both of them until this is cleared up.
3924       lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[3-9]86 (compact )?demand paged shared library'
3925       lt_cv_file_magic_cmd=/usr/bin/file
3926       lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
3927       ;;
3928     esac
3929   else
3930     lt_cv_deplibs_check_method=pass_all
3931   fi
3932   ;;
3933
3934 gnu*)
3935   lt_cv_deplibs_check_method=pass_all
3936   ;;
3937
3938 hpux10.20*|hpux11*)
3939   case $host_cpu in
3940   hppa*)
3941     lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library'
3942     lt_cv_file_magic_cmd=/usr/bin/file
3943     lt_cv_file_magic_test_file=/usr/lib/libc.sl
3944     ;;
3945   ia64*)
3946     lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
3947     lt_cv_file_magic_cmd=/usr/bin/file
3948     lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
3949     ;;
3950   esac
3951   ;;
3952
3953 irix5* | irix6*)
3954   case $host_os in
3955   irix5*)
3956     # this will be overridden with pass_all, but let us keep it just in case
3957     lt_cv_deplibs_check_method="file_magic ELF 32-bit MSB dynamic lib MIPS - version 1"
3958     ;;
3959   *)
3960     case $LD in
3961     *-32|*"-32 ") libmagic=32-bit;;
3962     *-n32|*"-n32 ") libmagic=N32;;
3963     *-64|*"-64 ") libmagic=64-bit;;
3964     *) libmagic=never-match;;
3965     esac
3966     # this will be overridden with pass_all, but let us keep it just in case
3967     lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[1234] dynamic lib MIPS - version 1"
3968     ;;
3969   esac
3970   lt_cv_file_magic_test_file=`echo /lib${libsuff}/libc.so*`
3971   lt_cv_deplibs_check_method=pass_all
3972   ;;
3973
3974 # This must be Linux ELF.
3975 linux-gnu*)
3976   lt_cv_deplibs_check_method=pass_all
3977   ;;
3978
3979 netbsd* | knetbsd*-gnu)
3980   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
3981     lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so\.[0-9]+\.[0-9]+$'
3982   else
3983     lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so$'
3984   fi
3985   ;;
3986
3987 newsos6)
3988   lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'
3989   lt_cv_file_magic_cmd=/usr/bin/file
3990   lt_cv_file_magic_test_file=/usr/lib/libnls.so
3991   ;;
3992
3993 osf3* | osf4* | osf5*)
3994   # this will be overridden with pass_all, but let us keep it just in case
3995   lt_cv_deplibs_check_method='file_magic COFF format alpha shared library'
3996   lt_cv_file_magic_test_file=/shlib/libc.so
3997   lt_cv_deplibs_check_method=pass_all
3998   ;;
3999
4000 sco3.2v5*)
4001   lt_cv_deplibs_check_method=pass_all
4002   ;;
4003
4004 solaris*)
4005   lt_cv_deplibs_check_method=pass_all
4006   lt_cv_file_magic_test_file=/lib/libc.so
4007   ;;
4008
4009 sysv5uw[78]* | sysv4*uw2*)
4010   lt_cv_deplibs_check_method=pass_all
4011   ;;
4012
4013 sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
4014   case $host_vendor in
4015   ncr)
4016     lt_cv_deplibs_check_method=pass_all
4017     ;;
4018   motorola)
4019     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]'
4020     lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
4021     ;;
4022   esac
4023   ;;
4024 esac
4025
4026 fi
4027 echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
4028 echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6
4029 file_magic_cmd=$lt_cv_file_magic_cmd
4030 deplibs_check_method=$lt_cv_deplibs_check_method
4031
4032
4033
4034
4035 # Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
4036
4037 # find the maximum length of command line arguments
4038 echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
4039 echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6
4040 if test "${lt_cv_sys_max_cmd_len+set}" = set; then
4041   echo $ECHO_N "(cached) $ECHO_C" >&6
4042 else
4043     i=0
4044   teststring="ABCD"
4045
4046   case $build_os in
4047   msdosdjgpp*)
4048     # On DJGPP, this test can blow up pretty badly due to problems in libc
4049     # (any single argument exceeding 2000 bytes causes a buffer overrun
4050     # during glob expansion).  Even if it were fixed, the result of this
4051     # check would be larger than it should be.
4052     lt_cv_sys_max_cmd_len=12288;    # 12K is about right
4053     ;;
4054
4055   cygwin* | mingw*)
4056     # On Win9x/ME, this test blows up -- it succeeds, but takes
4057     # about 5 minutes as the teststring grows exponentially.
4058     # Worse, since 9x/ME are not pre-emptively multitasking,
4059     # you end up with a "frozen" computer, even though with patience
4060     # the test eventually succeeds (with a max line length of 256k).
4061     # Instead, let's just punt: use the minimum linelength reported by
4062     # all of the supported platforms: 8192 (on NT/2K/XP).
4063     lt_cv_sys_max_cmd_len=8192;
4064     ;;
4065
4066   amigaos*)
4067     # On AmigaOS with pdksh, this test takes hours, literally.
4068     # So we just punt and use a minimum line length of 8192.
4069     lt_cv_sys_max_cmd_len=8192;
4070     ;;
4071
4072   netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
4073     # This has been around since 386BSD, at least.  Likely further.
4074     if test -x /sbin/sysctl; then
4075       lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
4076     elif test -x /usr/sbin/sysctl; then
4077       lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
4078     else
4079       lt_cv_sys_max_cmd_len=65536 # usable default for *BSD
4080     fi
4081     # And add a safety zone
4082     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
4083     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
4084     ;;
4085   esac
4086
4087 fi
4088
4089 if test -n "$lt_cv_sys_max_cmd_len" ; then
4090   echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
4091 echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6
4092 else
4093   echo "$as_me:$LINENO: result: none" >&5
4094 echo "${ECHO_T}none" >&6
4095 fi
4096
4097
4098 # Only perform the check for file, if the check method requires it
4099 case $deplibs_check_method in
4100 file_magic*)
4101   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
4102     echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
4103 echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6
4104 if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
4105   echo $ECHO_N "(cached) $ECHO_C" >&6
4106 else
4107   case $MAGIC_CMD in
4108   /*)
4109   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
4110   ;;
4111   ?:/*)
4112   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
4113   ;;
4114   *)
4115   ac_save_MAGIC_CMD="$MAGIC_CMD"
4116   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4117   ac_dummy="/usr/bin:$PATH"
4118   for ac_dir in $ac_dummy; do
4119     test -z "$ac_dir" && ac_dir=.
4120     if test -f $ac_dir/${ac_tool_prefix}file; then
4121       lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
4122       if test -n "$file_magic_test_file"; then
4123         case $deplibs_check_method in
4124         "file_magic "*)
4125           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
4126           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
4127           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
4128             egrep "$file_magic_regex" > /dev/null; then
4129             :
4130           else
4131             cat <<EOF 1>&2
4132
4133 *** Warning: the command libtool uses to detect shared libraries,
4134 *** $file_magic_cmd, produces output that libtool cannot recognize.
4135 *** The result is that libtool may fail to recognize shared libraries
4136 *** as such.  This will affect the creation of libtool libraries that
4137 *** depend on shared libraries, but programs linked with such libtool
4138 *** libraries will work regardless of this problem.  Nevertheless, you
4139 *** may want to report the problem to your system manager and/or to
4140 *** bug-libtool@gnu.org
4141
4142 EOF
4143           fi ;;
4144         esac
4145       fi
4146       break
4147     fi
4148   done
4149   IFS="$ac_save_ifs"
4150   MAGIC_CMD="$ac_save_MAGIC_CMD"
4151   ;;
4152 esac
4153 fi
4154
4155 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
4156 if test -n "$MAGIC_CMD"; then
4157   echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
4158 echo "${ECHO_T}$MAGIC_CMD" >&6
4159 else
4160   echo "$as_me:$LINENO: result: no" >&5
4161 echo "${ECHO_T}no" >&6
4162 fi
4163
4164 if test -z "$lt_cv_path_MAGIC_CMD"; then
4165   if test -n "$ac_tool_prefix"; then
4166     echo "$as_me:$LINENO: checking for file" >&5
4167 echo $ECHO_N "checking for file... $ECHO_C" >&6
4168 if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
4169   echo $ECHO_N "(cached) $ECHO_C" >&6
4170 else
4171   case $MAGIC_CMD in
4172   /*)
4173   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
4174   ;;
4175   ?:/*)
4176   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
4177   ;;
4178   *)
4179   ac_save_MAGIC_CMD="$MAGIC_CMD"
4180   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4181   ac_dummy="/usr/bin:$PATH"
4182   for ac_dir in $ac_dummy; do
4183     test -z "$ac_dir" && ac_dir=.
4184     if test -f $ac_dir/file; then
4185       lt_cv_path_MAGIC_CMD="$ac_dir/file"
4186       if test -n "$file_magic_test_file"; then
4187         case $deplibs_check_method in
4188         "file_magic "*)
4189           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
4190           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
4191           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
4192             egrep "$file_magic_regex" > /dev/null; then
4193             :
4194           else
4195             cat <<EOF 1>&2
4196
4197 *** Warning: the command libtool uses to detect shared libraries,
4198 *** $file_magic_cmd, produces output that libtool cannot recognize.
4199 *** The result is that libtool may fail to recognize shared libraries
4200 *** as such.  This will affect the creation of libtool libraries that
4201 *** depend on shared libraries, but programs linked with such libtool
4202 *** libraries will work regardless of this problem.  Nevertheless, you
4203 *** may want to report the problem to your system manager and/or to
4204 *** bug-libtool@gnu.org
4205
4206 EOF
4207           fi ;;
4208         esac
4209       fi
4210       break
4211     fi
4212   done
4213   IFS="$ac_save_ifs"
4214   MAGIC_CMD="$ac_save_MAGIC_CMD"
4215   ;;
4216 esac
4217 fi
4218
4219 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
4220 if test -n "$MAGIC_CMD"; then
4221   echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
4222 echo "${ECHO_T}$MAGIC_CMD" >&6
4223 else
4224   echo "$as_me:$LINENO: result: no" >&5
4225 echo "${ECHO_T}no" >&6
4226 fi
4227
4228   else
4229     MAGIC_CMD=:
4230   fi
4231 fi
4232
4233   fi
4234   ;;
4235 esac
4236
4237 if test -n "$ac_tool_prefix"; then
4238   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
4239 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
4240 echo "$as_me:$LINENO: checking for $ac_word" >&5
4241 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4242 if test "${ac_cv_prog_RANLIB+set}" = set; then
4243   echo $ECHO_N "(cached) $ECHO_C" >&6
4244 else
4245   if test -n "$RANLIB"; then
4246   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
4247 else
4248 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4249 for as_dir in $PATH
4250 do
4251   IFS=$as_save_IFS
4252   test -z "$as_dir" && as_dir=.
4253   for ac_exec_ext in '' $ac_executable_extensions; do
4254   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4255     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
4256     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4257     break 2
4258   fi
4259 done
4260 done
4261
4262 fi
4263 fi
4264 RANLIB=$ac_cv_prog_RANLIB
4265 if test -n "$RANLIB"; then
4266   echo "$as_me:$LINENO: result: $RANLIB" >&5
4267 echo "${ECHO_T}$RANLIB" >&6
4268 else
4269   echo "$as_me:$LINENO: result: no" >&5
4270 echo "${ECHO_T}no" >&6
4271 fi
4272
4273 fi
4274 if test -z "$ac_cv_prog_RANLIB"; then
4275   ac_ct_RANLIB=$RANLIB
4276   # Extract the first word of "ranlib", so it can be a program name with args.
4277 set dummy ranlib; ac_word=$2
4278 echo "$as_me:$LINENO: checking for $ac_word" >&5
4279 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4280 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
4281   echo $ECHO_N "(cached) $ECHO_C" >&6
4282 else
4283   if test -n "$ac_ct_RANLIB"; then
4284   ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
4285 else
4286 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4287 for as_dir in $PATH
4288 do
4289   IFS=$as_save_IFS
4290   test -z "$as_dir" && as_dir=.
4291   for ac_exec_ext in '' $ac_executable_extensions; do
4292   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4293     ac_cv_prog_ac_ct_RANLIB="ranlib"
4294     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4295     break 2
4296   fi
4297 done
4298 done
4299
4300   test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
4301 fi
4302 fi
4303 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
4304 if test -n "$ac_ct_RANLIB"; then
4305   echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
4306 echo "${ECHO_T}$ac_ct_RANLIB" >&6
4307 else
4308   echo "$as_me:$LINENO: result: no" >&5
4309 echo "${ECHO_T}no" >&6
4310 fi
4311
4312   RANLIB=$ac_ct_RANLIB
4313 else
4314   RANLIB="$ac_cv_prog_RANLIB"
4315 fi
4316
4317 if test -n "$ac_tool_prefix"; then
4318   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
4319 set dummy ${ac_tool_prefix}strip; ac_word=$2
4320 echo "$as_me:$LINENO: checking for $ac_word" >&5
4321 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4322 if test "${ac_cv_prog_STRIP+set}" = set; then
4323   echo $ECHO_N "(cached) $ECHO_C" >&6
4324 else
4325   if test -n "$STRIP"; then
4326   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
4327 else
4328 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4329 for as_dir in $PATH
4330 do
4331   IFS=$as_save_IFS
4332   test -z "$as_dir" && as_dir=.
4333   for ac_exec_ext in '' $ac_executable_extensions; do
4334   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4335     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
4336     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4337     break 2
4338   fi
4339 done
4340 done
4341
4342 fi
4343 fi
4344 STRIP=$ac_cv_prog_STRIP
4345 if test -n "$STRIP"; then
4346   echo "$as_me:$LINENO: result: $STRIP" >&5
4347 echo "${ECHO_T}$STRIP" >&6
4348 else
4349   echo "$as_me:$LINENO: result: no" >&5
4350 echo "${ECHO_T}no" >&6
4351 fi
4352
4353 fi
4354 if test -z "$ac_cv_prog_STRIP"; then
4355   ac_ct_STRIP=$STRIP
4356   # Extract the first word of "strip", so it can be a program name with args.
4357 set dummy strip; ac_word=$2
4358 echo "$as_me:$LINENO: checking for $ac_word" >&5
4359 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4360 if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
4361   echo $ECHO_N "(cached) $ECHO_C" >&6
4362 else
4363   if test -n "$ac_ct_STRIP"; then
4364   ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
4365 else
4366 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4367 for as_dir in $PATH
4368 do
4369   IFS=$as_save_IFS
4370   test -z "$as_dir" && as_dir=.
4371   for ac_exec_ext in '' $ac_executable_extensions; do
4372   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4373     ac_cv_prog_ac_ct_STRIP="strip"
4374     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4375     break 2
4376   fi
4377 done
4378 done
4379
4380   test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
4381 fi
4382 fi
4383 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
4384 if test -n "$ac_ct_STRIP"; then
4385   echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
4386 echo "${ECHO_T}$ac_ct_STRIP" >&6
4387 else
4388   echo "$as_me:$LINENO: result: no" >&5
4389 echo "${ECHO_T}no" >&6
4390 fi
4391
4392   STRIP=$ac_ct_STRIP
4393 else
4394   STRIP="$ac_cv_prog_STRIP"
4395 fi
4396
4397
4398 # Check for any special flags to pass to ltconfig.
4399 libtool_flags="--cache-file=$cache_file"
4400 test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
4401 test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
4402 test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
4403 test "$GCC" = yes && libtool_flags="$libtool_flags --with-gcc"
4404 test "$lt_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
4405
4406
4407 # Check whether --enable-libtool-lock or --disable-libtool-lock was given.
4408 if test "${enable_libtool_lock+set}" = set; then
4409   enableval="$enable_libtool_lock"
4410
4411 fi;
4412 test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
4413 test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
4414
4415
4416 # Check whether --with-pic or --without-pic was given.
4417 if test "${with_pic+set}" = set; then
4418   withval="$with_pic"
4419   pic_mode="$withval"
4420 else
4421   pic_mode=default
4422 fi;
4423 test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic"
4424 test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
4425
4426 # Some flags need to be propagated to the compiler or linker for good
4427 # libtool support.
4428 case $host in
4429 *-*-irix6*)
4430   # Find out which ABI we are using.
4431   echo '#line 4431 "configure"' > conftest.$ac_ext
4432   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4433   (eval $ac_compile) 2>&5
4434   ac_status=$?
4435   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4436   (exit $ac_status); }; then
4437    if test "$lt_cv_prog_gnu_ld" = yes; then
4438     case `/usr/bin/file conftest.$ac_objext` in
4439     *32-bit*)
4440       LD="${LD-ld} -melf32bsmip"
4441       ;;
4442     *N32*)
4443       LD="${LD-ld} -melf32bmipn32"
4444       ;;
4445     *64-bit*)
4446       LD="${LD-ld} -melf64bmip"
4447       ;;
4448     esac
4449    else
4450     case `/usr/bin/file conftest.$ac_objext` in
4451     *32-bit*)
4452       LD="${LD-ld} -32"
4453       ;;
4454     *N32*)
4455       LD="${LD-ld} -n32"
4456       ;;
4457     *64-bit*)
4458       LD="${LD-ld} -64"
4459       ;;
4460     esac
4461    fi
4462   fi
4463   rm -rf conftest*
4464   ;;
4465
4466 ia64-*-hpux*)
4467   # Find out which ABI we are using.
4468   echo 'int i;' > conftest.$ac_ext
4469   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4470   (eval $ac_compile) 2>&5
4471   ac_status=$?
4472   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4473   (exit $ac_status); }; then
4474     case "`/usr/bin/file conftest.o`" in
4475     *ELF-32*)
4476       HPUX_IA64_MODE="32"
4477       ;;
4478     *ELF-64*)
4479       HPUX_IA64_MODE="64"
4480       ;;
4481     esac
4482   fi
4483   rm -rf conftest*
4484   ;;
4485
4486 x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*)
4487   # Find out which ABI we are using.
4488   echo 'int i;' > conftest.$ac_ext
4489   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4490   (eval $ac_compile) 2>&5
4491   ac_status=$?
4492   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4493   (exit $ac_status); }; then
4494     case "`/usr/bin/file conftest.o`" in
4495     *32-bit*)
4496       case $host in
4497         x86_64-*linux*)
4498           LD="${LD-ld} -m elf_i386"
4499           ;;
4500         ppc64-*linux*|powerpc64-*linux*)
4501           LD="${LD-ld} -m elf32ppclinux"
4502           ;;
4503         s390x-*linux*)
4504           LD="${LD-ld} -m elf_s390"
4505           ;;
4506         sparc64-*linux*)
4507           LD="${LD-ld} -m elf32_sparc"
4508           ;;
4509       esac
4510       ;;
4511     *64-bit*)
4512       case $host in
4513         x86_64-*linux*)
4514           LD="${LD-ld} -m elf_x86_64"
4515           ;;
4516         ppc*-*linux*|powerpc*-*linux*)
4517           LD="${LD-ld} -m elf64ppc"
4518           ;;
4519         s390*-*linux*)
4520           LD="${LD-ld} -m elf64_s390"
4521           ;;
4522         sparc*-*linux*)
4523           LD="${LD-ld} -m elf64_sparc"
4524           ;;
4525       esac
4526       ;;
4527     esac
4528   fi
4529   rm -rf conftest*
4530   ;;
4531
4532 *-*-sco3.2v5*)
4533   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
4534   SAVE_CFLAGS="$CFLAGS"
4535   CFLAGS="$CFLAGS -belf"
4536   echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
4537 echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6
4538 if test "${lt_cv_cc_needs_belf+set}" = set; then
4539   echo $ECHO_N "(cached) $ECHO_C" >&6
4540 else
4541
4542
4543      ac_ext=c
4544 ac_cpp='$CPP $CPPFLAGS'
4545 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4546 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4547 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4548
4549      if test x$gcc_no_link = xyes; then
4550   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
4551 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
4552    { (exit 1); exit 1; }; }
4553 fi
4554 cat >conftest.$ac_ext <<_ACEOF
4555 /* confdefs.h.  */
4556 _ACEOF
4557 cat confdefs.h >>conftest.$ac_ext
4558 cat >>conftest.$ac_ext <<_ACEOF
4559 /* end confdefs.h.  */
4560
4561 int
4562 main ()
4563 {
4564
4565   ;
4566   return 0;
4567 }
4568 _ACEOF
4569 rm -f conftest.$ac_objext conftest$ac_exeext
4570 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4571   (eval $ac_link) 2>conftest.er1
4572   ac_status=$?
4573   grep -v '^ *+' conftest.er1 >conftest.err
4574   rm -f conftest.er1
4575   cat conftest.err >&5
4576   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4577   (exit $ac_status); } &&
4578          { ac_try='test -z "$ac_c_werror_flag"
4579                          || test ! -s conftest.err'
4580   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4581   (eval $ac_try) 2>&5
4582   ac_status=$?
4583   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4584   (exit $ac_status); }; } &&
4585          { ac_try='test -s conftest$ac_exeext'
4586   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4587   (eval $ac_try) 2>&5
4588   ac_status=$?
4589   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4590   (exit $ac_status); }; }; then
4591   lt_cv_cc_needs_belf=yes
4592 else
4593   echo "$as_me: failed program was:" >&5
4594 sed 's/^/| /' conftest.$ac_ext >&5
4595
4596 lt_cv_cc_needs_belf=no
4597 fi
4598 rm -f conftest.err conftest.$ac_objext \
4599       conftest$ac_exeext conftest.$ac_ext
4600      ac_ext=c
4601 ac_cpp='$CPP $CPPFLAGS'
4602 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4603 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4604 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4605
4606 fi
4607 echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
4608 echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6
4609   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
4610     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
4611     CFLAGS="$SAVE_CFLAGS"
4612   fi
4613   ;;
4614
4615
4616 esac
4617
4618
4619 # Save cache, so that ltconfig can load it
4620 cat >confcache <<\_ACEOF
4621 # This file is a shell script that caches the results of configure
4622 # tests run on this system so they can be shared between configure
4623 # scripts and configure runs, see configure's option --config-cache.
4624 # It is not useful on other systems.  If it contains results you don't
4625 # want to keep, you may remove or edit it.
4626 #
4627 # config.status only pays attention to the cache file if you give it
4628 # the --recheck option to rerun configure.
4629 #
4630 # `ac_cv_env_foo' variables (set or unset) will be overridden when
4631 # loading this file, other *unset* `ac_cv_foo' will be assigned the
4632 # following values.
4633
4634 _ACEOF
4635
4636 # The following way of writing the cache mishandles newlines in values,
4637 # but we know of no workaround that is simple, portable, and efficient.
4638 # So, don't put newlines in cache variables' values.
4639 # Ultrix sh set writes to stderr and can't be redirected directly,
4640 # and sets the high bit in the cache file unless we assign to the vars.
4641 {
4642   (set) 2>&1 |
4643     case `(ac_space=' '; set | grep ac_space) 2>&1` in
4644     *ac_space=\ *)
4645       # `set' does not quote correctly, so add quotes (double-quote
4646       # substitution turns \\\\ into \\, and sed turns \\ into \).
4647       sed -n \
4648         "s/'/'\\\\''/g;
4649           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
4650       ;;
4651     *)
4652       # `set' quotes correctly as required by POSIX, so do not add quotes.
4653       sed -n \
4654         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
4655       ;;
4656     esac;
4657 } |
4658   sed '
4659      t clear
4660      : clear
4661      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
4662      t end
4663      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
4664      : end' >>confcache
4665 if diff $cache_file confcache >/dev/null 2>&1; then :; else
4666   if test -w $cache_file; then
4667     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
4668     cat confcache >$cache_file
4669   else
4670     echo "not updating unwritable cache $cache_file"
4671   fi
4672 fi
4673 rm -f confcache
4674
4675 # Actually configure libtool.  ac_aux_dir is where install-sh is found.
4676 AR="$AR" LTCC="$CC" CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
4677 MAGIC_CMD="$MAGIC_CMD" LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
4678 LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \
4679 AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \
4680 objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \
4681 deplibs_check_method="$deplibs_check_method" file_magic_cmd="$file_magic_cmd" \
4682 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
4683 $libtool_flags --no-verify --build="$build" $ac_aux_dir/ltmain.sh $host \
4684 || { { echo "$as_me:$LINENO: error: libtool configure failed" >&5
4685 echo "$as_me: error: libtool configure failed" >&2;}
4686    { (exit 1); exit 1; }; }
4687
4688 # Reload cache, that may have been modified by ltconfig
4689 if test -r "$cache_file"; then
4690   # Some versions of bash will fail to source /dev/null (special
4691   # files actually), so we avoid doing that.
4692   if test -f "$cache_file"; then
4693     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
4694 echo "$as_me: loading cache $cache_file" >&6;}
4695     case $cache_file in
4696       [\\/]* | ?:[\\/]* ) . $cache_file;;
4697       *)                      . ./$cache_file;;
4698     esac
4699   fi
4700 else
4701   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
4702 echo "$as_me: creating cache $cache_file" >&6;}
4703   >$cache_file
4704 fi
4705
4706
4707 # This can be used to rebuild libtool when needed
4708 LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh $ac_aux_dir/ltcf-c.sh"
4709
4710 # Always use our own libtool.
4711 LIBTOOL='$(SHELL) $(top_builddir)/libtool'
4712
4713 # Redirect the config.log output again, so that the ltconfig log is not
4714 # clobbered by the next message.
4715 exec 5>>./config.log
4716
4717
4718
4719
4720
4721
4722
4723
4724 #AC_MSG_NOTICE([====== Finished libtool configuration]) ; sleep 10
4725
4726 # We need gfortran to compile parts of the library
4727 #AC_PROG_FC(gfortran)
4728 FC="$GFORTRAN"
4729 ac_ext=${FC_SRCEXT-f}
4730 ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4731 ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4732 ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4733 if test -n "$ac_tool_prefix"; then
4734   for ac_prog in gfortran
4735   do
4736     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4737 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4738 echo "$as_me:$LINENO: checking for $ac_word" >&5
4739 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4740 if test "${ac_cv_prog_FC+set}" = set; then
4741   echo $ECHO_N "(cached) $ECHO_C" >&6
4742 else
4743   if test -n "$FC"; then
4744   ac_cv_prog_FC="$FC" # Let the user override the test.
4745 else
4746 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4747 for as_dir in $PATH
4748 do
4749   IFS=$as_save_IFS
4750   test -z "$as_dir" && as_dir=.
4751   for ac_exec_ext in '' $ac_executable_extensions; do
4752   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4753     ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
4754     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4755     break 2
4756   fi
4757 done
4758 done
4759
4760 fi
4761 fi
4762 FC=$ac_cv_prog_FC
4763 if test -n "$FC"; then
4764   echo "$as_me:$LINENO: result: $FC" >&5
4765 echo "${ECHO_T}$FC" >&6
4766 else
4767   echo "$as_me:$LINENO: result: no" >&5
4768 echo "${ECHO_T}no" >&6
4769 fi
4770
4771     test -n "$FC" && break
4772   done
4773 fi
4774 if test -z "$FC"; then
4775   ac_ct_FC=$FC
4776   for ac_prog in gfortran
4777 do
4778   # Extract the first word of "$ac_prog", so it can be a program name with args.
4779 set dummy $ac_prog; ac_word=$2
4780 echo "$as_me:$LINENO: checking for $ac_word" >&5
4781 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4782 if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
4783   echo $ECHO_N "(cached) $ECHO_C" >&6
4784 else
4785   if test -n "$ac_ct_FC"; then
4786   ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
4787 else
4788 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4789 for as_dir in $PATH
4790 do
4791   IFS=$as_save_IFS
4792   test -z "$as_dir" && as_dir=.
4793   for ac_exec_ext in '' $ac_executable_extensions; do
4794   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4795     ac_cv_prog_ac_ct_FC="$ac_prog"
4796     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4797     break 2
4798   fi
4799 done
4800 done
4801
4802 fi
4803 fi
4804 ac_ct_FC=$ac_cv_prog_ac_ct_FC
4805 if test -n "$ac_ct_FC"; then
4806   echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
4807 echo "${ECHO_T}$ac_ct_FC" >&6
4808 else
4809   echo "$as_me:$LINENO: result: no" >&5
4810 echo "${ECHO_T}no" >&6
4811 fi
4812
4813   test -n "$ac_ct_FC" && break
4814 done
4815
4816   FC=$ac_ct_FC
4817 fi
4818
4819
4820 # Provide some information about the compiler.
4821 echo "$as_me:4821:" \
4822      "checking for Fortran compiler version" >&5
4823 ac_compiler=`set X $ac_compile; echo $2`
4824 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
4825   (eval $ac_compiler --version </dev/null >&5) 2>&5
4826   ac_status=$?
4827   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4828   (exit $ac_status); }
4829 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
4830   (eval $ac_compiler -v </dev/null >&5) 2>&5
4831   ac_status=$?
4832   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4833   (exit $ac_status); }
4834 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
4835   (eval $ac_compiler -V </dev/null >&5) 2>&5
4836   ac_status=$?
4837   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4838   (exit $ac_status); }
4839 rm -f a.out
4840
4841 # If we don't use `.F' as extension, the preprocessor is not run on the
4842 # input file.  (Note that this only needs to work for GNU compilers.)
4843 ac_save_ext=$ac_ext
4844 ac_ext=F
4845 echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
4846 echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
4847 if test "${ac_cv_fc_compiler_gnu+set}" = set; then
4848   echo $ECHO_N "(cached) $ECHO_C" >&6
4849 else
4850   cat >conftest.$ac_ext <<_ACEOF
4851       program main
4852 #ifndef __GNUC__
4853        choke me
4854 #endif
4855
4856       end
4857 _ACEOF
4858 rm -f conftest.$ac_objext
4859 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4860   (eval $ac_compile) 2>conftest.er1
4861   ac_status=$?
4862   grep -v '^ *+' conftest.er1 >conftest.err
4863   rm -f conftest.er1
4864   cat conftest.err >&5
4865   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4866   (exit $ac_status); } &&
4867          { ac_try='test -z "$ac_fc_werror_flag"
4868                          || test ! -s conftest.err'
4869   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4870   (eval $ac_try) 2>&5
4871   ac_status=$?
4872   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4873   (exit $ac_status); }; } &&
4874          { ac_try='test -s conftest.$ac_objext'
4875   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4876   (eval $ac_try) 2>&5
4877   ac_status=$?
4878   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4879   (exit $ac_status); }; }; then
4880   ac_compiler_gnu=yes
4881 else
4882   echo "$as_me: failed program was:" >&5
4883 sed 's/^/| /' conftest.$ac_ext >&5
4884
4885 ac_compiler_gnu=no
4886 fi
4887 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4888 ac_cv_fc_compiler_gnu=$ac_compiler_gnu
4889
4890 fi
4891 echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
4892 echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
4893 ac_ext=$ac_save_ext
4894 ac_test_FFLAGS=${FCFLAGS+set}
4895 ac_save_FFLAGS=$FCFLAGS
4896 FCFLAGS=
4897 echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
4898 echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
4899 if test "${ac_cv_prog_fc_g+set}" = set; then
4900   echo $ECHO_N "(cached) $ECHO_C" >&6
4901 else
4902   FCFLAGS=-g
4903 cat >conftest.$ac_ext <<_ACEOF
4904       program main
4905
4906       end
4907 _ACEOF
4908 rm -f conftest.$ac_objext
4909 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4910   (eval $ac_compile) 2>conftest.er1
4911   ac_status=$?
4912   grep -v '^ *+' conftest.er1 >conftest.err
4913   rm -f conftest.er1
4914   cat conftest.err >&5
4915   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4916   (exit $ac_status); } &&
4917          { ac_try='test -z "$ac_fc_werror_flag"
4918                          || test ! -s conftest.err'
4919   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4920   (eval $ac_try) 2>&5
4921   ac_status=$?
4922   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4923   (exit $ac_status); }; } &&
4924          { ac_try='test -s conftest.$ac_objext'
4925   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4926   (eval $ac_try) 2>&5
4927   ac_status=$?
4928   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4929   (exit $ac_status); }; }; then
4930   ac_cv_prog_fc_g=yes
4931 else
4932   echo "$as_me: failed program was:" >&5
4933 sed 's/^/| /' conftest.$ac_ext >&5
4934
4935 ac_cv_prog_fc_g=no
4936 fi
4937 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4938
4939 fi
4940 echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
4941 echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
4942 if test "$ac_test_FFLAGS" = set; then
4943   FCFLAGS=$ac_save_FFLAGS
4944 elif test $ac_cv_prog_fc_g = yes; then
4945   if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4946     FCFLAGS="-g -O2"
4947   else
4948     FCFLAGS="-g"
4949   fi
4950 else
4951   if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4952     FCFLAGS="-O2"
4953   else
4954     FCFLAGS=
4955   fi
4956 fi
4957
4958 ac_ext=c
4959 ac_cpp='$CPP $CPPFLAGS'
4960 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4961 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4962 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4963
4964
4965 # extra LD Flags which are required for targets
4966 case "${host}" in
4967   *-darwin*)
4968     # Darwin needs -single_module when linking libgfortran
4969     extra_ldflags_libgfortran=-Wl,-single_module
4970     ;;
4971 esac
4972
4973
4974 # We need a working compiler at that point, otherwise give a clear
4975 # error message and bail out.
4976
4977
4978 echo "$as_me:$LINENO: checking whether the GNU Fortran compiler is working" >&5
4979 echo $ECHO_N "checking whether the GNU Fortran compiler is working... $ECHO_C" >&6
4980 ac_ext=${FC_SRCEXT-f}
4981 ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4982 ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4983 ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4984
4985 cat >conftest.$ac_ext <<_ACEOF
4986
4987       program foo
4988       real, parameter :: bar = sin (12.34 / 2.5)
4989       end program foo
4990 _ACEOF
4991 rm -f conftest.$ac_objext
4992 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4993   (eval $ac_compile) 2>conftest.er1
4994   ac_status=$?
4995   grep -v '^ *+' conftest.er1 >conftest.err
4996   rm -f conftest.er1
4997   cat conftest.err >&5
4998   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4999   (exit $ac_status); } &&
5000          { ac_try='test -z "$ac_fc_werror_flag"
5001                          || test ! -s conftest.err'
5002   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5003   (eval $ac_try) 2>&5
5004   ac_status=$?
5005   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5006   (exit $ac_status); }; } &&
5007          { ac_try='test -s conftest.$ac_objext'
5008   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5009   (eval $ac_try) 2>&5
5010   ac_status=$?
5011   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5012   (exit $ac_status); }; }; then
5013   echo "$as_me:$LINENO: result: yes" >&5
5014 echo "${ECHO_T}yes" >&6
5015 else
5016   echo "$as_me: failed program was:" >&5
5017 sed 's/^/| /' conftest.$ac_ext >&5
5018
5019 echo "$as_me:$LINENO: result: no" >&5
5020 echo "${ECHO_T}no" >&6
5021      { { 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
5022 echo "$as_me: error: GNU Fortran is not working; please report a bug in http://gcc.gnu.org/bugzilla, attaching $PWD/config.log" >&2;}
5023    { (exit 1); exit 1; }; }
5024
5025 fi
5026 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5027 ac_ext=c
5028 ac_cpp='$CPP $CPPFLAGS'
5029 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5030 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5031 ac_compiler_gnu=$ac_cv_c_compiler_gnu
5032
5033
5034
5035 # Check whether --enable-largefile or --disable-largefile was given.
5036 if test "${enable_largefile+set}" = set; then
5037   enableval="$enable_largefile"
5038
5039 fi;
5040 if test "$enable_largefile" != no; then
5041
5042   echo "$as_me:$LINENO: checking for special C compiler options needed for large files" >&5
5043 echo $ECHO_N "checking for special C compiler options needed for large files... $ECHO_C" >&6
5044 if test "${ac_cv_sys_largefile_CC+set}" = set; then
5045   echo $ECHO_N "(cached) $ECHO_C" >&6
5046 else
5047   ac_cv_sys_largefile_CC=no
5048      if test "$GCC" != yes; then
5049        ac_save_CC=$CC
5050        while :; do
5051          # IRIX 6.2 and later do not support large files by default,
5052          # so use the C compiler's -n32 option if that helps.
5053          cat >conftest.$ac_ext <<_ACEOF
5054 /* confdefs.h.  */
5055 _ACEOF
5056 cat confdefs.h >>conftest.$ac_ext
5057 cat >>conftest.$ac_ext <<_ACEOF
5058 /* end confdefs.h.  */
5059 #include <sys/types.h>
5060  /* Check that off_t can represent 2**63 - 1 correctly.
5061     We can't simply define LARGE_OFF_T to be 9223372036854775807,
5062     since some C++ compilers masquerading as C compilers
5063     incorrectly reject 9223372036854775807.  */
5064 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5065   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5066                        && LARGE_OFF_T % 2147483647 == 1)
5067                       ? 1 : -1];
5068 int
5069 main ()
5070 {
5071
5072   ;
5073   return 0;
5074 }
5075 _ACEOF
5076          rm -f conftest.$ac_objext
5077 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5078   (eval $ac_compile) 2>conftest.er1
5079   ac_status=$?
5080   grep -v '^ *+' conftest.er1 >conftest.err
5081   rm -f conftest.er1
5082   cat conftest.err >&5
5083   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5084   (exit $ac_status); } &&
5085          { ac_try='test -z "$ac_c_werror_flag"
5086                          || test ! -s conftest.err'
5087   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5088   (eval $ac_try) 2>&5
5089   ac_status=$?
5090   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5091   (exit $ac_status); }; } &&
5092          { ac_try='test -s conftest.$ac_objext'
5093   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5094   (eval $ac_try) 2>&5
5095   ac_status=$?
5096   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5097   (exit $ac_status); }; }; then
5098   break
5099 else
5100   echo "$as_me: failed program was:" >&5
5101 sed 's/^/| /' conftest.$ac_ext >&5
5102
5103 fi
5104 rm -f conftest.err conftest.$ac_objext
5105          CC="$CC -n32"
5106          rm -f conftest.$ac_objext
5107 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5108   (eval $ac_compile) 2>conftest.er1
5109   ac_status=$?
5110   grep -v '^ *+' conftest.er1 >conftest.err
5111   rm -f conftest.er1
5112   cat conftest.err >&5
5113   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5114   (exit $ac_status); } &&
5115          { ac_try='test -z "$ac_c_werror_flag"
5116                          || test ! -s conftest.err'
5117   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5118   (eval $ac_try) 2>&5
5119   ac_status=$?
5120   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5121   (exit $ac_status); }; } &&
5122          { ac_try='test -s conftest.$ac_objext'
5123   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5124   (eval $ac_try) 2>&5
5125   ac_status=$?
5126   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5127   (exit $ac_status); }; }; then
5128   ac_cv_sys_largefile_CC=' -n32'; break
5129 else
5130   echo "$as_me: failed program was:" >&5
5131 sed 's/^/| /' conftest.$ac_ext >&5
5132
5133 fi
5134 rm -f conftest.err conftest.$ac_objext
5135          break
5136        done
5137        CC=$ac_save_CC
5138        rm -f conftest.$ac_ext
5139     fi
5140 fi
5141 echo "$as_me:$LINENO: result: $ac_cv_sys_largefile_CC" >&5
5142 echo "${ECHO_T}$ac_cv_sys_largefile_CC" >&6
5143   if test "$ac_cv_sys_largefile_CC" != no; then
5144     CC=$CC$ac_cv_sys_largefile_CC
5145   fi
5146
5147   echo "$as_me:$LINENO: checking for _FILE_OFFSET_BITS value needed for large files" >&5
5148 echo $ECHO_N "checking for _FILE_OFFSET_BITS value needed for large files... $ECHO_C" >&6
5149 if test "${ac_cv_sys_file_offset_bits+set}" = set; then
5150   echo $ECHO_N "(cached) $ECHO_C" >&6
5151 else
5152   while :; do
5153   ac_cv_sys_file_offset_bits=no
5154   cat >conftest.$ac_ext <<_ACEOF
5155 /* confdefs.h.  */
5156 _ACEOF
5157 cat confdefs.h >>conftest.$ac_ext
5158 cat >>conftest.$ac_ext <<_ACEOF
5159 /* end confdefs.h.  */
5160 #include <sys/types.h>
5161  /* Check that off_t can represent 2**63 - 1 correctly.
5162     We can't simply define LARGE_OFF_T to be 9223372036854775807,
5163     since some C++ compilers masquerading as C compilers
5164     incorrectly reject 9223372036854775807.  */
5165 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5166   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5167                        && LARGE_OFF_T % 2147483647 == 1)
5168                       ? 1 : -1];
5169 int
5170 main ()
5171 {
5172
5173   ;
5174   return 0;
5175 }
5176 _ACEOF
5177 rm -f conftest.$ac_objext
5178 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5179   (eval $ac_compile) 2>conftest.er1
5180   ac_status=$?
5181   grep -v '^ *+' conftest.er1 >conftest.err
5182   rm -f conftest.er1
5183   cat conftest.err >&5
5184   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5185   (exit $ac_status); } &&
5186          { ac_try='test -z "$ac_c_werror_flag"
5187                          || test ! -s conftest.err'
5188   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5189   (eval $ac_try) 2>&5
5190   ac_status=$?
5191   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5192   (exit $ac_status); }; } &&
5193          { ac_try='test -s conftest.$ac_objext'
5194   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5195   (eval $ac_try) 2>&5
5196   ac_status=$?
5197   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5198   (exit $ac_status); }; }; then
5199   break
5200 else
5201   echo "$as_me: failed program was:" >&5
5202 sed 's/^/| /' conftest.$ac_ext >&5
5203
5204 fi
5205 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5206   cat >conftest.$ac_ext <<_ACEOF
5207 /* confdefs.h.  */
5208 _ACEOF
5209 cat confdefs.h >>conftest.$ac_ext
5210 cat >>conftest.$ac_ext <<_ACEOF
5211 /* end confdefs.h.  */
5212 #define _FILE_OFFSET_BITS 64
5213 #include <sys/types.h>
5214  /* Check that off_t can represent 2**63 - 1 correctly.
5215     We can't simply define LARGE_OFF_T to be 9223372036854775807,
5216     since some C++ compilers masquerading as C compilers
5217     incorrectly reject 9223372036854775807.  */
5218 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5219   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5220                        && LARGE_OFF_T % 2147483647 == 1)
5221                       ? 1 : -1];
5222 int
5223 main ()
5224 {
5225
5226   ;
5227   return 0;
5228 }
5229 _ACEOF
5230 rm -f conftest.$ac_objext
5231 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5232   (eval $ac_compile) 2>conftest.er1
5233   ac_status=$?
5234   grep -v '^ *+' conftest.er1 >conftest.err
5235   rm -f conftest.er1
5236   cat conftest.err >&5
5237   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5238   (exit $ac_status); } &&
5239          { ac_try='test -z "$ac_c_werror_flag"
5240                          || test ! -s conftest.err'
5241   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5242   (eval $ac_try) 2>&5
5243   ac_status=$?
5244   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5245   (exit $ac_status); }; } &&
5246          { ac_try='test -s conftest.$ac_objext'
5247   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5248   (eval $ac_try) 2>&5
5249   ac_status=$?
5250   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5251   (exit $ac_status); }; }; then
5252   ac_cv_sys_file_offset_bits=64; break
5253 else
5254   echo "$as_me: failed program was:" >&5
5255 sed 's/^/| /' conftest.$ac_ext >&5
5256
5257 fi
5258 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5259   break
5260 done
5261 fi
5262 echo "$as_me:$LINENO: result: $ac_cv_sys_file_offset_bits" >&5
5263 echo "${ECHO_T}$ac_cv_sys_file_offset_bits" >&6
5264 if test "$ac_cv_sys_file_offset_bits" != no; then
5265
5266 cat >>confdefs.h <<_ACEOF
5267 #define _FILE_OFFSET_BITS $ac_cv_sys_file_offset_bits
5268 _ACEOF
5269
5270 fi
5271 rm -f conftest*
5272   echo "$as_me:$LINENO: checking for _LARGE_FILES value needed for large files" >&5
5273 echo $ECHO_N "checking for _LARGE_FILES value needed for large files... $ECHO_C" >&6
5274 if test "${ac_cv_sys_large_files+set}" = set; then
5275   echo $ECHO_N "(cached) $ECHO_C" >&6
5276 else
5277   while :; do
5278   ac_cv_sys_large_files=no
5279   cat >conftest.$ac_ext <<_ACEOF
5280 /* confdefs.h.  */
5281 _ACEOF
5282 cat confdefs.h >>conftest.$ac_ext
5283 cat >>conftest.$ac_ext <<_ACEOF
5284 /* end confdefs.h.  */
5285 #include <sys/types.h>
5286  /* Check that off_t can represent 2**63 - 1 correctly.
5287     We can't simply define LARGE_OFF_T to be 9223372036854775807,
5288     since some C++ compilers masquerading as C compilers
5289     incorrectly reject 9223372036854775807.  */
5290 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5291   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5292                        && LARGE_OFF_T % 2147483647 == 1)
5293                       ? 1 : -1];
5294 int
5295 main ()
5296 {
5297
5298   ;
5299   return 0;
5300 }
5301 _ACEOF
5302 rm -f conftest.$ac_objext
5303 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5304   (eval $ac_compile) 2>conftest.er1
5305   ac_status=$?
5306   grep -v '^ *+' conftest.er1 >conftest.err
5307   rm -f conftest.er1
5308   cat conftest.err >&5
5309   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5310   (exit $ac_status); } &&
5311          { ac_try='test -z "$ac_c_werror_flag"
5312                          || test ! -s conftest.err'
5313   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5314   (eval $ac_try) 2>&5
5315   ac_status=$?
5316   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5317   (exit $ac_status); }; } &&
5318          { ac_try='test -s conftest.$ac_objext'
5319   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5320   (eval $ac_try) 2>&5
5321   ac_status=$?
5322   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5323   (exit $ac_status); }; }; then
5324   break
5325 else
5326   echo "$as_me: failed program was:" >&5
5327 sed 's/^/| /' conftest.$ac_ext >&5
5328
5329 fi
5330 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5331   cat >conftest.$ac_ext <<_ACEOF
5332 /* confdefs.h.  */
5333 _ACEOF
5334 cat confdefs.h >>conftest.$ac_ext
5335 cat >>conftest.$ac_ext <<_ACEOF
5336 /* end confdefs.h.  */
5337 #define _LARGE_FILES 1
5338 #include <sys/types.h>
5339  /* Check that off_t can represent 2**63 - 1 correctly.
5340     We can't simply define LARGE_OFF_T to be 9223372036854775807,
5341     since some C++ compilers masquerading as C compilers
5342     incorrectly reject 9223372036854775807.  */
5343 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5344   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5345                        && LARGE_OFF_T % 2147483647 == 1)
5346                       ? 1 : -1];
5347 int
5348 main ()
5349 {
5350
5351   ;
5352   return 0;
5353 }
5354 _ACEOF
5355 rm -f conftest.$ac_objext
5356 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5357   (eval $ac_compile) 2>conftest.er1
5358   ac_status=$?
5359   grep -v '^ *+' conftest.er1 >conftest.err
5360   rm -f conftest.er1
5361   cat conftest.err >&5
5362   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5363   (exit $ac_status); } &&
5364          { ac_try='test -z "$ac_c_werror_flag"
5365                          || test ! -s conftest.err'
5366   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5367   (eval $ac_try) 2>&5
5368   ac_status=$?
5369   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5370   (exit $ac_status); }; } &&
5371          { ac_try='test -s conftest.$ac_objext'
5372   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5373   (eval $ac_try) 2>&5
5374   ac_status=$?
5375   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5376   (exit $ac_status); }; }; then
5377   ac_cv_sys_large_files=1; break
5378 else
5379   echo "$as_me: failed program was:" >&5
5380 sed 's/^/| /' conftest.$ac_ext >&5
5381
5382 fi
5383 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5384   break
5385 done
5386 fi
5387 echo "$as_me:$LINENO: result: $ac_cv_sys_large_files" >&5
5388 echo "${ECHO_T}$ac_cv_sys_large_files" >&6
5389 if test "$ac_cv_sys_large_files" != no; then
5390
5391 cat >>confdefs.h <<_ACEOF
5392 #define _LARGE_FILES $ac_cv_sys_large_files
5393 _ACEOF
5394
5395 fi
5396 rm -f conftest*
5397 fi
5398
5399 ac_ext=c
5400 ac_cpp='$CPP $CPPFLAGS'
5401 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5402 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5403 ac_compiler_gnu=$ac_cv_c_compiler_gnu
5404 echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
5405 echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
5406 # On Suns, sometimes $CPP names a directory.
5407 if test -n "$CPP" && test -d "$CPP"; then
5408   CPP=
5409 fi
5410 if test -z "$CPP"; then
5411   if test "${ac_cv_prog_CPP+set}" = set; then
5412   echo $ECHO_N "(cached) $ECHO_C" >&6
5413 else
5414       # Double quotes because CPP needs to be expanded
5415     for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
5416     do
5417       ac_preproc_ok=false
5418 for ac_c_preproc_warn_flag in '' yes
5419 do
5420   # Use a header file that comes with gcc, so configuring glibc
5421   # with a fresh cross-compiler works.
5422   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5423   # <limits.h> exists even on freestanding compilers.
5424   # On the NeXT, cc -E runs the code through the compiler's parser,
5425   # not just through cpp. "Syntax error" is here to catch this case.
5426   cat >conftest.$ac_ext <<_ACEOF
5427 /* confdefs.h.  */
5428 _ACEOF
5429 cat confdefs.h >>conftest.$ac_ext
5430 cat >>conftest.$ac_ext <<_ACEOF
5431 /* end confdefs.h.  */
5432 #ifdef __STDC__
5433 # include <limits.h>
5434 #else
5435 # include <assert.h>
5436 #endif
5437                      Syntax error
5438 _ACEOF
5439 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5440   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5441   ac_status=$?
5442   grep -v '^ *+' conftest.er1 >conftest.err
5443   rm -f conftest.er1
5444   cat conftest.err >&5
5445   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5446   (exit $ac_status); } >/dev/null; then
5447   if test -s conftest.err; then
5448     ac_cpp_err=$ac_c_preproc_warn_flag
5449     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5450   else
5451     ac_cpp_err=
5452   fi
5453 else
5454   ac_cpp_err=yes
5455 fi
5456 if test -z "$ac_cpp_err"; then
5457   :
5458 else
5459   echo "$as_me: failed program was:" >&5
5460 sed 's/^/| /' conftest.$ac_ext >&5
5461
5462   # Broken: fails on valid input.
5463 continue
5464 fi
5465 rm -f conftest.err conftest.$ac_ext
5466
5467   # OK, works on sane cases.  Now check whether non-existent headers
5468   # can be detected and how.
5469   cat >conftest.$ac_ext <<_ACEOF
5470 /* confdefs.h.  */
5471 _ACEOF
5472 cat confdefs.h >>conftest.$ac_ext
5473 cat >>conftest.$ac_ext <<_ACEOF
5474 /* end confdefs.h.  */
5475 #include <ac_nonexistent.h>
5476 _ACEOF
5477 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5478   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5479   ac_status=$?
5480   grep -v '^ *+' conftest.er1 >conftest.err
5481   rm -f conftest.er1
5482   cat conftest.err >&5
5483   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5484   (exit $ac_status); } >/dev/null; then
5485   if test -s conftest.err; then
5486     ac_cpp_err=$ac_c_preproc_warn_flag
5487     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5488   else
5489     ac_cpp_err=
5490   fi
5491 else
5492   ac_cpp_err=yes
5493 fi
5494 if test -z "$ac_cpp_err"; then
5495   # Broken: success on invalid input.
5496 continue
5497 else
5498   echo "$as_me: failed program was:" >&5
5499 sed 's/^/| /' conftest.$ac_ext >&5
5500
5501   # Passes both tests.
5502 ac_preproc_ok=:
5503 break
5504 fi
5505 rm -f conftest.err conftest.$ac_ext
5506
5507 done
5508 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5509 rm -f conftest.err conftest.$ac_ext
5510 if $ac_preproc_ok; then
5511   break
5512 fi
5513
5514     done
5515     ac_cv_prog_CPP=$CPP
5516
5517 fi
5518   CPP=$ac_cv_prog_CPP
5519 else
5520   ac_cv_prog_CPP=$CPP
5521 fi
5522 echo "$as_me:$LINENO: result: $CPP" >&5
5523 echo "${ECHO_T}$CPP" >&6
5524 ac_preproc_ok=false
5525 for ac_c_preproc_warn_flag in '' yes
5526 do
5527   # Use a header file that comes with gcc, so configuring glibc
5528   # with a fresh cross-compiler works.
5529   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5530   # <limits.h> exists even on freestanding compilers.
5531   # On the NeXT, cc -E runs the code through the compiler's parser,
5532   # not just through cpp. "Syntax error" is here to catch this case.
5533   cat >conftest.$ac_ext <<_ACEOF
5534 /* confdefs.h.  */
5535 _ACEOF
5536 cat confdefs.h >>conftest.$ac_ext
5537 cat >>conftest.$ac_ext <<_ACEOF
5538 /* end confdefs.h.  */
5539 #ifdef __STDC__
5540 # include <limits.h>
5541 #else
5542 # include <assert.h>
5543 #endif
5544                      Syntax error
5545 _ACEOF
5546 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5547   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5548   ac_status=$?
5549   grep -v '^ *+' conftest.er1 >conftest.err
5550   rm -f conftest.er1
5551   cat conftest.err >&5
5552   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5553   (exit $ac_status); } >/dev/null; then
5554   if test -s conftest.err; then
5555     ac_cpp_err=$ac_c_preproc_warn_flag
5556     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5557   else
5558     ac_cpp_err=
5559   fi
5560 else
5561   ac_cpp_err=yes
5562 fi
5563 if test -z "$ac_cpp_err"; then
5564   :
5565 else
5566   echo "$as_me: failed program was:" >&5
5567 sed 's/^/| /' conftest.$ac_ext >&5
5568
5569   # Broken: fails on valid input.
5570 continue
5571 fi
5572 rm -f conftest.err conftest.$ac_ext
5573
5574   # OK, works on sane cases.  Now check whether non-existent headers
5575   # can be detected and how.
5576   cat >conftest.$ac_ext <<_ACEOF
5577 /* confdefs.h.  */
5578 _ACEOF
5579 cat confdefs.h >>conftest.$ac_ext
5580 cat >>conftest.$ac_ext <<_ACEOF
5581 /* end confdefs.h.  */
5582 #include <ac_nonexistent.h>
5583 _ACEOF
5584 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5585   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5586   ac_status=$?
5587   grep -v '^ *+' conftest.er1 >conftest.err
5588   rm -f conftest.er1
5589   cat conftest.err >&5
5590   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5591   (exit $ac_status); } >/dev/null; then
5592   if test -s conftest.err; then
5593     ac_cpp_err=$ac_c_preproc_warn_flag
5594     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5595   else
5596     ac_cpp_err=
5597   fi
5598 else
5599   ac_cpp_err=yes
5600 fi
5601 if test -z "$ac_cpp_err"; then
5602   # Broken: success on invalid input.
5603 continue
5604 else
5605   echo "$as_me: failed program was:" >&5
5606 sed 's/^/| /' conftest.$ac_ext >&5
5607
5608   # Passes both tests.
5609 ac_preproc_ok=:
5610 break
5611 fi
5612 rm -f conftest.err conftest.$ac_ext
5613
5614 done
5615 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5616 rm -f conftest.err conftest.$ac_ext
5617 if $ac_preproc_ok; then
5618   :
5619 else
5620   { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
5621 See \`config.log' for more details." >&5
5622 echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
5623 See \`config.log' for more details." >&2;}
5624    { (exit 1); exit 1; }; }
5625 fi
5626
5627 ac_ext=c
5628 ac_cpp='$CPP $CPPFLAGS'
5629 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5630 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5631 ac_compiler_gnu=$ac_cv_c_compiler_gnu
5632
5633
5634 echo "$as_me:$LINENO: checking for egrep" >&5
5635 echo $ECHO_N "checking for egrep... $ECHO_C" >&6
5636 if test "${ac_cv_prog_egrep+set}" = set; then
5637   echo $ECHO_N "(cached) $ECHO_C" >&6
5638 else
5639   if echo a | (grep -E '(a|b)') >/dev/null 2>&1
5640     then ac_cv_prog_egrep='grep -E'
5641     else ac_cv_prog_egrep='egrep'
5642     fi
5643 fi
5644 echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
5645 echo "${ECHO_T}$ac_cv_prog_egrep" >&6
5646  EGREP=$ac_cv_prog_egrep
5647
5648
5649 echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5650 echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5651 if test "${ac_cv_header_stdc+set}" = set; then
5652   echo $ECHO_N "(cached) $ECHO_C" >&6
5653 else
5654   cat >conftest.$ac_ext <<_ACEOF
5655 /* confdefs.h.  */
5656 _ACEOF
5657 cat confdefs.h >>conftest.$ac_ext
5658 cat >>conftest.$ac_ext <<_ACEOF
5659 /* end confdefs.h.  */
5660 #include <stdlib.h>
5661 #include <stdarg.h>
5662 #include <string.h>
5663 #include <float.h>
5664
5665 int
5666 main ()
5667 {
5668
5669   ;
5670   return 0;
5671 }
5672 _ACEOF
5673 rm -f conftest.$ac_objext
5674 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5675   (eval $ac_compile) 2>conftest.er1
5676   ac_status=$?
5677   grep -v '^ *+' conftest.er1 >conftest.err
5678   rm -f conftest.er1
5679   cat conftest.err >&5
5680   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5681   (exit $ac_status); } &&
5682          { ac_try='test -z "$ac_c_werror_flag"
5683                          || test ! -s conftest.err'
5684   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5685   (eval $ac_try) 2>&5
5686   ac_status=$?
5687   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5688   (exit $ac_status); }; } &&
5689          { ac_try='test -s conftest.$ac_objext'
5690   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5691   (eval $ac_try) 2>&5
5692   ac_status=$?
5693   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5694   (exit $ac_status); }; }; then
5695   ac_cv_header_stdc=yes
5696 else
5697   echo "$as_me: failed program was:" >&5
5698 sed 's/^/| /' conftest.$ac_ext >&5
5699
5700 ac_cv_header_stdc=no
5701 fi
5702 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5703
5704 if test $ac_cv_header_stdc = yes; then
5705   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5706   cat >conftest.$ac_ext <<_ACEOF
5707 /* confdefs.h.  */
5708 _ACEOF
5709 cat confdefs.h >>conftest.$ac_ext
5710 cat >>conftest.$ac_ext <<_ACEOF
5711 /* end confdefs.h.  */
5712 #include <string.h>
5713
5714 _ACEOF
5715 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5716   $EGREP "memchr" >/dev/null 2>&1; then
5717   :
5718 else
5719   ac_cv_header_stdc=no
5720 fi
5721 rm -f conftest*
5722
5723 fi
5724
5725 if test $ac_cv_header_stdc = yes; then
5726   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5727   cat >conftest.$ac_ext <<_ACEOF
5728 /* confdefs.h.  */
5729 _ACEOF
5730 cat confdefs.h >>conftest.$ac_ext
5731 cat >>conftest.$ac_ext <<_ACEOF
5732 /* end confdefs.h.  */
5733 #include <stdlib.h>
5734
5735 _ACEOF
5736 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5737   $EGREP "free" >/dev/null 2>&1; then
5738   :
5739 else
5740   ac_cv_header_stdc=no
5741 fi
5742 rm -f conftest*
5743
5744 fi
5745
5746 if test $ac_cv_header_stdc = yes; then
5747   # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5748   if test "$cross_compiling" = yes; then
5749   :
5750 else
5751   cat >conftest.$ac_ext <<_ACEOF
5752 /* confdefs.h.  */
5753 _ACEOF
5754 cat confdefs.h >>conftest.$ac_ext
5755 cat >>conftest.$ac_ext <<_ACEOF
5756 /* end confdefs.h.  */
5757 #include <ctype.h>
5758 #if ((' ' & 0x0FF) == 0x020)
5759 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5760 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5761 #else
5762 # define ISLOWER(c) \
5763                    (('a' <= (c) && (c) <= 'i') \
5764                      || ('j' <= (c) && (c) <= 'r') \
5765                      || ('s' <= (c) && (c) <= 'z'))
5766 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5767 #endif
5768
5769 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5770 int
5771 main ()
5772 {
5773   int i;
5774   for (i = 0; i < 256; i++)
5775     if (XOR (islower (i), ISLOWER (i))
5776         || toupper (i) != TOUPPER (i))
5777       exit(2);
5778   exit (0);
5779 }
5780 _ACEOF
5781 rm -f conftest$ac_exeext
5782 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5783   (eval $ac_link) 2>&5
5784   ac_status=$?
5785   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5786   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5787   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5788   (eval $ac_try) 2>&5
5789   ac_status=$?
5790   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5791   (exit $ac_status); }; }; then
5792   :
5793 else
5794   echo "$as_me: program exited with status $ac_status" >&5
5795 echo "$as_me: failed program was:" >&5
5796 sed 's/^/| /' conftest.$ac_ext >&5
5797
5798 ( exit $ac_status )
5799 ac_cv_header_stdc=no
5800 fi
5801 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5802 fi
5803 fi
5804 fi
5805 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5806 echo "${ECHO_T}$ac_cv_header_stdc" >&6
5807 if test $ac_cv_header_stdc = yes; then
5808
5809 cat >>confdefs.h <<\_ACEOF
5810 #define STDC_HEADERS 1
5811 _ACEOF
5812
5813 fi
5814
5815 # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5816
5817
5818
5819
5820
5821
5822
5823
5824
5825 for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5826                   inttypes.h stdint.h unistd.h
5827 do
5828 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5829 echo "$as_me:$LINENO: checking for $ac_header" >&5
5830 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5831 if eval "test \"\${$as_ac_Header+set}\" = set"; then
5832   echo $ECHO_N "(cached) $ECHO_C" >&6
5833 else
5834   cat >conftest.$ac_ext <<_ACEOF
5835 /* confdefs.h.  */
5836 _ACEOF
5837 cat confdefs.h >>conftest.$ac_ext
5838 cat >>conftest.$ac_ext <<_ACEOF
5839 /* end confdefs.h.  */
5840 $ac_includes_default
5841
5842 #include <$ac_header>
5843 _ACEOF
5844 rm -f conftest.$ac_objext
5845 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5846   (eval $ac_compile) 2>conftest.er1
5847   ac_status=$?
5848   grep -v '^ *+' conftest.er1 >conftest.err
5849   rm -f conftest.er1
5850   cat conftest.err >&5
5851   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5852   (exit $ac_status); } &&
5853          { ac_try='test -z "$ac_c_werror_flag"
5854                          || test ! -s conftest.err'
5855   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5856   (eval $ac_try) 2>&5
5857   ac_status=$?
5858   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5859   (exit $ac_status); }; } &&
5860          { ac_try='test -s conftest.$ac_objext'
5861   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5862   (eval $ac_try) 2>&5
5863   ac_status=$?
5864   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5865   (exit $ac_status); }; }; then
5866   eval "$as_ac_Header=yes"
5867 else
5868   echo "$as_me: failed program was:" >&5
5869 sed 's/^/| /' conftest.$ac_ext >&5
5870
5871 eval "$as_ac_Header=no"
5872 fi
5873 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5874 fi
5875 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5876 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5877 if test `eval echo '${'$as_ac_Header'}'` = yes; then
5878   cat >>confdefs.h <<_ACEOF
5879 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5880 _ACEOF
5881
5882 fi
5883
5884 done
5885
5886
5887 echo "$as_me:$LINENO: checking for off_t" >&5
5888 echo $ECHO_N "checking for off_t... $ECHO_C" >&6
5889 if test "${ac_cv_type_off_t+set}" = set; then
5890   echo $ECHO_N "(cached) $ECHO_C" >&6
5891 else
5892   cat >conftest.$ac_ext <<_ACEOF
5893 /* confdefs.h.  */
5894 _ACEOF
5895 cat confdefs.h >>conftest.$ac_ext
5896 cat >>conftest.$ac_ext <<_ACEOF
5897 /* end confdefs.h.  */
5898 $ac_includes_default
5899 int
5900 main ()
5901 {
5902 if ((off_t *) 0)
5903   return 0;
5904 if (sizeof (off_t))
5905   return 0;
5906   ;
5907   return 0;
5908 }
5909 _ACEOF
5910 rm -f conftest.$ac_objext
5911 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5912   (eval $ac_compile) 2>conftest.er1
5913   ac_status=$?
5914   grep -v '^ *+' conftest.er1 >conftest.err
5915   rm -f conftest.er1
5916   cat conftest.err >&5
5917   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5918   (exit $ac_status); } &&
5919          { ac_try='test -z "$ac_c_werror_flag"
5920                          || test ! -s conftest.err'
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); }; } &&
5926          { ac_try='test -s conftest.$ac_objext'
5927   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5928   (eval $ac_try) 2>&5
5929   ac_status=$?
5930   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5931   (exit $ac_status); }; }; then
5932   ac_cv_type_off_t=yes
5933 else
5934   echo "$as_me: failed program was:" >&5
5935 sed 's/^/| /' conftest.$ac_ext >&5
5936
5937 ac_cv_type_off_t=no
5938 fi
5939 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5940 fi
5941 echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5
5942 echo "${ECHO_T}$ac_cv_type_off_t" >&6
5943 if test $ac_cv_type_off_t = yes; then
5944   :
5945 else
5946
5947 cat >>confdefs.h <<_ACEOF
5948 #define off_t long
5949 _ACEOF
5950
5951 fi
5952
5953
5954 # check header files
5955 echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5956 echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5957 if test "${ac_cv_header_stdc+set}" = set; then
5958   echo $ECHO_N "(cached) $ECHO_C" >&6
5959 else
5960   cat >conftest.$ac_ext <<_ACEOF
5961 /* confdefs.h.  */
5962 _ACEOF
5963 cat confdefs.h >>conftest.$ac_ext
5964 cat >>conftest.$ac_ext <<_ACEOF
5965 /* end confdefs.h.  */
5966 #include <stdlib.h>
5967 #include <stdarg.h>
5968 #include <string.h>
5969 #include <float.h>
5970
5971 int
5972 main ()
5973 {
5974
5975   ;
5976   return 0;
5977 }
5978 _ACEOF
5979 rm -f conftest.$ac_objext
5980 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5981   (eval $ac_compile) 2>conftest.er1
5982   ac_status=$?
5983   grep -v '^ *+' conftest.er1 >conftest.err
5984   rm -f conftest.er1
5985   cat conftest.err >&5
5986   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5987   (exit $ac_status); } &&
5988          { ac_try='test -z "$ac_c_werror_flag"
5989                          || test ! -s conftest.err'
5990   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5991   (eval $ac_try) 2>&5
5992   ac_status=$?
5993   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5994   (exit $ac_status); }; } &&
5995          { ac_try='test -s conftest.$ac_objext'
5996   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5997   (eval $ac_try) 2>&5
5998   ac_status=$?
5999   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6000   (exit $ac_status); }; }; then
6001   ac_cv_header_stdc=yes
6002 else
6003   echo "$as_me: failed program was:" >&5
6004 sed 's/^/| /' conftest.$ac_ext >&5
6005
6006 ac_cv_header_stdc=no
6007 fi
6008 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6009
6010 if test $ac_cv_header_stdc = yes; then
6011   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
6012   cat >conftest.$ac_ext <<_ACEOF
6013 /* confdefs.h.  */
6014 _ACEOF
6015 cat confdefs.h >>conftest.$ac_ext
6016 cat >>conftest.$ac_ext <<_ACEOF
6017 /* end confdefs.h.  */
6018 #include <string.h>
6019
6020 _ACEOF
6021 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6022   $EGREP "memchr" >/dev/null 2>&1; then
6023   :
6024 else
6025   ac_cv_header_stdc=no
6026 fi
6027 rm -f conftest*
6028
6029 fi
6030
6031 if test $ac_cv_header_stdc = yes; then
6032   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
6033   cat >conftest.$ac_ext <<_ACEOF
6034 /* confdefs.h.  */
6035 _ACEOF
6036 cat confdefs.h >>conftest.$ac_ext
6037 cat >>conftest.$ac_ext <<_ACEOF
6038 /* end confdefs.h.  */
6039 #include <stdlib.h>
6040
6041 _ACEOF
6042 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6043   $EGREP "free" >/dev/null 2>&1; then
6044   :
6045 else
6046   ac_cv_header_stdc=no
6047 fi
6048 rm -f conftest*
6049
6050 fi
6051
6052 if test $ac_cv_header_stdc = yes; then
6053   # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
6054   if test "$cross_compiling" = yes; then
6055   :
6056 else
6057   cat >conftest.$ac_ext <<_ACEOF
6058 /* confdefs.h.  */
6059 _ACEOF
6060 cat confdefs.h >>conftest.$ac_ext
6061 cat >>conftest.$ac_ext <<_ACEOF
6062 /* end confdefs.h.  */
6063 #include <ctype.h>
6064 #if ((' ' & 0x0FF) == 0x020)
6065 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
6066 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
6067 #else
6068 # define ISLOWER(c) \
6069                    (('a' <= (c) && (c) <= 'i') \
6070                      || ('j' <= (c) && (c) <= 'r') \
6071                      || ('s' <= (c) && (c) <= 'z'))
6072 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
6073 #endif
6074
6075 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
6076 int
6077 main ()
6078 {
6079   int i;
6080   for (i = 0; i < 256; i++)
6081     if (XOR (islower (i), ISLOWER (i))
6082         || toupper (i) != TOUPPER (i))
6083       exit(2);
6084   exit (0);
6085 }
6086 _ACEOF
6087 rm -f conftest$ac_exeext
6088 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6089   (eval $ac_link) 2>&5
6090   ac_status=$?
6091   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6092   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
6093   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6094   (eval $ac_try) 2>&5
6095   ac_status=$?
6096   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6097   (exit $ac_status); }; }; then
6098   :
6099 else
6100   echo "$as_me: program exited with status $ac_status" >&5
6101 echo "$as_me: failed program was:" >&5
6102 sed 's/^/| /' conftest.$ac_ext >&5
6103
6104 ( exit $ac_status )
6105 ac_cv_header_stdc=no
6106 fi
6107 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
6108 fi
6109 fi
6110 fi
6111 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
6112 echo "${ECHO_T}$ac_cv_header_stdc" >&6
6113 if test $ac_cv_header_stdc = yes; then
6114
6115 cat >>confdefs.h <<\_ACEOF
6116 #define STDC_HEADERS 1
6117 _ACEOF
6118
6119 fi
6120
6121 echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
6122 echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
6123 if test "${ac_cv_header_time+set}" = set; then
6124   echo $ECHO_N "(cached) $ECHO_C" >&6
6125 else
6126   cat >conftest.$ac_ext <<_ACEOF
6127 /* confdefs.h.  */
6128 _ACEOF
6129 cat confdefs.h >>conftest.$ac_ext
6130 cat >>conftest.$ac_ext <<_ACEOF
6131 /* end confdefs.h.  */
6132 #include <sys/types.h>
6133 #include <sys/time.h>
6134 #include <time.h>
6135
6136 int
6137 main ()
6138 {
6139 if ((struct tm *) 0)
6140 return 0;
6141   ;
6142   return 0;
6143 }
6144 _ACEOF
6145 rm -f conftest.$ac_objext
6146 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6147   (eval $ac_compile) 2>conftest.er1
6148   ac_status=$?
6149   grep -v '^ *+' conftest.er1 >conftest.err
6150   rm -f conftest.er1
6151   cat conftest.err >&5
6152   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6153   (exit $ac_status); } &&
6154          { ac_try='test -z "$ac_c_werror_flag"
6155                          || test ! -s conftest.err'
6156   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6157   (eval $ac_try) 2>&5
6158   ac_status=$?
6159   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6160   (exit $ac_status); }; } &&
6161          { ac_try='test -s conftest.$ac_objext'
6162   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6163   (eval $ac_try) 2>&5
6164   ac_status=$?
6165   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6166   (exit $ac_status); }; }; then
6167   ac_cv_header_time=yes
6168 else
6169   echo "$as_me: failed program was:" >&5
6170 sed 's/^/| /' conftest.$ac_ext >&5
6171
6172 ac_cv_header_time=no
6173 fi
6174 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6175 fi
6176 echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
6177 echo "${ECHO_T}$ac_cv_header_time" >&6
6178 if test $ac_cv_header_time = yes; then
6179
6180 cat >>confdefs.h <<\_ACEOF
6181 #define TIME_WITH_SYS_TIME 1
6182 _ACEOF
6183
6184 fi
6185
6186
6187
6188
6189
6190 for ac_header in stdlib.h string.h unistd.h signal.h
6191 do
6192 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6193 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6194   echo "$as_me:$LINENO: checking for $ac_header" >&5
6195 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6196 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6197   echo $ECHO_N "(cached) $ECHO_C" >&6
6198 fi
6199 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6200 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6201 else
6202   # Is the header compilable?
6203 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6204 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6205 cat >conftest.$ac_ext <<_ACEOF
6206 /* confdefs.h.  */
6207 _ACEOF
6208 cat confdefs.h >>conftest.$ac_ext
6209 cat >>conftest.$ac_ext <<_ACEOF
6210 /* end confdefs.h.  */
6211 $ac_includes_default
6212 #include <$ac_header>
6213 _ACEOF
6214 rm -f conftest.$ac_objext
6215 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6216   (eval $ac_compile) 2>conftest.er1
6217   ac_status=$?
6218   grep -v '^ *+' conftest.er1 >conftest.err
6219   rm -f conftest.er1
6220   cat conftest.err >&5
6221   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6222   (exit $ac_status); } &&
6223          { ac_try='test -z "$ac_c_werror_flag"
6224                          || test ! -s conftest.err'
6225   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6226   (eval $ac_try) 2>&5
6227   ac_status=$?
6228   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6229   (exit $ac_status); }; } &&
6230          { ac_try='test -s conftest.$ac_objext'
6231   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6232   (eval $ac_try) 2>&5
6233   ac_status=$?
6234   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6235   (exit $ac_status); }; }; then
6236   ac_header_compiler=yes
6237 else
6238   echo "$as_me: failed program was:" >&5
6239 sed 's/^/| /' conftest.$ac_ext >&5
6240
6241 ac_header_compiler=no
6242 fi
6243 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6244 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6245 echo "${ECHO_T}$ac_header_compiler" >&6
6246
6247 # Is the header present?
6248 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6249 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6250 cat >conftest.$ac_ext <<_ACEOF
6251 /* confdefs.h.  */
6252 _ACEOF
6253 cat confdefs.h >>conftest.$ac_ext
6254 cat >>conftest.$ac_ext <<_ACEOF
6255 /* end confdefs.h.  */
6256 #include <$ac_header>
6257 _ACEOF
6258 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6259   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6260   ac_status=$?
6261   grep -v '^ *+' conftest.er1 >conftest.err
6262   rm -f conftest.er1
6263   cat conftest.err >&5
6264   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6265   (exit $ac_status); } >/dev/null; then
6266   if test -s conftest.err; then
6267     ac_cpp_err=$ac_c_preproc_warn_flag
6268     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6269   else
6270     ac_cpp_err=
6271   fi
6272 else
6273   ac_cpp_err=yes
6274 fi
6275 if test -z "$ac_cpp_err"; then
6276   ac_header_preproc=yes
6277 else
6278   echo "$as_me: failed program was:" >&5
6279 sed 's/^/| /' conftest.$ac_ext >&5
6280
6281   ac_header_preproc=no
6282 fi
6283 rm -f conftest.err conftest.$ac_ext
6284 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6285 echo "${ECHO_T}$ac_header_preproc" >&6
6286
6287 # So?  What about this header?
6288 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6289   yes:no: )
6290     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6291 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6292     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6293 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6294     ac_header_preproc=yes
6295     ;;
6296   no:yes:* )
6297     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6298 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6299     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6300 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6301     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6302 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6303     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6304 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6305     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6306 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6307     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6308 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6309     (
6310       cat <<\_ASBOX
6311 ## ------------------------------------------------------ ##
6312 ## Report this to the GNU Fortran Runtime Library lists.  ##
6313 ## ------------------------------------------------------ ##
6314 _ASBOX
6315     ) |
6316       sed "s/^/$as_me: WARNING:     /" >&2
6317     ;;
6318 esac
6319 echo "$as_me:$LINENO: checking for $ac_header" >&5
6320 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6321 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6322   echo $ECHO_N "(cached) $ECHO_C" >&6
6323 else
6324   eval "$as_ac_Header=\$ac_header_preproc"
6325 fi
6326 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6327 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6328
6329 fi
6330 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6331   cat >>confdefs.h <<_ACEOF
6332 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6333 _ACEOF
6334
6335 fi
6336
6337 done
6338
6339
6340
6341
6342
6343 for ac_header in time.h sys/time.h sys/times.h sys/resource.h
6344 do
6345 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6346 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6347   echo "$as_me:$LINENO: checking for $ac_header" >&5
6348 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6349 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6350   echo $ECHO_N "(cached) $ECHO_C" >&6
6351 fi
6352 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6353 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6354 else
6355   # Is the header compilable?
6356 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6357 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6358 cat >conftest.$ac_ext <<_ACEOF
6359 /* confdefs.h.  */
6360 _ACEOF
6361 cat confdefs.h >>conftest.$ac_ext
6362 cat >>conftest.$ac_ext <<_ACEOF
6363 /* end confdefs.h.  */
6364 $ac_includes_default
6365 #include <$ac_header>
6366 _ACEOF
6367 rm -f conftest.$ac_objext
6368 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6369   (eval $ac_compile) 2>conftest.er1
6370   ac_status=$?
6371   grep -v '^ *+' conftest.er1 >conftest.err
6372   rm -f conftest.er1
6373   cat conftest.err >&5
6374   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6375   (exit $ac_status); } &&
6376          { ac_try='test -z "$ac_c_werror_flag"
6377                          || test ! -s conftest.err'
6378   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6379   (eval $ac_try) 2>&5
6380   ac_status=$?
6381   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6382   (exit $ac_status); }; } &&
6383          { ac_try='test -s conftest.$ac_objext'
6384   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6385   (eval $ac_try) 2>&5
6386   ac_status=$?
6387   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6388   (exit $ac_status); }; }; then
6389   ac_header_compiler=yes
6390 else
6391   echo "$as_me: failed program was:" >&5
6392 sed 's/^/| /' conftest.$ac_ext >&5
6393
6394 ac_header_compiler=no
6395 fi
6396 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6397 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6398 echo "${ECHO_T}$ac_header_compiler" >&6
6399
6400 # Is the header present?
6401 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6402 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6403 cat >conftest.$ac_ext <<_ACEOF
6404 /* confdefs.h.  */
6405 _ACEOF
6406 cat confdefs.h >>conftest.$ac_ext
6407 cat >>conftest.$ac_ext <<_ACEOF
6408 /* end confdefs.h.  */
6409 #include <$ac_header>
6410 _ACEOF
6411 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6412   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6413   ac_status=$?
6414   grep -v '^ *+' conftest.er1 >conftest.err
6415   rm -f conftest.er1
6416   cat conftest.err >&5
6417   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6418   (exit $ac_status); } >/dev/null; then
6419   if test -s conftest.err; then
6420     ac_cpp_err=$ac_c_preproc_warn_flag
6421     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6422   else
6423     ac_cpp_err=
6424   fi
6425 else
6426   ac_cpp_err=yes
6427 fi
6428 if test -z "$ac_cpp_err"; then
6429   ac_header_preproc=yes
6430 else
6431   echo "$as_me: failed program was:" >&5
6432 sed 's/^/| /' conftest.$ac_ext >&5
6433
6434   ac_header_preproc=no
6435 fi
6436 rm -f conftest.err conftest.$ac_ext
6437 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6438 echo "${ECHO_T}$ac_header_preproc" >&6
6439
6440 # So?  What about this header?
6441 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6442   yes:no: )
6443     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6444 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6445     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6446 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6447     ac_header_preproc=yes
6448     ;;
6449   no:yes:* )
6450     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6451 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6452     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6453 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6454     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6455 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6456     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6457 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6458     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6459 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6460     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6461 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6462     (
6463       cat <<\_ASBOX
6464 ## ------------------------------------------------------ ##
6465 ## Report this to the GNU Fortran Runtime Library lists.  ##
6466 ## ------------------------------------------------------ ##
6467 _ASBOX
6468     ) |
6469       sed "s/^/$as_me: WARNING:     /" >&2
6470     ;;
6471 esac
6472 echo "$as_me:$LINENO: checking for $ac_header" >&5
6473 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6474 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6475   echo $ECHO_N "(cached) $ECHO_C" >&6
6476 else
6477   eval "$as_ac_Header=\$ac_header_preproc"
6478 fi
6479 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6480 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6481
6482 fi
6483 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6484   cat >>confdefs.h <<_ACEOF
6485 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6486 _ACEOF
6487
6488 fi
6489
6490 done
6491
6492
6493
6494
6495
6496
6497 for ac_header in sys/types.h sys/stat.h sys/wait.h floatingpoint.h ieeefp.h
6498 do
6499 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6500 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6501   echo "$as_me:$LINENO: checking for $ac_header" >&5
6502 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6503 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6504   echo $ECHO_N "(cached) $ECHO_C" >&6
6505 fi
6506 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6507 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6508 else
6509   # Is the header compilable?
6510 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6511 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6512 cat >conftest.$ac_ext <<_ACEOF
6513 /* confdefs.h.  */
6514 _ACEOF
6515 cat confdefs.h >>conftest.$ac_ext
6516 cat >>conftest.$ac_ext <<_ACEOF
6517 /* end confdefs.h.  */
6518 $ac_includes_default
6519 #include <$ac_header>
6520 _ACEOF
6521 rm -f conftest.$ac_objext
6522 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6523   (eval $ac_compile) 2>conftest.er1
6524   ac_status=$?
6525   grep -v '^ *+' conftest.er1 >conftest.err
6526   rm -f conftest.er1
6527   cat conftest.err >&5
6528   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6529   (exit $ac_status); } &&
6530          { ac_try='test -z "$ac_c_werror_flag"
6531                          || test ! -s conftest.err'
6532   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6533   (eval $ac_try) 2>&5
6534   ac_status=$?
6535   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6536   (exit $ac_status); }; } &&
6537          { ac_try='test -s conftest.$ac_objext'
6538   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6539   (eval $ac_try) 2>&5
6540   ac_status=$?
6541   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6542   (exit $ac_status); }; }; then
6543   ac_header_compiler=yes
6544 else
6545   echo "$as_me: failed program was:" >&5
6546 sed 's/^/| /' conftest.$ac_ext >&5
6547
6548 ac_header_compiler=no
6549 fi
6550 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6551 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6552 echo "${ECHO_T}$ac_header_compiler" >&6
6553
6554 # Is the header present?
6555 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6556 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6557 cat >conftest.$ac_ext <<_ACEOF
6558 /* confdefs.h.  */
6559 _ACEOF
6560 cat confdefs.h >>conftest.$ac_ext
6561 cat >>conftest.$ac_ext <<_ACEOF
6562 /* end confdefs.h.  */
6563 #include <$ac_header>
6564 _ACEOF
6565 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6566   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6567   ac_status=$?
6568   grep -v '^ *+' conftest.er1 >conftest.err
6569   rm -f conftest.er1
6570   cat conftest.err >&5
6571   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6572   (exit $ac_status); } >/dev/null; then
6573   if test -s conftest.err; then
6574     ac_cpp_err=$ac_c_preproc_warn_flag
6575     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6576   else
6577     ac_cpp_err=
6578   fi
6579 else
6580   ac_cpp_err=yes
6581 fi
6582 if test -z "$ac_cpp_err"; then
6583   ac_header_preproc=yes
6584 else
6585   echo "$as_me: failed program was:" >&5
6586 sed 's/^/| /' conftest.$ac_ext >&5
6587
6588   ac_header_preproc=no
6589 fi
6590 rm -f conftest.err conftest.$ac_ext
6591 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6592 echo "${ECHO_T}$ac_header_preproc" >&6
6593
6594 # So?  What about this header?
6595 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6596   yes:no: )
6597     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6598 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6599     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6600 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6601     ac_header_preproc=yes
6602     ;;
6603   no:yes:* )
6604     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6605 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6606     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6607 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6608     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6609 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6610     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6611 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6612     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6613 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6614     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6615 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6616     (
6617       cat <<\_ASBOX
6618 ## ------------------------------------------------------ ##
6619 ## Report this to the GNU Fortran Runtime Library lists.  ##
6620 ## ------------------------------------------------------ ##
6621 _ASBOX
6622     ) |
6623       sed "s/^/$as_me: WARNING:     /" >&2
6624     ;;
6625 esac
6626 echo "$as_me:$LINENO: checking for $ac_header" >&5
6627 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6628 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6629   echo $ECHO_N "(cached) $ECHO_C" >&6
6630 else
6631   eval "$as_ac_Header=\$ac_header_preproc"
6632 fi
6633 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6634 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6635
6636 fi
6637 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6638   cat >>confdefs.h <<_ACEOF
6639 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6640 _ACEOF
6641
6642 fi
6643
6644 done
6645
6646
6647
6648
6649
6650
6651 for ac_header in fenv.h fptrap.h float.h execinfo.h pwd.h
6652 do
6653 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6654 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6655   echo "$as_me:$LINENO: checking for $ac_header" >&5
6656 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6657 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6658   echo $ECHO_N "(cached) $ECHO_C" >&6
6659 fi
6660 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6661 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6662 else
6663   # Is the header compilable?
6664 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6665 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6666 cat >conftest.$ac_ext <<_ACEOF
6667 /* confdefs.h.  */
6668 _ACEOF
6669 cat confdefs.h >>conftest.$ac_ext
6670 cat >>conftest.$ac_ext <<_ACEOF
6671 /* end confdefs.h.  */
6672 $ac_includes_default
6673 #include <$ac_header>
6674 _ACEOF
6675 rm -f conftest.$ac_objext
6676 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6677   (eval $ac_compile) 2>conftest.er1
6678   ac_status=$?
6679   grep -v '^ *+' conftest.er1 >conftest.err
6680   rm -f conftest.er1
6681   cat conftest.err >&5
6682   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6683   (exit $ac_status); } &&
6684          { ac_try='test -z "$ac_c_werror_flag"
6685                          || test ! -s conftest.err'
6686   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6687   (eval $ac_try) 2>&5
6688   ac_status=$?
6689   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6690   (exit $ac_status); }; } &&
6691          { ac_try='test -s conftest.$ac_objext'
6692   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6693   (eval $ac_try) 2>&5
6694   ac_status=$?
6695   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6696   (exit $ac_status); }; }; then
6697   ac_header_compiler=yes
6698 else
6699   echo "$as_me: failed program was:" >&5
6700 sed 's/^/| /' conftest.$ac_ext >&5
6701
6702 ac_header_compiler=no
6703 fi
6704 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6705 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6706 echo "${ECHO_T}$ac_header_compiler" >&6
6707
6708 # Is the header present?
6709 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6710 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6711 cat >conftest.$ac_ext <<_ACEOF
6712 /* confdefs.h.  */
6713 _ACEOF
6714 cat confdefs.h >>conftest.$ac_ext
6715 cat >>conftest.$ac_ext <<_ACEOF
6716 /* end confdefs.h.  */
6717 #include <$ac_header>
6718 _ACEOF
6719 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6720   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6721   ac_status=$?
6722   grep -v '^ *+' conftest.er1 >conftest.err
6723   rm -f conftest.er1
6724   cat conftest.err >&5
6725   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6726   (exit $ac_status); } >/dev/null; then
6727   if test -s conftest.err; then
6728     ac_cpp_err=$ac_c_preproc_warn_flag
6729     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6730   else
6731     ac_cpp_err=
6732   fi
6733 else
6734   ac_cpp_err=yes
6735 fi
6736 if test -z "$ac_cpp_err"; then
6737   ac_header_preproc=yes
6738 else
6739   echo "$as_me: failed program was:" >&5
6740 sed 's/^/| /' conftest.$ac_ext >&5
6741
6742   ac_header_preproc=no
6743 fi
6744 rm -f conftest.err conftest.$ac_ext
6745 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6746 echo "${ECHO_T}$ac_header_preproc" >&6
6747
6748 # So?  What about this header?
6749 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6750   yes:no: )
6751     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6752 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6753     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6754 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6755     ac_header_preproc=yes
6756     ;;
6757   no:yes:* )
6758     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6759 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6760     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6761 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6762     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6763 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6764     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6765 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6766     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6767 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6768     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6769 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6770     (
6771       cat <<\_ASBOX
6772 ## ------------------------------------------------------ ##
6773 ## Report this to the GNU Fortran Runtime Library lists.  ##
6774 ## ------------------------------------------------------ ##
6775 _ASBOX
6776     ) |
6777       sed "s/^/$as_me: WARNING:     /" >&2
6778     ;;
6779 esac
6780 echo "$as_me:$LINENO: checking for $ac_header" >&5
6781 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6782 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6783   echo $ECHO_N "(cached) $ECHO_C" >&6
6784 else
6785   eval "$as_ac_Header=\$ac_header_preproc"
6786 fi
6787 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6788 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6789
6790 fi
6791 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6792   cat >>confdefs.h <<_ACEOF
6793 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6794 _ACEOF
6795
6796 fi
6797
6798 done
6799
6800 if test "${ac_cv_header_complex_h+set}" = set; then
6801   echo "$as_me:$LINENO: checking for complex.h" >&5
6802 echo $ECHO_N "checking for complex.h... $ECHO_C" >&6
6803 if test "${ac_cv_header_complex_h+set}" = set; then
6804   echo $ECHO_N "(cached) $ECHO_C" >&6
6805 fi
6806 echo "$as_me:$LINENO: result: $ac_cv_header_complex_h" >&5
6807 echo "${ECHO_T}$ac_cv_header_complex_h" >&6
6808 else
6809   # Is the header compilable?
6810 echo "$as_me:$LINENO: checking complex.h usability" >&5
6811 echo $ECHO_N "checking complex.h usability... $ECHO_C" >&6
6812 cat >conftest.$ac_ext <<_ACEOF
6813 /* confdefs.h.  */
6814 _ACEOF
6815 cat confdefs.h >>conftest.$ac_ext
6816 cat >>conftest.$ac_ext <<_ACEOF
6817 /* end confdefs.h.  */
6818 $ac_includes_default
6819 #include <complex.h>
6820 _ACEOF
6821 rm -f conftest.$ac_objext
6822 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6823   (eval $ac_compile) 2>conftest.er1
6824   ac_status=$?
6825   grep -v '^ *+' conftest.er1 >conftest.err
6826   rm -f conftest.er1
6827   cat conftest.err >&5
6828   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6829   (exit $ac_status); } &&
6830          { ac_try='test -z "$ac_c_werror_flag"
6831                          || test ! -s conftest.err'
6832   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6833   (eval $ac_try) 2>&5
6834   ac_status=$?
6835   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6836   (exit $ac_status); }; } &&
6837          { ac_try='test -s conftest.$ac_objext'
6838   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6839   (eval $ac_try) 2>&5
6840   ac_status=$?
6841   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6842   (exit $ac_status); }; }; then
6843   ac_header_compiler=yes
6844 else
6845   echo "$as_me: failed program was:" >&5
6846 sed 's/^/| /' conftest.$ac_ext >&5
6847
6848 ac_header_compiler=no
6849 fi
6850 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6851 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6852 echo "${ECHO_T}$ac_header_compiler" >&6
6853
6854 # Is the header present?
6855 echo "$as_me:$LINENO: checking complex.h presence" >&5
6856 echo $ECHO_N "checking complex.h presence... $ECHO_C" >&6
6857 cat >conftest.$ac_ext <<_ACEOF
6858 /* confdefs.h.  */
6859 _ACEOF
6860 cat confdefs.h >>conftest.$ac_ext
6861 cat >>conftest.$ac_ext <<_ACEOF
6862 /* end confdefs.h.  */
6863 #include <complex.h>
6864 _ACEOF
6865 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6866   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6867   ac_status=$?
6868   grep -v '^ *+' conftest.er1 >conftest.err
6869   rm -f conftest.er1
6870   cat conftest.err >&5
6871   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6872   (exit $ac_status); } >/dev/null; then
6873   if test -s conftest.err; then
6874     ac_cpp_err=$ac_c_preproc_warn_flag
6875     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6876   else
6877     ac_cpp_err=
6878   fi
6879 else
6880   ac_cpp_err=yes
6881 fi
6882 if test -z "$ac_cpp_err"; then
6883   ac_header_preproc=yes
6884 else
6885   echo "$as_me: failed program was:" >&5
6886 sed 's/^/| /' conftest.$ac_ext >&5
6887
6888   ac_header_preproc=no
6889 fi
6890 rm -f conftest.err conftest.$ac_ext
6891 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6892 echo "${ECHO_T}$ac_header_preproc" >&6
6893
6894 # So?  What about this header?
6895 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6896   yes:no: )
6897     { echo "$as_me:$LINENO: WARNING: complex.h: accepted by the compiler, rejected by the preprocessor!" >&5
6898 echo "$as_me: WARNING: complex.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6899     { echo "$as_me:$LINENO: WARNING: complex.h: proceeding with the compiler's result" >&5
6900 echo "$as_me: WARNING: complex.h: proceeding with the compiler's result" >&2;}
6901     ac_header_preproc=yes
6902     ;;
6903   no:yes:* )
6904     { echo "$as_me:$LINENO: WARNING: complex.h: present but cannot be compiled" >&5
6905 echo "$as_me: WARNING: complex.h: present but cannot be compiled" >&2;}
6906     { echo "$as_me:$LINENO: WARNING: complex.h:     check for missing prerequisite headers?" >&5
6907 echo "$as_me: WARNING: complex.h:     check for missing prerequisite headers?" >&2;}
6908     { echo "$as_me:$LINENO: WARNING: complex.h: see the Autoconf documentation" >&5
6909 echo "$as_me: WARNING: complex.h: see the Autoconf documentation" >&2;}
6910     { echo "$as_me:$LINENO: WARNING: complex.h:     section \"Present But Cannot Be Compiled\"" >&5
6911 echo "$as_me: WARNING: complex.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6912     { echo "$as_me:$LINENO: WARNING: complex.h: proceeding with the preprocessor's result" >&5
6913 echo "$as_me: WARNING: complex.h: proceeding with the preprocessor's result" >&2;}
6914     { echo "$as_me:$LINENO: WARNING: complex.h: in the future, the compiler will take precedence" >&5
6915 echo "$as_me: WARNING: complex.h: in the future, the compiler will take precedence" >&2;}
6916     (
6917       cat <<\_ASBOX
6918 ## ------------------------------------------------------ ##
6919 ## Report this to the GNU Fortran Runtime Library lists.  ##
6920 ## ------------------------------------------------------ ##
6921 _ASBOX
6922     ) |
6923       sed "s/^/$as_me: WARNING:     /" >&2
6924     ;;
6925 esac
6926 echo "$as_me:$LINENO: checking for complex.h" >&5
6927 echo $ECHO_N "checking for complex.h... $ECHO_C" >&6
6928 if test "${ac_cv_header_complex_h+set}" = set; then
6929   echo $ECHO_N "(cached) $ECHO_C" >&6
6930 else
6931   ac_cv_header_complex_h=$ac_header_preproc
6932 fi
6933 echo "$as_me:$LINENO: result: $ac_cv_header_complex_h" >&5
6934 echo "${ECHO_T}$ac_cv_header_complex_h" >&6
6935
6936 fi
6937 if test $ac_cv_header_complex_h = yes; then
6938
6939 cat >>confdefs.h <<\_ACEOF
6940 #define HAVE_COMPLEX_H 1
6941 _ACEOF
6942
6943 fi
6944
6945
6946
6947
6948 inttype_headers=`echo inttypes.h sys/inttypes.h  | sed -e 's/,/ /g'`
6949
6950 acx_cv_header_stdint=stddef.h
6951 acx_cv_header_stdint_kind="(already complete)"
6952 for i in stdint.h $inttype_headers; do
6953   unset ac_cv_type_uintptr_t
6954   unset ac_cv_type_uintmax_t
6955   unset ac_cv_type_int_least32_t
6956   unset ac_cv_type_int_fast32_t
6957   unset ac_cv_type_uint64_t
6958   echo $ECHO_N "looking for a compliant stdint.h in $i, $ECHO_C" >&6
6959   echo "$as_me:$LINENO: checking for uintmax_t" >&5
6960 echo $ECHO_N "checking for uintmax_t... $ECHO_C" >&6
6961 if test "${ac_cv_type_uintmax_t+set}" = set; then
6962   echo $ECHO_N "(cached) $ECHO_C" >&6
6963 else
6964   cat >conftest.$ac_ext <<_ACEOF
6965 /* confdefs.h.  */
6966 _ACEOF
6967 cat confdefs.h >>conftest.$ac_ext
6968 cat >>conftest.$ac_ext <<_ACEOF
6969 /* end confdefs.h.  */
6970 #include <sys/types.h>
6971 #include <$i>
6972
6973 int
6974 main ()
6975 {
6976 if ((uintmax_t *) 0)
6977   return 0;
6978 if (sizeof (uintmax_t))
6979   return 0;
6980   ;
6981   return 0;
6982 }
6983 _ACEOF
6984 rm -f conftest.$ac_objext
6985 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6986   (eval $ac_compile) 2>conftest.er1
6987   ac_status=$?
6988   grep -v '^ *+' conftest.er1 >conftest.err
6989   rm -f conftest.er1
6990   cat conftest.err >&5
6991   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6992   (exit $ac_status); } &&
6993          { ac_try='test -z "$ac_c_werror_flag"
6994                          || test ! -s conftest.err'
6995   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6996   (eval $ac_try) 2>&5
6997   ac_status=$?
6998   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6999   (exit $ac_status); }; } &&
7000          { ac_try='test -s conftest.$ac_objext'
7001   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7002   (eval $ac_try) 2>&5
7003   ac_status=$?
7004   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7005   (exit $ac_status); }; }; then
7006   ac_cv_type_uintmax_t=yes
7007 else
7008   echo "$as_me: failed program was:" >&5
7009 sed 's/^/| /' conftest.$ac_ext >&5
7010
7011 ac_cv_type_uintmax_t=no
7012 fi
7013 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7014 fi
7015 echo "$as_me:$LINENO: result: $ac_cv_type_uintmax_t" >&5
7016 echo "${ECHO_T}$ac_cv_type_uintmax_t" >&6
7017 if test $ac_cv_type_uintmax_t = yes; then
7018   acx_cv_header_stdint=$i
7019 else
7020   continue
7021 fi
7022
7023   echo "$as_me:$LINENO: checking for uintptr_t" >&5
7024 echo $ECHO_N "checking for uintptr_t... $ECHO_C" >&6
7025 if test "${ac_cv_type_uintptr_t+set}" = set; then
7026   echo $ECHO_N "(cached) $ECHO_C" >&6
7027 else
7028   cat >conftest.$ac_ext <<_ACEOF
7029 /* confdefs.h.  */
7030 _ACEOF
7031 cat confdefs.h >>conftest.$ac_ext
7032 cat >>conftest.$ac_ext <<_ACEOF
7033 /* end confdefs.h.  */
7034 #include <sys/types.h>
7035 #include <$i>
7036
7037 int
7038 main ()
7039 {
7040 if ((uintptr_t *) 0)
7041   return 0;
7042 if (sizeof (uintptr_t))
7043   return 0;
7044   ;
7045   return 0;
7046 }
7047 _ACEOF
7048 rm -f conftest.$ac_objext
7049 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7050   (eval $ac_compile) 2>conftest.er1
7051   ac_status=$?
7052   grep -v '^ *+' conftest.er1 >conftest.err
7053   rm -f conftest.er1
7054   cat conftest.err >&5
7055   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7056   (exit $ac_status); } &&
7057          { ac_try='test -z "$ac_c_werror_flag"
7058                          || test ! -s conftest.err'
7059   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7060   (eval $ac_try) 2>&5
7061   ac_status=$?
7062   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7063   (exit $ac_status); }; } &&
7064          { ac_try='test -s conftest.$ac_objext'
7065   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7066   (eval $ac_try) 2>&5
7067   ac_status=$?
7068   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7069   (exit $ac_status); }; }; then
7070   ac_cv_type_uintptr_t=yes
7071 else
7072   echo "$as_me: failed program was:" >&5
7073 sed 's/^/| /' conftest.$ac_ext >&5
7074
7075 ac_cv_type_uintptr_t=no
7076 fi
7077 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7078 fi
7079 echo "$as_me:$LINENO: result: $ac_cv_type_uintptr_t" >&5
7080 echo "${ECHO_T}$ac_cv_type_uintptr_t" >&6
7081 if test $ac_cv_type_uintptr_t = yes; then
7082   :
7083 else
7084   acx_cv_header_stdint_kind="(mostly complete)"
7085 fi
7086
7087   echo "$as_me:$LINENO: checking for int_least32_t" >&5
7088 echo $ECHO_N "checking for int_least32_t... $ECHO_C" >&6
7089 if test "${ac_cv_type_int_least32_t+set}" = set; then
7090   echo $ECHO_N "(cached) $ECHO_C" >&6
7091 else
7092   cat >conftest.$ac_ext <<_ACEOF
7093 /* confdefs.h.  */
7094 _ACEOF
7095 cat confdefs.h >>conftest.$ac_ext
7096 cat >>conftest.$ac_ext <<_ACEOF
7097 /* end confdefs.h.  */
7098 #include <sys/types.h>
7099 #include <$i>
7100
7101 int
7102 main ()
7103 {
7104 if ((int_least32_t *) 0)
7105   return 0;
7106 if (sizeof (int_least32_t))
7107   return 0;
7108   ;
7109   return 0;
7110 }
7111 _ACEOF
7112 rm -f conftest.$ac_objext
7113 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7114   (eval $ac_compile) 2>conftest.er1
7115   ac_status=$?
7116   grep -v '^ *+' conftest.er1 >conftest.err
7117   rm -f conftest.er1
7118   cat conftest.err >&5
7119   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7120   (exit $ac_status); } &&
7121          { ac_try='test -z "$ac_c_werror_flag"
7122                          || test ! -s conftest.err'
7123   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7124   (eval $ac_try) 2>&5
7125   ac_status=$?
7126   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7127   (exit $ac_status); }; } &&
7128          { ac_try='test -s conftest.$ac_objext'
7129   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7130   (eval $ac_try) 2>&5
7131   ac_status=$?
7132   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7133   (exit $ac_status); }; }; then
7134   ac_cv_type_int_least32_t=yes
7135 else
7136   echo "$as_me: failed program was:" >&5
7137 sed 's/^/| /' conftest.$ac_ext >&5
7138
7139 ac_cv_type_int_least32_t=no
7140 fi
7141 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7142 fi
7143 echo "$as_me:$LINENO: result: $ac_cv_type_int_least32_t" >&5
7144 echo "${ECHO_T}$ac_cv_type_int_least32_t" >&6
7145 if test $ac_cv_type_int_least32_t = yes; then
7146   :
7147 else
7148   acx_cv_header_stdint_kind="(mostly complete)"
7149 fi
7150
7151   echo "$as_me:$LINENO: checking for int_fast32_t" >&5
7152 echo $ECHO_N "checking for int_fast32_t... $ECHO_C" >&6
7153 if test "${ac_cv_type_int_fast32_t+set}" = set; then
7154   echo $ECHO_N "(cached) $ECHO_C" >&6
7155 else
7156   cat >conftest.$ac_ext <<_ACEOF
7157 /* confdefs.h.  */
7158 _ACEOF
7159 cat confdefs.h >>conftest.$ac_ext
7160 cat >>conftest.$ac_ext <<_ACEOF
7161 /* end confdefs.h.  */
7162 #include <sys/types.h>
7163 #include <$i>
7164
7165 int
7166 main ()
7167 {
7168 if ((int_fast32_t *) 0)
7169   return 0;
7170 if (sizeof (int_fast32_t))
7171   return 0;
7172   ;
7173   return 0;
7174 }
7175 _ACEOF
7176 rm -f conftest.$ac_objext
7177 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7178   (eval $ac_compile) 2>conftest.er1
7179   ac_status=$?
7180   grep -v '^ *+' conftest.er1 >conftest.err
7181   rm -f conftest.er1
7182   cat conftest.err >&5
7183   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7184   (exit $ac_status); } &&
7185          { ac_try='test -z "$ac_c_werror_flag"
7186                          || test ! -s conftest.err'
7187   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7188   (eval $ac_try) 2>&5
7189   ac_status=$?
7190   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7191   (exit $ac_status); }; } &&
7192          { ac_try='test -s conftest.$ac_objext'
7193   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7194   (eval $ac_try) 2>&5
7195   ac_status=$?
7196   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7197   (exit $ac_status); }; }; then
7198   ac_cv_type_int_fast32_t=yes
7199 else
7200   echo "$as_me: failed program was:" >&5
7201 sed 's/^/| /' conftest.$ac_ext >&5
7202
7203 ac_cv_type_int_fast32_t=no
7204 fi
7205 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7206 fi
7207 echo "$as_me:$LINENO: result: $ac_cv_type_int_fast32_t" >&5
7208 echo "${ECHO_T}$ac_cv_type_int_fast32_t" >&6
7209 if test $ac_cv_type_int_fast32_t = yes; then
7210   :
7211 else
7212   acx_cv_header_stdint_kind="(mostly complete)"
7213 fi
7214
7215   echo "$as_me:$LINENO: checking for uint64_t" >&5
7216 echo $ECHO_N "checking for uint64_t... $ECHO_C" >&6
7217 if test "${ac_cv_type_uint64_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 ((uint64_t *) 0)
7233   return 0;
7234 if (sizeof (uint64_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_uint64_t=yes
7263 else
7264   echo "$as_me: failed program was:" >&5
7265 sed 's/^/| /' conftest.$ac_ext >&5
7266
7267 ac_cv_type_uint64_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_uint64_t" >&5
7272 echo "${ECHO_T}$ac_cv_type_uint64_t" >&6
7273 if test $ac_cv_type_uint64_t = yes; then
7274   :
7275 else
7276   acx_cv_header_stdint_kind="(lacks uint64_t)"
7277 fi
7278
7279   break
7280 done
7281 if test "$acx_cv_header_stdint" = stddef.h; then
7282   acx_cv_header_stdint_kind="(lacks uintmax_t)"
7283   for i in stdint.h $inttype_headers; do
7284     unset ac_cv_type_uintptr_t
7285     unset ac_cv_type_uint32_t
7286     unset ac_cv_type_uint64_t
7287     echo $ECHO_N "looking for an incomplete stdint.h in $i, $ECHO_C" >&6
7288     echo "$as_me:$LINENO: checking for uint32_t" >&5
7289 echo $ECHO_N "checking for uint32_t... $ECHO_C" >&6
7290 if test "${ac_cv_type_uint32_t+set}" = set; then
7291   echo $ECHO_N "(cached) $ECHO_C" >&6
7292 else
7293   cat >conftest.$ac_ext <<_ACEOF
7294 /* confdefs.h.  */
7295 _ACEOF
7296 cat confdefs.h >>conftest.$ac_ext
7297 cat >>conftest.$ac_ext <<_ACEOF
7298 /* end confdefs.h.  */
7299 #include <sys/types.h>
7300 #include <$i>
7301
7302 int
7303 main ()
7304 {
7305 if ((uint32_t *) 0)
7306   return 0;
7307 if (sizeof (uint32_t))
7308   return 0;
7309   ;
7310   return 0;
7311 }
7312 _ACEOF
7313 rm -f conftest.$ac_objext
7314 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7315   (eval $ac_compile) 2>conftest.er1
7316   ac_status=$?
7317   grep -v '^ *+' conftest.er1 >conftest.err
7318   rm -f conftest.er1
7319   cat conftest.err >&5
7320   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7321   (exit $ac_status); } &&
7322          { ac_try='test -z "$ac_c_werror_flag"
7323                          || test ! -s conftest.err'
7324   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7325   (eval $ac_try) 2>&5
7326   ac_status=$?
7327   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7328   (exit $ac_status); }; } &&
7329          { ac_try='test -s conftest.$ac_objext'
7330   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7331   (eval $ac_try) 2>&5
7332   ac_status=$?
7333   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7334   (exit $ac_status); }; }; then
7335   ac_cv_type_uint32_t=yes
7336 else
7337   echo "$as_me: failed program was:" >&5
7338 sed 's/^/| /' conftest.$ac_ext >&5
7339
7340 ac_cv_type_uint32_t=no
7341 fi
7342 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7343 fi
7344 echo "$as_me:$LINENO: result: $ac_cv_type_uint32_t" >&5
7345 echo "${ECHO_T}$ac_cv_type_uint32_t" >&6
7346 if test $ac_cv_type_uint32_t = yes; then
7347   acx_cv_header_stdint=$i
7348 else
7349   continue
7350 fi
7351
7352     echo "$as_me:$LINENO: checking for uint64_t" >&5
7353 echo $ECHO_N "checking for uint64_t... $ECHO_C" >&6
7354 if test "${ac_cv_type_uint64_t+set}" = set; then
7355   echo $ECHO_N "(cached) $ECHO_C" >&6
7356 else
7357   cat >conftest.$ac_ext <<_ACEOF
7358 /* confdefs.h.  */
7359 _ACEOF
7360 cat confdefs.h >>conftest.$ac_ext
7361 cat >>conftest.$ac_ext <<_ACEOF
7362 /* end confdefs.h.  */
7363 #include <sys/types.h>
7364 #include <$i>
7365
7366 int
7367 main ()
7368 {
7369 if ((uint64_t *) 0)
7370   return 0;
7371 if (sizeof (uint64_t))
7372   return 0;
7373   ;
7374   return 0;
7375 }
7376 _ACEOF
7377 rm -f conftest.$ac_objext
7378 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7379   (eval $ac_compile) 2>conftest.er1
7380   ac_status=$?
7381   grep -v '^ *+' conftest.er1 >conftest.err
7382   rm -f conftest.er1
7383   cat conftest.err >&5
7384   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7385   (exit $ac_status); } &&
7386          { ac_try='test -z "$ac_c_werror_flag"
7387                          || test ! -s conftest.err'
7388   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7389   (eval $ac_try) 2>&5
7390   ac_status=$?
7391   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7392   (exit $ac_status); }; } &&
7393          { ac_try='test -s conftest.$ac_objext'
7394   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7395   (eval $ac_try) 2>&5
7396   ac_status=$?
7397   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7398   (exit $ac_status); }; }; then
7399   ac_cv_type_uint64_t=yes
7400 else
7401   echo "$as_me: failed program was:" >&5
7402 sed 's/^/| /' conftest.$ac_ext >&5
7403
7404 ac_cv_type_uint64_t=no
7405 fi
7406 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7407 fi
7408 echo "$as_me:$LINENO: result: $ac_cv_type_uint64_t" >&5
7409 echo "${ECHO_T}$ac_cv_type_uint64_t" >&6
7410
7411     echo "$as_me:$LINENO: checking for uintptr_t" >&5
7412 echo $ECHO_N "checking for uintptr_t... $ECHO_C" >&6
7413 if test "${ac_cv_type_uintptr_t+set}" = set; then
7414   echo $ECHO_N "(cached) $ECHO_C" >&6
7415 else
7416   cat >conftest.$ac_ext <<_ACEOF
7417 /* confdefs.h.  */
7418 _ACEOF
7419 cat confdefs.h >>conftest.$ac_ext
7420 cat >>conftest.$ac_ext <<_ACEOF
7421 /* end confdefs.h.  */
7422 #include <sys/types.h>
7423 #include <$i>
7424
7425 int
7426 main ()
7427 {
7428 if ((uintptr_t *) 0)
7429   return 0;
7430 if (sizeof (uintptr_t))
7431   return 0;
7432   ;
7433   return 0;
7434 }
7435 _ACEOF
7436 rm -f conftest.$ac_objext
7437 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7438   (eval $ac_compile) 2>conftest.er1
7439   ac_status=$?
7440   grep -v '^ *+' conftest.er1 >conftest.err
7441   rm -f conftest.er1
7442   cat conftest.err >&5
7443   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7444   (exit $ac_status); } &&
7445          { ac_try='test -z "$ac_c_werror_flag"
7446                          || test ! -s conftest.err'
7447   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7448   (eval $ac_try) 2>&5
7449   ac_status=$?
7450   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7451   (exit $ac_status); }; } &&
7452          { ac_try='test -s conftest.$ac_objext'
7453   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7454   (eval $ac_try) 2>&5
7455   ac_status=$?
7456   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7457   (exit $ac_status); }; }; then
7458   ac_cv_type_uintptr_t=yes
7459 else
7460   echo "$as_me: failed program was:" >&5
7461 sed 's/^/| /' conftest.$ac_ext >&5
7462
7463 ac_cv_type_uintptr_t=no
7464 fi
7465 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7466 fi
7467 echo "$as_me:$LINENO: result: $ac_cv_type_uintptr_t" >&5
7468 echo "${ECHO_T}$ac_cv_type_uintptr_t" >&6
7469
7470     break
7471   done
7472 fi
7473 if test "$acx_cv_header_stdint" = stddef.h; then
7474   acx_cv_header_stdint_kind="(u_intXX_t style)"
7475   for i in sys/types.h $inttype_headers; do
7476     unset ac_cv_type_u_int32_t
7477     unset ac_cv_type_u_int64_t
7478     echo $ECHO_N "looking for u_intXX_t types in $i, $ECHO_C" >&6
7479     echo "$as_me:$LINENO: checking for u_int32_t" >&5
7480 echo $ECHO_N "checking for u_int32_t... $ECHO_C" >&6
7481 if test "${ac_cv_type_u_int32_t+set}" = set; then
7482   echo $ECHO_N "(cached) $ECHO_C" >&6
7483 else
7484   cat >conftest.$ac_ext <<_ACEOF
7485 /* confdefs.h.  */
7486 _ACEOF
7487 cat confdefs.h >>conftest.$ac_ext
7488 cat >>conftest.$ac_ext <<_ACEOF
7489 /* end confdefs.h.  */
7490 #include <sys/types.h>
7491 #include <$i>
7492
7493 int
7494 main ()
7495 {
7496 if ((u_int32_t *) 0)
7497   return 0;
7498 if (sizeof (u_int32_t))
7499   return 0;
7500   ;
7501   return 0;
7502 }
7503 _ACEOF
7504 rm -f conftest.$ac_objext
7505 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7506   (eval $ac_compile) 2>conftest.er1
7507   ac_status=$?
7508   grep -v '^ *+' conftest.er1 >conftest.err
7509   rm -f conftest.er1
7510   cat conftest.err >&5
7511   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7512   (exit $ac_status); } &&
7513          { ac_try='test -z "$ac_c_werror_flag"
7514                          || test ! -s conftest.err'
7515   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7516   (eval $ac_try) 2>&5
7517   ac_status=$?
7518   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7519   (exit $ac_status); }; } &&
7520          { ac_try='test -s conftest.$ac_objext'
7521   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7522   (eval $ac_try) 2>&5
7523   ac_status=$?
7524   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7525   (exit $ac_status); }; }; then
7526   ac_cv_type_u_int32_t=yes
7527 else
7528   echo "$as_me: failed program was:" >&5
7529 sed 's/^/| /' conftest.$ac_ext >&5
7530
7531 ac_cv_type_u_int32_t=no
7532 fi
7533 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7534 fi
7535 echo "$as_me:$LINENO: result: $ac_cv_type_u_int32_t" >&5
7536 echo "${ECHO_T}$ac_cv_type_u_int32_t" >&6
7537 if test $ac_cv_type_u_int32_t = yes; then
7538   acx_cv_header_stdint=$i
7539 else
7540   continue
7541 fi
7542
7543     echo "$as_me:$LINENO: checking for u_int64_t" >&5
7544 echo $ECHO_N "checking for u_int64_t... $ECHO_C" >&6
7545 if test "${ac_cv_type_u_int64_t+set}" = set; then
7546   echo $ECHO_N "(cached) $ECHO_C" >&6
7547 else
7548   cat >conftest.$ac_ext <<_ACEOF
7549 /* confdefs.h.  */
7550 _ACEOF
7551 cat confdefs.h >>conftest.$ac_ext
7552 cat >>conftest.$ac_ext <<_ACEOF
7553 /* end confdefs.h.  */
7554 #include <sys/types.h>
7555 #include <$i>
7556
7557 int
7558 main ()
7559 {
7560 if ((u_int64_t *) 0)
7561   return 0;
7562 if (sizeof (u_int64_t))
7563   return 0;
7564   ;
7565   return 0;
7566 }
7567 _ACEOF
7568 rm -f conftest.$ac_objext
7569 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7570   (eval $ac_compile) 2>conftest.er1
7571   ac_status=$?
7572   grep -v '^ *+' conftest.er1 >conftest.err
7573   rm -f conftest.er1
7574   cat conftest.err >&5
7575   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7576   (exit $ac_status); } &&
7577          { ac_try='test -z "$ac_c_werror_flag"
7578                          || test ! -s conftest.err'
7579   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7580   (eval $ac_try) 2>&5
7581   ac_status=$?
7582   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7583   (exit $ac_status); }; } &&
7584          { ac_try='test -s conftest.$ac_objext'
7585   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7586   (eval $ac_try) 2>&5
7587   ac_status=$?
7588   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7589   (exit $ac_status); }; }; then
7590   ac_cv_type_u_int64_t=yes
7591 else
7592   echo "$as_me: failed program was:" >&5
7593 sed 's/^/| /' conftest.$ac_ext >&5
7594
7595 ac_cv_type_u_int64_t=no
7596 fi
7597 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7598 fi
7599 echo "$as_me:$LINENO: result: $ac_cv_type_u_int64_t" >&5
7600 echo "${ECHO_T}$ac_cv_type_u_int64_t" >&6
7601
7602     break
7603   done
7604 fi
7605 if test "$acx_cv_header_stdint" = stddef.h; then
7606   acx_cv_header_stdint_kind="(using manual detection)"
7607 fi
7608
7609 test -z "$ac_cv_type_uintptr_t" && ac_cv_type_uintptr_t=no
7610 test -z "$ac_cv_type_uint64_t" && ac_cv_type_uint64_t=no
7611 test -z "$ac_cv_type_u_int64_t" && ac_cv_type_u_int64_t=no
7612 test -z "$ac_cv_type_int_least32_t" && ac_cv_type_int_least32_t=no
7613 test -z "$ac_cv_type_int_fast32_t" && ac_cv_type_int_fast32_t=no
7614
7615 # ----------------- Summarize what we found so far
7616
7617 echo "$as_me:$LINENO: checking what to include in gstdint.h" >&5
7618 echo $ECHO_N "checking what to include in gstdint.h... $ECHO_C" >&6
7619
7620 case `$as_basename gstdint.h ||
7621 $as_expr X/gstdint.h : '.*/\([^/][^/]*\)/*$' \| \
7622          Xgstdint.h : 'X\(//\)$' \| \
7623          Xgstdint.h : 'X\(/\)$' \| \
7624          .     : '\(.\)' 2>/dev/null ||
7625 echo X/gstdint.h |
7626     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
7627           /^X\/\(\/\/\)$/{ s//\1/; q; }
7628           /^X\/\(\/\).*/{ s//\1/; q; }
7629           s/.*/./; q'` in
7630   stdint.h) { echo "$as_me:$LINENO: WARNING: are you sure you want it there?" >&5
7631 echo "$as_me: WARNING: are you sure you want it there?" >&2;} ;;
7632   inttypes.h) { echo "$as_me:$LINENO: WARNING: are you sure you want it there?" >&5
7633 echo "$as_me: WARNING: are you sure you want it there?" >&2;} ;;
7634   *) ;;
7635 esac
7636
7637 echo "$as_me:$LINENO: result: $acx_cv_header_stdint $acx_cv_header_stdint_kind" >&5
7638 echo "${ECHO_T}$acx_cv_header_stdint $acx_cv_header_stdint_kind" >&6
7639
7640 # ----------------- done included file, check C basic types --------
7641
7642 # Lacking an uintptr_t?  Test size of void *
7643 case "$acx_cv_header_stdint:$ac_cv_type_uintptr_t" in
7644   stddef.h:* | *:no) echo "$as_me:$LINENO: checking for void *" >&5
7645 echo $ECHO_N "checking for void *... $ECHO_C" >&6
7646 if test "${ac_cv_type_void_p+set}" = set; then
7647   echo $ECHO_N "(cached) $ECHO_C" >&6
7648 else
7649   cat >conftest.$ac_ext <<_ACEOF
7650 /* confdefs.h.  */
7651 _ACEOF
7652 cat confdefs.h >>conftest.$ac_ext
7653 cat >>conftest.$ac_ext <<_ACEOF
7654 /* end confdefs.h.  */
7655 $ac_includes_default
7656 int
7657 main ()
7658 {
7659 if ((void * *) 0)
7660   return 0;
7661 if (sizeof (void *))
7662   return 0;
7663   ;
7664   return 0;
7665 }
7666 _ACEOF
7667 rm -f conftest.$ac_objext
7668 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7669   (eval $ac_compile) 2>conftest.er1
7670   ac_status=$?
7671   grep -v '^ *+' conftest.er1 >conftest.err
7672   rm -f conftest.er1
7673   cat conftest.err >&5
7674   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7675   (exit $ac_status); } &&
7676          { ac_try='test -z "$ac_c_werror_flag"
7677                          || test ! -s conftest.err'
7678   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7679   (eval $ac_try) 2>&5
7680   ac_status=$?
7681   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7682   (exit $ac_status); }; } &&
7683          { ac_try='test -s conftest.$ac_objext'
7684   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7685   (eval $ac_try) 2>&5
7686   ac_status=$?
7687   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7688   (exit $ac_status); }; }; then
7689   ac_cv_type_void_p=yes
7690 else
7691   echo "$as_me: failed program was:" >&5
7692 sed 's/^/| /' conftest.$ac_ext >&5
7693
7694 ac_cv_type_void_p=no
7695 fi
7696 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7697 fi
7698 echo "$as_me:$LINENO: result: $ac_cv_type_void_p" >&5
7699 echo "${ECHO_T}$ac_cv_type_void_p" >&6
7700
7701 echo "$as_me:$LINENO: checking size of void *" >&5
7702 echo $ECHO_N "checking size of void *... $ECHO_C" >&6
7703 if test "${ac_cv_sizeof_void_p+set}" = set; then
7704   echo $ECHO_N "(cached) $ECHO_C" >&6
7705 else
7706   if test "$ac_cv_type_void_p" = yes; then
7707   # The cast to unsigned long works around a bug in the HP C Compiler
7708   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
7709   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
7710   # This bug is HP SR number 8606223364.
7711   if test "$cross_compiling" = yes; then
7712   # Depending upon the size, compute the lo and hi bounds.
7713 cat >conftest.$ac_ext <<_ACEOF
7714 /* confdefs.h.  */
7715 _ACEOF
7716 cat confdefs.h >>conftest.$ac_ext
7717 cat >>conftest.$ac_ext <<_ACEOF
7718 /* end confdefs.h.  */
7719 $ac_includes_default
7720 int
7721 main ()
7722 {
7723 static int test_array [1 - 2 * !(((long) (sizeof (void *))) >= 0)];
7724 test_array [0] = 0
7725
7726   ;
7727   return 0;
7728 }
7729 _ACEOF
7730 rm -f conftest.$ac_objext
7731 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7732   (eval $ac_compile) 2>conftest.er1
7733   ac_status=$?
7734   grep -v '^ *+' conftest.er1 >conftest.err
7735   rm -f conftest.er1
7736   cat conftest.err >&5
7737   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7738   (exit $ac_status); } &&
7739          { ac_try='test -z "$ac_c_werror_flag"
7740                          || test ! -s conftest.err'
7741   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7742   (eval $ac_try) 2>&5
7743   ac_status=$?
7744   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7745   (exit $ac_status); }; } &&
7746          { ac_try='test -s conftest.$ac_objext'
7747   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7748   (eval $ac_try) 2>&5
7749   ac_status=$?
7750   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7751   (exit $ac_status); }; }; then
7752   ac_lo=0 ac_mid=0
7753   while :; do
7754     cat >conftest.$ac_ext <<_ACEOF
7755 /* confdefs.h.  */
7756 _ACEOF
7757 cat confdefs.h >>conftest.$ac_ext
7758 cat >>conftest.$ac_ext <<_ACEOF
7759 /* end confdefs.h.  */
7760 $ac_includes_default
7761 int
7762 main ()
7763 {
7764 static int test_array [1 - 2 * !(((long) (sizeof (void *))) <= $ac_mid)];
7765 test_array [0] = 0
7766
7767   ;
7768   return 0;
7769 }
7770 _ACEOF
7771 rm -f conftest.$ac_objext
7772 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7773   (eval $ac_compile) 2>conftest.er1
7774   ac_status=$?
7775   grep -v '^ *+' conftest.er1 >conftest.err
7776   rm -f conftest.er1
7777   cat conftest.err >&5
7778   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7779   (exit $ac_status); } &&
7780          { ac_try='test -z "$ac_c_werror_flag"
7781                          || test ! -s conftest.err'
7782   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7783   (eval $ac_try) 2>&5
7784   ac_status=$?
7785   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7786   (exit $ac_status); }; } &&
7787          { ac_try='test -s conftest.$ac_objext'
7788   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7789   (eval $ac_try) 2>&5
7790   ac_status=$?
7791   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7792   (exit $ac_status); }; }; then
7793   ac_hi=$ac_mid; break
7794 else
7795   echo "$as_me: failed program was:" >&5
7796 sed 's/^/| /' conftest.$ac_ext >&5
7797
7798 ac_lo=`expr $ac_mid + 1`
7799                     if test $ac_lo -le $ac_mid; then
7800                       ac_lo= ac_hi=
7801                       break
7802                     fi
7803                     ac_mid=`expr 2 '*' $ac_mid + 1`
7804 fi
7805 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7806   done
7807 else
7808   echo "$as_me: failed program was:" >&5
7809 sed 's/^/| /' conftest.$ac_ext >&5
7810
7811 cat >conftest.$ac_ext <<_ACEOF
7812 /* confdefs.h.  */
7813 _ACEOF
7814 cat confdefs.h >>conftest.$ac_ext
7815 cat >>conftest.$ac_ext <<_ACEOF
7816 /* end confdefs.h.  */
7817 $ac_includes_default
7818 int
7819 main ()
7820 {
7821 static int test_array [1 - 2 * !(((long) (sizeof (void *))) < 0)];
7822 test_array [0] = 0
7823
7824   ;
7825   return 0;
7826 }
7827 _ACEOF
7828 rm -f conftest.$ac_objext
7829 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7830   (eval $ac_compile) 2>conftest.er1
7831   ac_status=$?
7832   grep -v '^ *+' conftest.er1 >conftest.err
7833   rm -f conftest.er1
7834   cat conftest.err >&5
7835   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7836   (exit $ac_status); } &&
7837          { ac_try='test -z "$ac_c_werror_flag"
7838                          || test ! -s conftest.err'
7839   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7840   (eval $ac_try) 2>&5
7841   ac_status=$?
7842   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7843   (exit $ac_status); }; } &&
7844          { ac_try='test -s conftest.$ac_objext'
7845   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7846   (eval $ac_try) 2>&5
7847   ac_status=$?
7848   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7849   (exit $ac_status); }; }; then
7850   ac_hi=-1 ac_mid=-1
7851   while :; do
7852     cat >conftest.$ac_ext <<_ACEOF
7853 /* confdefs.h.  */
7854 _ACEOF
7855 cat confdefs.h >>conftest.$ac_ext
7856 cat >>conftest.$ac_ext <<_ACEOF
7857 /* end confdefs.h.  */
7858 $ac_includes_default
7859 int
7860 main ()
7861 {
7862 static int test_array [1 - 2 * !(((long) (sizeof (void *))) >= $ac_mid)];
7863 test_array [0] = 0
7864
7865   ;
7866   return 0;
7867 }
7868 _ACEOF
7869 rm -f conftest.$ac_objext
7870 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7871   (eval $ac_compile) 2>conftest.er1
7872   ac_status=$?
7873   grep -v '^ *+' conftest.er1 >conftest.err
7874   rm -f conftest.er1
7875   cat conftest.err >&5
7876   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7877   (exit $ac_status); } &&
7878          { ac_try='test -z "$ac_c_werror_flag"
7879                          || test ! -s conftest.err'
7880   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7881   (eval $ac_try) 2>&5
7882   ac_status=$?
7883   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7884   (exit $ac_status); }; } &&
7885          { ac_try='test -s conftest.$ac_objext'
7886   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7887   (eval $ac_try) 2>&5
7888   ac_status=$?
7889   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7890   (exit $ac_status); }; }; then
7891   ac_lo=$ac_mid; break
7892 else
7893   echo "$as_me: failed program was:" >&5
7894 sed 's/^/| /' conftest.$ac_ext >&5
7895
7896 ac_hi=`expr '(' $ac_mid ')' - 1`
7897                        if test $ac_mid -le $ac_hi; then
7898                          ac_lo= ac_hi=
7899                          break
7900                        fi
7901                        ac_mid=`expr 2 '*' $ac_mid`
7902 fi
7903 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7904   done
7905 else
7906   echo "$as_me: failed program was:" >&5
7907 sed 's/^/| /' conftest.$ac_ext >&5
7908
7909 ac_lo= ac_hi=
7910 fi
7911 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7912 fi
7913 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7914 # Binary search between lo and hi bounds.
7915 while test "x$ac_lo" != "x$ac_hi"; do
7916   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
7917   cat >conftest.$ac_ext <<_ACEOF
7918 /* confdefs.h.  */
7919 _ACEOF
7920 cat confdefs.h >>conftest.$ac_ext
7921 cat >>conftest.$ac_ext <<_ACEOF
7922 /* end confdefs.h.  */
7923 $ac_includes_default
7924 int
7925 main ()
7926 {
7927 static int test_array [1 - 2 * !(((long) (sizeof (void *))) <= $ac_mid)];
7928 test_array [0] = 0
7929
7930   ;
7931   return 0;
7932 }
7933 _ACEOF
7934 rm -f conftest.$ac_objext
7935 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7936   (eval $ac_compile) 2>conftest.er1
7937   ac_status=$?
7938   grep -v '^ *+' conftest.er1 >conftest.err
7939   rm -f conftest.er1
7940   cat conftest.err >&5
7941   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7942   (exit $ac_status); } &&
7943          { ac_try='test -z "$ac_c_werror_flag"
7944                          || test ! -s conftest.err'
7945   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7946   (eval $ac_try) 2>&5
7947   ac_status=$?
7948   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7949   (exit $ac_status); }; } &&
7950          { ac_try='test -s conftest.$ac_objext'
7951   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7952   (eval $ac_try) 2>&5
7953   ac_status=$?
7954   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7955   (exit $ac_status); }; }; then
7956   ac_hi=$ac_mid
7957 else
7958   echo "$as_me: failed program was:" >&5
7959 sed 's/^/| /' conftest.$ac_ext >&5
7960
7961 ac_lo=`expr '(' $ac_mid ')' + 1`
7962 fi
7963 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7964 done
7965 case $ac_lo in
7966 ?*) ac_cv_sizeof_void_p=$ac_lo;;
7967 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (void *), 77
7968 See \`config.log' for more details." >&5
7969 echo "$as_me: error: cannot compute sizeof (void *), 77
7970 See \`config.log' for more details." >&2;}
7971    { (exit 1); exit 1; }; } ;;
7972 esac
7973 else
7974   if test "$cross_compiling" = yes; then
7975   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
7976 See \`config.log' for more details." >&5
7977 echo "$as_me: error: cannot run test program while cross compiling
7978 See \`config.log' for more details." >&2;}
7979    { (exit 1); exit 1; }; }
7980 else
7981   cat >conftest.$ac_ext <<_ACEOF
7982 /* confdefs.h.  */
7983 _ACEOF
7984 cat confdefs.h >>conftest.$ac_ext
7985 cat >>conftest.$ac_ext <<_ACEOF
7986 /* end confdefs.h.  */
7987 $ac_includes_default
7988 long longval () { return (long) (sizeof (void *)); }
7989 unsigned long ulongval () { return (long) (sizeof (void *)); }
7990 #include <stdio.h>
7991 #include <stdlib.h>
7992 int
7993 main ()
7994 {
7995
7996   FILE *f = fopen ("conftest.val", "w");
7997   if (! f)
7998     exit (1);
7999   if (((long) (sizeof (void *))) < 0)
8000     {
8001       long i = longval ();
8002       if (i != ((long) (sizeof (void *))))
8003         exit (1);
8004       fprintf (f, "%ld\n", i);
8005     }
8006   else
8007     {
8008       unsigned long i = ulongval ();
8009       if (i != ((long) (sizeof (void *))))
8010         exit (1);
8011       fprintf (f, "%lu\n", i);
8012     }
8013   exit (ferror (f) || fclose (f) != 0);
8014
8015   ;
8016   return 0;
8017 }
8018 _ACEOF
8019 rm -f conftest$ac_exeext
8020 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8021   (eval $ac_link) 2>&5
8022   ac_status=$?
8023   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8024   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8025   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8026   (eval $ac_try) 2>&5
8027   ac_status=$?
8028   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8029   (exit $ac_status); }; }; then
8030   ac_cv_sizeof_void_p=`cat conftest.val`
8031 else
8032   echo "$as_me: program exited with status $ac_status" >&5
8033 echo "$as_me: failed program was:" >&5
8034 sed 's/^/| /' conftest.$ac_ext >&5
8035
8036 ( exit $ac_status )
8037 { { echo "$as_me:$LINENO: error: cannot compute sizeof (void *), 77
8038 See \`config.log' for more details." >&5
8039 echo "$as_me: error: cannot compute sizeof (void *), 77
8040 See \`config.log' for more details." >&2;}
8041    { (exit 1); exit 1; }; }
8042 fi
8043 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8044 fi
8045 fi
8046 rm -f conftest.val
8047 else
8048   ac_cv_sizeof_void_p=0
8049 fi
8050 fi
8051 echo "$as_me:$LINENO: result: $ac_cv_sizeof_void_p" >&5
8052 echo "${ECHO_T}$ac_cv_sizeof_void_p" >&6
8053 cat >>confdefs.h <<_ACEOF
8054 #define SIZEOF_VOID_P $ac_cv_sizeof_void_p
8055 _ACEOF
8056
8057  ;;
8058 esac
8059
8060 # Lacking an uint64_t?  Test size of long
8061 case "$acx_cv_header_stdint:$ac_cv_type_uint64_t:$ac_cv_type_u_int64_t" in
8062   stddef.h:*:* | *:no:no) echo "$as_me:$LINENO: checking for long" >&5
8063 echo $ECHO_N "checking for long... $ECHO_C" >&6
8064 if test "${ac_cv_type_long+set}" = set; then
8065   echo $ECHO_N "(cached) $ECHO_C" >&6
8066 else
8067   cat >conftest.$ac_ext <<_ACEOF
8068 /* confdefs.h.  */
8069 _ACEOF
8070 cat confdefs.h >>conftest.$ac_ext
8071 cat >>conftest.$ac_ext <<_ACEOF
8072 /* end confdefs.h.  */
8073 $ac_includes_default
8074 int
8075 main ()
8076 {
8077 if ((long *) 0)
8078   return 0;
8079 if (sizeof (long))
8080   return 0;
8081   ;
8082   return 0;
8083 }
8084 _ACEOF
8085 rm -f conftest.$ac_objext
8086 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8087   (eval $ac_compile) 2>conftest.er1
8088   ac_status=$?
8089   grep -v '^ *+' conftest.er1 >conftest.err
8090   rm -f conftest.er1
8091   cat conftest.err >&5
8092   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8093   (exit $ac_status); } &&
8094          { ac_try='test -z "$ac_c_werror_flag"
8095                          || test ! -s conftest.err'
8096   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8097   (eval $ac_try) 2>&5
8098   ac_status=$?
8099   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8100   (exit $ac_status); }; } &&
8101          { ac_try='test -s conftest.$ac_objext'
8102   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8103   (eval $ac_try) 2>&5
8104   ac_status=$?
8105   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8106   (exit $ac_status); }; }; then
8107   ac_cv_type_long=yes
8108 else
8109   echo "$as_me: failed program was:" >&5
8110 sed 's/^/| /' conftest.$ac_ext >&5
8111
8112 ac_cv_type_long=no
8113 fi
8114 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8115 fi
8116 echo "$as_me:$LINENO: result: $ac_cv_type_long" >&5
8117 echo "${ECHO_T}$ac_cv_type_long" >&6
8118
8119 echo "$as_me:$LINENO: checking size of long" >&5
8120 echo $ECHO_N "checking size of long... $ECHO_C" >&6
8121 if test "${ac_cv_sizeof_long+set}" = set; then
8122   echo $ECHO_N "(cached) $ECHO_C" >&6
8123 else
8124   if test "$ac_cv_type_long" = yes; then
8125   # The cast to unsigned long works around a bug in the HP C Compiler
8126   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
8127   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
8128   # This bug is HP SR number 8606223364.
8129   if test "$cross_compiling" = yes; then
8130   # Depending upon the size, compute the lo and hi bounds.
8131 cat >conftest.$ac_ext <<_ACEOF
8132 /* confdefs.h.  */
8133 _ACEOF
8134 cat confdefs.h >>conftest.$ac_ext
8135 cat >>conftest.$ac_ext <<_ACEOF
8136 /* end confdefs.h.  */
8137 $ac_includes_default
8138 int
8139 main ()
8140 {
8141 static int test_array [1 - 2 * !(((long) (sizeof (long))) >= 0)];
8142 test_array [0] = 0
8143
8144   ;
8145   return 0;
8146 }
8147 _ACEOF
8148 rm -f conftest.$ac_objext
8149 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8150   (eval $ac_compile) 2>conftest.er1
8151   ac_status=$?
8152   grep -v '^ *+' conftest.er1 >conftest.err
8153   rm -f conftest.er1
8154   cat conftest.err >&5
8155   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8156   (exit $ac_status); } &&
8157          { ac_try='test -z "$ac_c_werror_flag"
8158                          || test ! -s conftest.err'
8159   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8160   (eval $ac_try) 2>&5
8161   ac_status=$?
8162   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8163   (exit $ac_status); }; } &&
8164          { ac_try='test -s conftest.$ac_objext'
8165   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8166   (eval $ac_try) 2>&5
8167   ac_status=$?
8168   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8169   (exit $ac_status); }; }; then
8170   ac_lo=0 ac_mid=0
8171   while :; do
8172     cat >conftest.$ac_ext <<_ACEOF
8173 /* confdefs.h.  */
8174 _ACEOF
8175 cat confdefs.h >>conftest.$ac_ext
8176 cat >>conftest.$ac_ext <<_ACEOF
8177 /* end confdefs.h.  */
8178 $ac_includes_default
8179 int
8180 main ()
8181 {
8182 static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];
8183 test_array [0] = 0
8184
8185   ;
8186   return 0;
8187 }
8188 _ACEOF
8189 rm -f conftest.$ac_objext
8190 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8191   (eval $ac_compile) 2>conftest.er1
8192   ac_status=$?
8193   grep -v '^ *+' conftest.er1 >conftest.err
8194   rm -f conftest.er1
8195   cat conftest.err >&5
8196   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8197   (exit $ac_status); } &&
8198          { ac_try='test -z "$ac_c_werror_flag"
8199                          || test ! -s conftest.err'
8200   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8201   (eval $ac_try) 2>&5
8202   ac_status=$?
8203   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8204   (exit $ac_status); }; } &&
8205          { ac_try='test -s conftest.$ac_objext'
8206   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8207   (eval $ac_try) 2>&5
8208   ac_status=$?
8209   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8210   (exit $ac_status); }; }; then
8211   ac_hi=$ac_mid; break
8212 else
8213   echo "$as_me: failed program was:" >&5
8214 sed 's/^/| /' conftest.$ac_ext >&5
8215
8216 ac_lo=`expr $ac_mid + 1`
8217                     if test $ac_lo -le $ac_mid; then
8218                       ac_lo= ac_hi=
8219                       break
8220                     fi
8221                     ac_mid=`expr 2 '*' $ac_mid + 1`
8222 fi
8223 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8224   done
8225 else
8226   echo "$as_me: failed program was:" >&5
8227 sed 's/^/| /' conftest.$ac_ext >&5
8228
8229 cat >conftest.$ac_ext <<_ACEOF
8230 /* confdefs.h.  */
8231 _ACEOF
8232 cat confdefs.h >>conftest.$ac_ext
8233 cat >>conftest.$ac_ext <<_ACEOF
8234 /* end confdefs.h.  */
8235 $ac_includes_default
8236 int
8237 main ()
8238 {
8239 static int test_array [1 - 2 * !(((long) (sizeof (long))) < 0)];
8240 test_array [0] = 0
8241
8242   ;
8243   return 0;
8244 }
8245 _ACEOF
8246 rm -f conftest.$ac_objext
8247 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8248   (eval $ac_compile) 2>conftest.er1
8249   ac_status=$?
8250   grep -v '^ *+' conftest.er1 >conftest.err
8251   rm -f conftest.er1
8252   cat conftest.err >&5
8253   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8254   (exit $ac_status); } &&
8255          { ac_try='test -z "$ac_c_werror_flag"
8256                          || test ! -s conftest.err'
8257   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8258   (eval $ac_try) 2>&5
8259   ac_status=$?
8260   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8261   (exit $ac_status); }; } &&
8262          { ac_try='test -s conftest.$ac_objext'
8263   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8264   (eval $ac_try) 2>&5
8265   ac_status=$?
8266   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8267   (exit $ac_status); }; }; then
8268   ac_hi=-1 ac_mid=-1
8269   while :; do
8270     cat >conftest.$ac_ext <<_ACEOF
8271 /* confdefs.h.  */
8272 _ACEOF
8273 cat confdefs.h >>conftest.$ac_ext
8274 cat >>conftest.$ac_ext <<_ACEOF
8275 /* end confdefs.h.  */
8276 $ac_includes_default
8277 int
8278 main ()
8279 {
8280 static int test_array [1 - 2 * !(((long) (sizeof (long))) >= $ac_mid)];
8281 test_array [0] = 0
8282
8283   ;
8284   return 0;
8285 }
8286 _ACEOF
8287 rm -f conftest.$ac_objext
8288 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8289   (eval $ac_compile) 2>conftest.er1
8290   ac_status=$?
8291   grep -v '^ *+' conftest.er1 >conftest.err
8292   rm -f conftest.er1
8293   cat conftest.err >&5
8294   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8295   (exit $ac_status); } &&
8296          { ac_try='test -z "$ac_c_werror_flag"
8297                          || test ! -s conftest.err'
8298   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8299   (eval $ac_try) 2>&5
8300   ac_status=$?
8301   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8302   (exit $ac_status); }; } &&
8303          { ac_try='test -s conftest.$ac_objext'
8304   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8305   (eval $ac_try) 2>&5
8306   ac_status=$?
8307   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8308   (exit $ac_status); }; }; then
8309   ac_lo=$ac_mid; break
8310 else
8311   echo "$as_me: failed program was:" >&5
8312 sed 's/^/| /' conftest.$ac_ext >&5
8313
8314 ac_hi=`expr '(' $ac_mid ')' - 1`
8315                        if test $ac_mid -le $ac_hi; then
8316                          ac_lo= ac_hi=
8317                          break
8318                        fi
8319                        ac_mid=`expr 2 '*' $ac_mid`
8320 fi
8321 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8322   done
8323 else
8324   echo "$as_me: failed program was:" >&5
8325 sed 's/^/| /' conftest.$ac_ext >&5
8326
8327 ac_lo= ac_hi=
8328 fi
8329 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8330 fi
8331 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8332 # Binary search between lo and hi bounds.
8333 while test "x$ac_lo" != "x$ac_hi"; do
8334   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
8335   cat >conftest.$ac_ext <<_ACEOF
8336 /* confdefs.h.  */
8337 _ACEOF
8338 cat confdefs.h >>conftest.$ac_ext
8339 cat >>conftest.$ac_ext <<_ACEOF
8340 /* end confdefs.h.  */
8341 $ac_includes_default
8342 int
8343 main ()
8344 {
8345 static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];
8346 test_array [0] = 0
8347
8348   ;
8349   return 0;
8350 }
8351 _ACEOF
8352 rm -f conftest.$ac_objext
8353 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8354   (eval $ac_compile) 2>conftest.er1
8355   ac_status=$?
8356   grep -v '^ *+' conftest.er1 >conftest.err
8357   rm -f conftest.er1
8358   cat conftest.err >&5
8359   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8360   (exit $ac_status); } &&
8361          { ac_try='test -z "$ac_c_werror_flag"
8362                          || test ! -s conftest.err'
8363   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8364   (eval $ac_try) 2>&5
8365   ac_status=$?
8366   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8367   (exit $ac_status); }; } &&
8368          { ac_try='test -s conftest.$ac_objext'
8369   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8370   (eval $ac_try) 2>&5
8371   ac_status=$?
8372   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8373   (exit $ac_status); }; }; then
8374   ac_hi=$ac_mid
8375 else
8376   echo "$as_me: failed program was:" >&5
8377 sed 's/^/| /' conftest.$ac_ext >&5
8378
8379 ac_lo=`expr '(' $ac_mid ')' + 1`
8380 fi
8381 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8382 done
8383 case $ac_lo in
8384 ?*) ac_cv_sizeof_long=$ac_lo;;
8385 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77
8386 See \`config.log' for more details." >&5
8387 echo "$as_me: error: cannot compute sizeof (long), 77
8388 See \`config.log' for more details." >&2;}
8389    { (exit 1); exit 1; }; } ;;
8390 esac
8391 else
8392   if test "$cross_compiling" = yes; then
8393   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
8394 See \`config.log' for more details." >&5
8395 echo "$as_me: error: cannot run test program while cross compiling
8396 See \`config.log' for more details." >&2;}
8397    { (exit 1); exit 1; }; }
8398 else
8399   cat >conftest.$ac_ext <<_ACEOF
8400 /* confdefs.h.  */
8401 _ACEOF
8402 cat confdefs.h >>conftest.$ac_ext
8403 cat >>conftest.$ac_ext <<_ACEOF
8404 /* end confdefs.h.  */
8405 $ac_includes_default
8406 long longval () { return (long) (sizeof (long)); }
8407 unsigned long ulongval () { return (long) (sizeof (long)); }
8408 #include <stdio.h>
8409 #include <stdlib.h>
8410 int
8411 main ()
8412 {
8413
8414   FILE *f = fopen ("conftest.val", "w");
8415   if (! f)
8416     exit (1);
8417   if (((long) (sizeof (long))) < 0)
8418     {
8419       long i = longval ();
8420       if (i != ((long) (sizeof (long))))
8421         exit (1);
8422       fprintf (f, "%ld\n", i);
8423     }
8424   else
8425     {
8426       unsigned long i = ulongval ();
8427       if (i != ((long) (sizeof (long))))
8428         exit (1);
8429       fprintf (f, "%lu\n", i);
8430     }
8431   exit (ferror (f) || fclose (f) != 0);
8432
8433   ;
8434   return 0;
8435 }
8436 _ACEOF
8437 rm -f conftest$ac_exeext
8438 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8439   (eval $ac_link) 2>&5
8440   ac_status=$?
8441   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8442   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8443   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8444   (eval $ac_try) 2>&5
8445   ac_status=$?
8446   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8447   (exit $ac_status); }; }; then
8448   ac_cv_sizeof_long=`cat conftest.val`
8449 else
8450   echo "$as_me: program exited with status $ac_status" >&5
8451 echo "$as_me: failed program was:" >&5
8452 sed 's/^/| /' conftest.$ac_ext >&5
8453
8454 ( exit $ac_status )
8455 { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77
8456 See \`config.log' for more details." >&5
8457 echo "$as_me: error: cannot compute sizeof (long), 77
8458 See \`config.log' for more details." >&2;}
8459    { (exit 1); exit 1; }; }
8460 fi
8461 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8462 fi
8463 fi
8464 rm -f conftest.val
8465 else
8466   ac_cv_sizeof_long=0
8467 fi
8468 fi
8469 echo "$as_me:$LINENO: result: $ac_cv_sizeof_long" >&5
8470 echo "${ECHO_T}$ac_cv_sizeof_long" >&6
8471 cat >>confdefs.h <<_ACEOF
8472 #define SIZEOF_LONG $ac_cv_sizeof_long
8473 _ACEOF
8474
8475  ;;
8476 esac
8477
8478 if test $acx_cv_header_stdint = stddef.h; then
8479   # Lacking a good header?  Test size of everything and deduce all types.
8480   echo "$as_me:$LINENO: checking for int" >&5
8481 echo $ECHO_N "checking for int... $ECHO_C" >&6
8482 if test "${ac_cv_type_int+set}" = set; then
8483   echo $ECHO_N "(cached) $ECHO_C" >&6
8484 else
8485   cat >conftest.$ac_ext <<_ACEOF
8486 /* confdefs.h.  */
8487 _ACEOF
8488 cat confdefs.h >>conftest.$ac_ext
8489 cat >>conftest.$ac_ext <<_ACEOF
8490 /* end confdefs.h.  */
8491 $ac_includes_default
8492 int
8493 main ()
8494 {
8495 if ((int *) 0)
8496   return 0;
8497 if (sizeof (int))
8498   return 0;
8499   ;
8500   return 0;
8501 }
8502 _ACEOF
8503 rm -f conftest.$ac_objext
8504 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8505   (eval $ac_compile) 2>conftest.er1
8506   ac_status=$?
8507   grep -v '^ *+' conftest.er1 >conftest.err
8508   rm -f conftest.er1
8509   cat conftest.err >&5
8510   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8511   (exit $ac_status); } &&
8512          { ac_try='test -z "$ac_c_werror_flag"
8513                          || test ! -s conftest.err'
8514   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8515   (eval $ac_try) 2>&5
8516   ac_status=$?
8517   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8518   (exit $ac_status); }; } &&
8519          { ac_try='test -s conftest.$ac_objext'
8520   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8521   (eval $ac_try) 2>&5
8522   ac_status=$?
8523   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8524   (exit $ac_status); }; }; then
8525   ac_cv_type_int=yes
8526 else
8527   echo "$as_me: failed program was:" >&5
8528 sed 's/^/| /' conftest.$ac_ext >&5
8529
8530 ac_cv_type_int=no
8531 fi
8532 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8533 fi
8534 echo "$as_me:$LINENO: result: $ac_cv_type_int" >&5
8535 echo "${ECHO_T}$ac_cv_type_int" >&6
8536
8537 echo "$as_me:$LINENO: checking size of int" >&5
8538 echo $ECHO_N "checking size of int... $ECHO_C" >&6
8539 if test "${ac_cv_sizeof_int+set}" = set; then
8540   echo $ECHO_N "(cached) $ECHO_C" >&6
8541 else
8542   if test "$ac_cv_type_int" = yes; then
8543   # The cast to unsigned long works around a bug in the HP C Compiler
8544   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
8545   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
8546   # This bug is HP SR number 8606223364.
8547   if test "$cross_compiling" = yes; then
8548   # Depending upon the size, compute the lo and hi bounds.
8549 cat >conftest.$ac_ext <<_ACEOF
8550 /* confdefs.h.  */
8551 _ACEOF
8552 cat confdefs.h >>conftest.$ac_ext
8553 cat >>conftest.$ac_ext <<_ACEOF
8554 /* end confdefs.h.  */
8555 $ac_includes_default
8556 int
8557 main ()
8558 {
8559 static int test_array [1 - 2 * !(((long) (sizeof (int))) >= 0)];
8560 test_array [0] = 0
8561
8562   ;
8563   return 0;
8564 }
8565 _ACEOF
8566 rm -f conftest.$ac_objext
8567 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8568   (eval $ac_compile) 2>conftest.er1
8569   ac_status=$?
8570   grep -v '^ *+' conftest.er1 >conftest.err
8571   rm -f conftest.er1
8572   cat conftest.err >&5
8573   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8574   (exit $ac_status); } &&
8575          { ac_try='test -z "$ac_c_werror_flag"
8576                          || test ! -s conftest.err'
8577   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8578   (eval $ac_try) 2>&5
8579   ac_status=$?
8580   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8581   (exit $ac_status); }; } &&
8582          { ac_try='test -s conftest.$ac_objext'
8583   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8584   (eval $ac_try) 2>&5
8585   ac_status=$?
8586   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8587   (exit $ac_status); }; }; then
8588   ac_lo=0 ac_mid=0
8589   while :; do
8590     cat >conftest.$ac_ext <<_ACEOF
8591 /* confdefs.h.  */
8592 _ACEOF
8593 cat confdefs.h >>conftest.$ac_ext
8594 cat >>conftest.$ac_ext <<_ACEOF
8595 /* end confdefs.h.  */
8596 $ac_includes_default
8597 int
8598 main ()
8599 {
8600 static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)];
8601 test_array [0] = 0
8602
8603   ;
8604   return 0;
8605 }
8606 _ACEOF
8607 rm -f conftest.$ac_objext
8608 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8609   (eval $ac_compile) 2>conftest.er1
8610   ac_status=$?
8611   grep -v '^ *+' conftest.er1 >conftest.err
8612   rm -f conftest.er1
8613   cat conftest.err >&5
8614   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8615   (exit $ac_status); } &&
8616          { ac_try='test -z "$ac_c_werror_flag"
8617                          || test ! -s conftest.err'
8618   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8619   (eval $ac_try) 2>&5
8620   ac_status=$?
8621   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8622   (exit $ac_status); }; } &&
8623          { ac_try='test -s conftest.$ac_objext'
8624   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8625   (eval $ac_try) 2>&5
8626   ac_status=$?
8627   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8628   (exit $ac_status); }; }; then
8629   ac_hi=$ac_mid; break
8630 else
8631   echo "$as_me: failed program was:" >&5
8632 sed 's/^/| /' conftest.$ac_ext >&5
8633
8634 ac_lo=`expr $ac_mid + 1`
8635                     if test $ac_lo -le $ac_mid; then
8636                       ac_lo= ac_hi=
8637                       break
8638                     fi
8639                     ac_mid=`expr 2 '*' $ac_mid + 1`
8640 fi
8641 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8642   done
8643 else
8644   echo "$as_me: failed program was:" >&5
8645 sed 's/^/| /' conftest.$ac_ext >&5
8646
8647 cat >conftest.$ac_ext <<_ACEOF
8648 /* confdefs.h.  */
8649 _ACEOF
8650 cat confdefs.h >>conftest.$ac_ext
8651 cat >>conftest.$ac_ext <<_ACEOF
8652 /* end confdefs.h.  */
8653 $ac_includes_default
8654 int
8655 main ()
8656 {
8657 static int test_array [1 - 2 * !(((long) (sizeof (int))) < 0)];
8658 test_array [0] = 0
8659
8660   ;
8661   return 0;
8662 }
8663 _ACEOF
8664 rm -f conftest.$ac_objext
8665 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8666   (eval $ac_compile) 2>conftest.er1
8667   ac_status=$?
8668   grep -v '^ *+' conftest.er1 >conftest.err
8669   rm -f conftest.er1
8670   cat conftest.err >&5
8671   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8672   (exit $ac_status); } &&
8673          { ac_try='test -z "$ac_c_werror_flag"
8674                          || test ! -s conftest.err'
8675   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8676   (eval $ac_try) 2>&5
8677   ac_status=$?
8678   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8679   (exit $ac_status); }; } &&
8680          { ac_try='test -s conftest.$ac_objext'
8681   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8682   (eval $ac_try) 2>&5
8683   ac_status=$?
8684   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8685   (exit $ac_status); }; }; then
8686   ac_hi=-1 ac_mid=-1
8687   while :; do
8688     cat >conftest.$ac_ext <<_ACEOF
8689 /* confdefs.h.  */
8690 _ACEOF
8691 cat confdefs.h >>conftest.$ac_ext
8692 cat >>conftest.$ac_ext <<_ACEOF
8693 /* end confdefs.h.  */
8694 $ac_includes_default
8695 int
8696 main ()
8697 {
8698 static int test_array [1 - 2 * !(((long) (sizeof (int))) >= $ac_mid)];
8699 test_array [0] = 0
8700
8701   ;
8702   return 0;
8703 }
8704 _ACEOF
8705 rm -f conftest.$ac_objext
8706 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8707   (eval $ac_compile) 2>conftest.er1
8708   ac_status=$?
8709   grep -v '^ *+' conftest.er1 >conftest.err
8710   rm -f conftest.er1
8711   cat conftest.err >&5
8712   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8713   (exit $ac_status); } &&
8714          { ac_try='test -z "$ac_c_werror_flag"
8715                          || test ! -s conftest.err'
8716   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8717   (eval $ac_try) 2>&5
8718   ac_status=$?
8719   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8720   (exit $ac_status); }; } &&
8721          { ac_try='test -s conftest.$ac_objext'
8722   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8723   (eval $ac_try) 2>&5
8724   ac_status=$?
8725   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8726   (exit $ac_status); }; }; then
8727   ac_lo=$ac_mid; break
8728 else
8729   echo "$as_me: failed program was:" >&5
8730 sed 's/^/| /' conftest.$ac_ext >&5
8731
8732 ac_hi=`expr '(' $ac_mid ')' - 1`
8733                        if test $ac_mid -le $ac_hi; then
8734                          ac_lo= ac_hi=
8735                          break
8736                        fi
8737                        ac_mid=`expr 2 '*' $ac_mid`
8738 fi
8739 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8740   done
8741 else
8742   echo "$as_me: failed program was:" >&5
8743 sed 's/^/| /' conftest.$ac_ext >&5
8744
8745 ac_lo= ac_hi=
8746 fi
8747 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8748 fi
8749 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8750 # Binary search between lo and hi bounds.
8751 while test "x$ac_lo" != "x$ac_hi"; do
8752   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
8753   cat >conftest.$ac_ext <<_ACEOF
8754 /* confdefs.h.  */
8755 _ACEOF
8756 cat confdefs.h >>conftest.$ac_ext
8757 cat >>conftest.$ac_ext <<_ACEOF
8758 /* end confdefs.h.  */
8759 $ac_includes_default
8760 int
8761 main ()
8762 {
8763 static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)];
8764 test_array [0] = 0
8765
8766   ;
8767   return 0;
8768 }
8769 _ACEOF
8770 rm -f conftest.$ac_objext
8771 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8772   (eval $ac_compile) 2>conftest.er1
8773   ac_status=$?
8774   grep -v '^ *+' conftest.er1 >conftest.err
8775   rm -f conftest.er1
8776   cat conftest.err >&5
8777   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8778   (exit $ac_status); } &&
8779          { ac_try='test -z "$ac_c_werror_flag"
8780                          || test ! -s conftest.err'
8781   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8782   (eval $ac_try) 2>&5
8783   ac_status=$?
8784   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8785   (exit $ac_status); }; } &&
8786          { ac_try='test -s conftest.$ac_objext'
8787   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8788   (eval $ac_try) 2>&5
8789   ac_status=$?
8790   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8791   (exit $ac_status); }; }; then
8792   ac_hi=$ac_mid
8793 else
8794   echo "$as_me: failed program was:" >&5
8795 sed 's/^/| /' conftest.$ac_ext >&5
8796
8797 ac_lo=`expr '(' $ac_mid ')' + 1`
8798 fi
8799 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8800 done
8801 case $ac_lo in
8802 ?*) ac_cv_sizeof_int=$ac_lo;;
8803 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77
8804 See \`config.log' for more details." >&5
8805 echo "$as_me: error: cannot compute sizeof (int), 77
8806 See \`config.log' for more details." >&2;}
8807    { (exit 1); exit 1; }; } ;;
8808 esac
8809 else
8810   if test "$cross_compiling" = yes; then
8811   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
8812 See \`config.log' for more details." >&5
8813 echo "$as_me: error: cannot run test program while cross compiling
8814 See \`config.log' for more details." >&2;}
8815    { (exit 1); exit 1; }; }
8816 else
8817   cat >conftest.$ac_ext <<_ACEOF
8818 /* confdefs.h.  */
8819 _ACEOF
8820 cat confdefs.h >>conftest.$ac_ext
8821 cat >>conftest.$ac_ext <<_ACEOF
8822 /* end confdefs.h.  */
8823 $ac_includes_default
8824 long longval () { return (long) (sizeof (int)); }
8825 unsigned long ulongval () { return (long) (sizeof (int)); }
8826 #include <stdio.h>
8827 #include <stdlib.h>
8828 int
8829 main ()
8830 {
8831
8832   FILE *f = fopen ("conftest.val", "w");
8833   if (! f)
8834     exit (1);
8835   if (((long) (sizeof (int))) < 0)
8836     {
8837       long i = longval ();
8838       if (i != ((long) (sizeof (int))))
8839         exit (1);
8840       fprintf (f, "%ld\n", i);
8841     }
8842   else
8843     {
8844       unsigned long i = ulongval ();
8845       if (i != ((long) (sizeof (int))))
8846         exit (1);
8847       fprintf (f, "%lu\n", i);
8848     }
8849   exit (ferror (f) || fclose (f) != 0);
8850
8851   ;
8852   return 0;
8853 }
8854 _ACEOF
8855 rm -f conftest$ac_exeext
8856 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8857   (eval $ac_link) 2>&5
8858   ac_status=$?
8859   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8860   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
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_sizeof_int=`cat conftest.val`
8867 else
8868   echo "$as_me: program exited with status $ac_status" >&5
8869 echo "$as_me: failed program was:" >&5
8870 sed 's/^/| /' conftest.$ac_ext >&5
8871
8872 ( exit $ac_status )
8873 { { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77
8874 See \`config.log' for more details." >&5
8875 echo "$as_me: error: cannot compute sizeof (int), 77
8876 See \`config.log' for more details." >&2;}
8877    { (exit 1); exit 1; }; }
8878 fi
8879 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8880 fi
8881 fi
8882 rm -f conftest.val
8883 else
8884   ac_cv_sizeof_int=0
8885 fi
8886 fi
8887 echo "$as_me:$LINENO: result: $ac_cv_sizeof_int" >&5
8888 echo "${ECHO_T}$ac_cv_sizeof_int" >&6
8889 cat >>confdefs.h <<_ACEOF
8890 #define SIZEOF_INT $ac_cv_sizeof_int
8891 _ACEOF
8892
8893
8894   echo "$as_me:$LINENO: checking for short" >&5
8895 echo $ECHO_N "checking for short... $ECHO_C" >&6
8896 if test "${ac_cv_type_short+set}" = set; then
8897   echo $ECHO_N "(cached) $ECHO_C" >&6
8898 else
8899   cat >conftest.$ac_ext <<_ACEOF
8900 /* confdefs.h.  */
8901 _ACEOF
8902 cat confdefs.h >>conftest.$ac_ext
8903 cat >>conftest.$ac_ext <<_ACEOF
8904 /* end confdefs.h.  */
8905 $ac_includes_default
8906 int
8907 main ()
8908 {
8909 if ((short *) 0)
8910   return 0;
8911 if (sizeof (short))
8912   return 0;
8913   ;
8914   return 0;
8915 }
8916 _ACEOF
8917 rm -f conftest.$ac_objext
8918 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8919   (eval $ac_compile) 2>conftest.er1
8920   ac_status=$?
8921   grep -v '^ *+' conftest.er1 >conftest.err
8922   rm -f conftest.er1
8923   cat conftest.err >&5
8924   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8925   (exit $ac_status); } &&
8926          { ac_try='test -z "$ac_c_werror_flag"
8927                          || test ! -s conftest.err'
8928   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8929   (eval $ac_try) 2>&5
8930   ac_status=$?
8931   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8932   (exit $ac_status); }; } &&
8933          { ac_try='test -s conftest.$ac_objext'
8934   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8935   (eval $ac_try) 2>&5
8936   ac_status=$?
8937   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8938   (exit $ac_status); }; }; then
8939   ac_cv_type_short=yes
8940 else
8941   echo "$as_me: failed program was:" >&5
8942 sed 's/^/| /' conftest.$ac_ext >&5
8943
8944 ac_cv_type_short=no
8945 fi
8946 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8947 fi
8948 echo "$as_me:$LINENO: result: $ac_cv_type_short" >&5
8949 echo "${ECHO_T}$ac_cv_type_short" >&6
8950
8951 echo "$as_me:$LINENO: checking size of short" >&5
8952 echo $ECHO_N "checking size of short... $ECHO_C" >&6
8953 if test "${ac_cv_sizeof_short+set}" = set; then
8954   echo $ECHO_N "(cached) $ECHO_C" >&6
8955 else
8956   if test "$ac_cv_type_short" = yes; then
8957   # The cast to unsigned long works around a bug in the HP C Compiler
8958   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
8959   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
8960   # This bug is HP SR number 8606223364.
8961   if test "$cross_compiling" = yes; then
8962   # Depending upon the size, compute the lo and hi bounds.
8963 cat >conftest.$ac_ext <<_ACEOF
8964 /* confdefs.h.  */
8965 _ACEOF
8966 cat confdefs.h >>conftest.$ac_ext
8967 cat >>conftest.$ac_ext <<_ACEOF
8968 /* end confdefs.h.  */
8969 $ac_includes_default
8970 int
8971 main ()
8972 {
8973 static int test_array [1 - 2 * !(((long) (sizeof (short))) >= 0)];
8974 test_array [0] = 0
8975
8976   ;
8977   return 0;
8978 }
8979 _ACEOF
8980 rm -f conftest.$ac_objext
8981 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8982   (eval $ac_compile) 2>conftest.er1
8983   ac_status=$?
8984   grep -v '^ *+' conftest.er1 >conftest.err
8985   rm -f conftest.er1
8986   cat conftest.err >&5
8987   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8988   (exit $ac_status); } &&
8989          { ac_try='test -z "$ac_c_werror_flag"
8990                          || test ! -s conftest.err'
8991   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8992   (eval $ac_try) 2>&5
8993   ac_status=$?
8994   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8995   (exit $ac_status); }; } &&
8996          { ac_try='test -s conftest.$ac_objext'
8997   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8998   (eval $ac_try) 2>&5
8999   ac_status=$?
9000   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9001   (exit $ac_status); }; }; then
9002   ac_lo=0 ac_mid=0
9003   while :; do
9004     cat >conftest.$ac_ext <<_ACEOF
9005 /* confdefs.h.  */
9006 _ACEOF
9007 cat confdefs.h >>conftest.$ac_ext
9008 cat >>conftest.$ac_ext <<_ACEOF
9009 /* end confdefs.h.  */
9010 $ac_includes_default
9011 int
9012 main ()
9013 {
9014 static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)];
9015 test_array [0] = 0
9016
9017   ;
9018   return 0;
9019 }
9020 _ACEOF
9021 rm -f conftest.$ac_objext
9022 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9023   (eval $ac_compile) 2>conftest.er1
9024   ac_status=$?
9025   grep -v '^ *+' conftest.er1 >conftest.err
9026   rm -f conftest.er1
9027   cat conftest.err >&5
9028   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9029   (exit $ac_status); } &&
9030          { ac_try='test -z "$ac_c_werror_flag"
9031                          || test ! -s conftest.err'
9032   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9033   (eval $ac_try) 2>&5
9034   ac_status=$?
9035   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9036   (exit $ac_status); }; } &&
9037          { ac_try='test -s conftest.$ac_objext'
9038   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9039   (eval $ac_try) 2>&5
9040   ac_status=$?
9041   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9042   (exit $ac_status); }; }; then
9043   ac_hi=$ac_mid; break
9044 else
9045   echo "$as_me: failed program was:" >&5
9046 sed 's/^/| /' conftest.$ac_ext >&5
9047
9048 ac_lo=`expr $ac_mid + 1`
9049                     if test $ac_lo -le $ac_mid; then
9050                       ac_lo= ac_hi=
9051                       break
9052                     fi
9053                     ac_mid=`expr 2 '*' $ac_mid + 1`
9054 fi
9055 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9056   done
9057 else
9058   echo "$as_me: failed program was:" >&5
9059 sed 's/^/| /' conftest.$ac_ext >&5
9060
9061 cat >conftest.$ac_ext <<_ACEOF
9062 /* confdefs.h.  */
9063 _ACEOF
9064 cat confdefs.h >>conftest.$ac_ext
9065 cat >>conftest.$ac_ext <<_ACEOF
9066 /* end confdefs.h.  */
9067 $ac_includes_default
9068 int
9069 main ()
9070 {
9071 static int test_array [1 - 2 * !(((long) (sizeof (short))) < 0)];
9072 test_array [0] = 0
9073
9074   ;
9075   return 0;
9076 }
9077 _ACEOF
9078 rm -f conftest.$ac_objext
9079 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9080   (eval $ac_compile) 2>conftest.er1
9081   ac_status=$?
9082   grep -v '^ *+' conftest.er1 >conftest.err
9083   rm -f conftest.er1
9084   cat conftest.err >&5
9085   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9086   (exit $ac_status); } &&
9087          { ac_try='test -z "$ac_c_werror_flag"
9088                          || test ! -s conftest.err'
9089   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9090   (eval $ac_try) 2>&5
9091   ac_status=$?
9092   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9093   (exit $ac_status); }; } &&
9094          { ac_try='test -s conftest.$ac_objext'
9095   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9096   (eval $ac_try) 2>&5
9097   ac_status=$?
9098   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9099   (exit $ac_status); }; }; then
9100   ac_hi=-1 ac_mid=-1
9101   while :; do
9102     cat >conftest.$ac_ext <<_ACEOF
9103 /* confdefs.h.  */
9104 _ACEOF
9105 cat confdefs.h >>conftest.$ac_ext
9106 cat >>conftest.$ac_ext <<_ACEOF
9107 /* end confdefs.h.  */
9108 $ac_includes_default
9109 int
9110 main ()
9111 {
9112 static int test_array [1 - 2 * !(((long) (sizeof (short))) >= $ac_mid)];
9113 test_array [0] = 0
9114
9115   ;
9116   return 0;
9117 }
9118 _ACEOF
9119 rm -f conftest.$ac_objext
9120 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9121   (eval $ac_compile) 2>conftest.er1
9122   ac_status=$?
9123   grep -v '^ *+' conftest.er1 >conftest.err
9124   rm -f conftest.er1
9125   cat conftest.err >&5
9126   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9127   (exit $ac_status); } &&
9128          { ac_try='test -z "$ac_c_werror_flag"
9129                          || test ! -s conftest.err'
9130   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9131   (eval $ac_try) 2>&5
9132   ac_status=$?
9133   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9134   (exit $ac_status); }; } &&
9135          { ac_try='test -s conftest.$ac_objext'
9136   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9137   (eval $ac_try) 2>&5
9138   ac_status=$?
9139   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9140   (exit $ac_status); }; }; then
9141   ac_lo=$ac_mid; break
9142 else
9143   echo "$as_me: failed program was:" >&5
9144 sed 's/^/| /' conftest.$ac_ext >&5
9145
9146 ac_hi=`expr '(' $ac_mid ')' - 1`
9147                        if test $ac_mid -le $ac_hi; then
9148                          ac_lo= ac_hi=
9149                          break
9150                        fi
9151                        ac_mid=`expr 2 '*' $ac_mid`
9152 fi
9153 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9154   done
9155 else
9156   echo "$as_me: failed program was:" >&5
9157 sed 's/^/| /' conftest.$ac_ext >&5
9158
9159 ac_lo= ac_hi=
9160 fi
9161 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9162 fi
9163 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9164 # Binary search between lo and hi bounds.
9165 while test "x$ac_lo" != "x$ac_hi"; do
9166   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
9167   cat >conftest.$ac_ext <<_ACEOF
9168 /* confdefs.h.  */
9169 _ACEOF
9170 cat confdefs.h >>conftest.$ac_ext
9171 cat >>conftest.$ac_ext <<_ACEOF
9172 /* end confdefs.h.  */
9173 $ac_includes_default
9174 int
9175 main ()
9176 {
9177 static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)];
9178 test_array [0] = 0
9179
9180   ;
9181   return 0;
9182 }
9183 _ACEOF
9184 rm -f conftest.$ac_objext
9185 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9186   (eval $ac_compile) 2>conftest.er1
9187   ac_status=$?
9188   grep -v '^ *+' conftest.er1 >conftest.err
9189   rm -f conftest.er1
9190   cat conftest.err >&5
9191   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9192   (exit $ac_status); } &&
9193          { ac_try='test -z "$ac_c_werror_flag"
9194                          || test ! -s conftest.err'
9195   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9196   (eval $ac_try) 2>&5
9197   ac_status=$?
9198   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9199   (exit $ac_status); }; } &&
9200          { ac_try='test -s conftest.$ac_objext'
9201   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9202   (eval $ac_try) 2>&5
9203   ac_status=$?
9204   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9205   (exit $ac_status); }; }; then
9206   ac_hi=$ac_mid
9207 else
9208   echo "$as_me: failed program was:" >&5
9209 sed 's/^/| /' conftest.$ac_ext >&5
9210
9211 ac_lo=`expr '(' $ac_mid ')' + 1`
9212 fi
9213 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9214 done
9215 case $ac_lo in
9216 ?*) ac_cv_sizeof_short=$ac_lo;;
9217 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77
9218 See \`config.log' for more details." >&5
9219 echo "$as_me: error: cannot compute sizeof (short), 77
9220 See \`config.log' for more details." >&2;}
9221    { (exit 1); exit 1; }; } ;;
9222 esac
9223 else
9224   if test "$cross_compiling" = yes; then
9225   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
9226 See \`config.log' for more details." >&5
9227 echo "$as_me: error: cannot run test program while cross compiling
9228 See \`config.log' for more details." >&2;}
9229    { (exit 1); exit 1; }; }
9230 else
9231   cat >conftest.$ac_ext <<_ACEOF
9232 /* confdefs.h.  */
9233 _ACEOF
9234 cat confdefs.h >>conftest.$ac_ext
9235 cat >>conftest.$ac_ext <<_ACEOF
9236 /* end confdefs.h.  */
9237 $ac_includes_default
9238 long longval () { return (long) (sizeof (short)); }
9239 unsigned long ulongval () { return (long) (sizeof (short)); }
9240 #include <stdio.h>
9241 #include <stdlib.h>
9242 int
9243 main ()
9244 {
9245
9246   FILE *f = fopen ("conftest.val", "w");
9247   if (! f)
9248     exit (1);
9249   if (((long) (sizeof (short))) < 0)
9250     {
9251       long i = longval ();
9252       if (i != ((long) (sizeof (short))))
9253         exit (1);
9254       fprintf (f, "%ld\n", i);
9255     }
9256   else
9257     {
9258       unsigned long i = ulongval ();
9259       if (i != ((long) (sizeof (short))))
9260         exit (1);
9261       fprintf (f, "%lu\n", i);
9262     }
9263   exit (ferror (f) || fclose (f) != 0);
9264
9265   ;
9266   return 0;
9267 }
9268 _ACEOF
9269 rm -f conftest$ac_exeext
9270 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9271   (eval $ac_link) 2>&5
9272   ac_status=$?
9273   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9274   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
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_sizeof_short=`cat conftest.val`
9281 else
9282   echo "$as_me: program exited with status $ac_status" >&5
9283 echo "$as_me: failed program was:" >&5
9284 sed 's/^/| /' conftest.$ac_ext >&5
9285
9286 ( exit $ac_status )
9287 { { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77
9288 See \`config.log' for more details." >&5
9289 echo "$as_me: error: cannot compute sizeof (short), 77
9290 See \`config.log' for more details." >&2;}
9291    { (exit 1); exit 1; }; }
9292 fi
9293 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9294 fi
9295 fi
9296 rm -f conftest.val
9297 else
9298   ac_cv_sizeof_short=0
9299 fi
9300 fi
9301 echo "$as_me:$LINENO: result: $ac_cv_sizeof_short" >&5
9302 echo "${ECHO_T}$ac_cv_sizeof_short" >&6
9303 cat >>confdefs.h <<_ACEOF
9304 #define SIZEOF_SHORT $ac_cv_sizeof_short
9305 _ACEOF
9306
9307
9308   echo "$as_me:$LINENO: checking for char" >&5
9309 echo $ECHO_N "checking for char... $ECHO_C" >&6
9310 if test "${ac_cv_type_char+set}" = set; then
9311   echo $ECHO_N "(cached) $ECHO_C" >&6
9312 else
9313   cat >conftest.$ac_ext <<_ACEOF
9314 /* confdefs.h.  */
9315 _ACEOF
9316 cat confdefs.h >>conftest.$ac_ext
9317 cat >>conftest.$ac_ext <<_ACEOF
9318 /* end confdefs.h.  */
9319 $ac_includes_default
9320 int
9321 main ()
9322 {
9323 if ((char *) 0)
9324   return 0;
9325 if (sizeof (char))
9326   return 0;
9327   ;
9328   return 0;
9329 }
9330 _ACEOF
9331 rm -f conftest.$ac_objext
9332 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9333   (eval $ac_compile) 2>conftest.er1
9334   ac_status=$?
9335   grep -v '^ *+' conftest.er1 >conftest.err
9336   rm -f conftest.er1
9337   cat conftest.err >&5
9338   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9339   (exit $ac_status); } &&
9340          { ac_try='test -z "$ac_c_werror_flag"
9341                          || test ! -s conftest.err'
9342   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9343   (eval $ac_try) 2>&5
9344   ac_status=$?
9345   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9346   (exit $ac_status); }; } &&
9347          { ac_try='test -s conftest.$ac_objext'
9348   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9349   (eval $ac_try) 2>&5
9350   ac_status=$?
9351   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9352   (exit $ac_status); }; }; then
9353   ac_cv_type_char=yes
9354 else
9355   echo "$as_me: failed program was:" >&5
9356 sed 's/^/| /' conftest.$ac_ext >&5
9357
9358 ac_cv_type_char=no
9359 fi
9360 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9361 fi
9362 echo "$as_me:$LINENO: result: $ac_cv_type_char" >&5
9363 echo "${ECHO_T}$ac_cv_type_char" >&6
9364
9365 echo "$as_me:$LINENO: checking size of char" >&5
9366 echo $ECHO_N "checking size of char... $ECHO_C" >&6
9367 if test "${ac_cv_sizeof_char+set}" = set; then
9368   echo $ECHO_N "(cached) $ECHO_C" >&6
9369 else
9370   if test "$ac_cv_type_char" = yes; then
9371   # The cast to unsigned long works around a bug in the HP C Compiler
9372   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
9373   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
9374   # This bug is HP SR number 8606223364.
9375   if test "$cross_compiling" = yes; then
9376   # Depending upon the size, compute the lo and hi bounds.
9377 cat >conftest.$ac_ext <<_ACEOF
9378 /* confdefs.h.  */
9379 _ACEOF
9380 cat confdefs.h >>conftest.$ac_ext
9381 cat >>conftest.$ac_ext <<_ACEOF
9382 /* end confdefs.h.  */
9383 $ac_includes_default
9384 int
9385 main ()
9386 {
9387 static int test_array [1 - 2 * !(((long) (sizeof (char))) >= 0)];
9388 test_array [0] = 0
9389
9390   ;
9391   return 0;
9392 }
9393 _ACEOF
9394 rm -f conftest.$ac_objext
9395 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9396   (eval $ac_compile) 2>conftest.er1
9397   ac_status=$?
9398   grep -v '^ *+' conftest.er1 >conftest.err
9399   rm -f conftest.er1
9400   cat conftest.err >&5
9401   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9402   (exit $ac_status); } &&
9403          { ac_try='test -z "$ac_c_werror_flag"
9404                          || test ! -s conftest.err'
9405   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9406   (eval $ac_try) 2>&5
9407   ac_status=$?
9408   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9409   (exit $ac_status); }; } &&
9410          { ac_try='test -s conftest.$ac_objext'
9411   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9412   (eval $ac_try) 2>&5
9413   ac_status=$?
9414   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9415   (exit $ac_status); }; }; then
9416   ac_lo=0 ac_mid=0
9417   while :; do
9418     cat >conftest.$ac_ext <<_ACEOF
9419 /* confdefs.h.  */
9420 _ACEOF
9421 cat confdefs.h >>conftest.$ac_ext
9422 cat >>conftest.$ac_ext <<_ACEOF
9423 /* end confdefs.h.  */
9424 $ac_includes_default
9425 int
9426 main ()
9427 {
9428 static int test_array [1 - 2 * !(((long) (sizeof (char))) <= $ac_mid)];
9429 test_array [0] = 0
9430
9431   ;
9432   return 0;
9433 }
9434 _ACEOF
9435 rm -f conftest.$ac_objext
9436 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9437   (eval $ac_compile) 2>conftest.er1
9438   ac_status=$?
9439   grep -v '^ *+' conftest.er1 >conftest.err
9440   rm -f conftest.er1
9441   cat conftest.err >&5
9442   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9443   (exit $ac_status); } &&
9444          { ac_try='test -z "$ac_c_werror_flag"
9445                          || test ! -s conftest.err'
9446   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9447   (eval $ac_try) 2>&5
9448   ac_status=$?
9449   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9450   (exit $ac_status); }; } &&
9451          { ac_try='test -s conftest.$ac_objext'
9452   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9453   (eval $ac_try) 2>&5
9454   ac_status=$?
9455   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9456   (exit $ac_status); }; }; then
9457   ac_hi=$ac_mid; break
9458 else
9459   echo "$as_me: failed program was:" >&5
9460 sed 's/^/| /' conftest.$ac_ext >&5
9461
9462 ac_lo=`expr $ac_mid + 1`
9463                     if test $ac_lo -le $ac_mid; then
9464                       ac_lo= ac_hi=
9465                       break
9466                     fi
9467                     ac_mid=`expr 2 '*' $ac_mid + 1`
9468 fi
9469 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9470   done
9471 else
9472   echo "$as_me: failed program was:" >&5
9473 sed 's/^/| /' conftest.$ac_ext >&5
9474
9475 cat >conftest.$ac_ext <<_ACEOF
9476 /* confdefs.h.  */
9477 _ACEOF
9478 cat confdefs.h >>conftest.$ac_ext
9479 cat >>conftest.$ac_ext <<_ACEOF
9480 /* end confdefs.h.  */
9481 $ac_includes_default
9482 int
9483 main ()
9484 {
9485 static int test_array [1 - 2 * !(((long) (sizeof (char))) < 0)];
9486 test_array [0] = 0
9487
9488   ;
9489   return 0;
9490 }
9491 _ACEOF
9492 rm -f conftest.$ac_objext
9493 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9494   (eval $ac_compile) 2>conftest.er1
9495   ac_status=$?
9496   grep -v '^ *+' conftest.er1 >conftest.err
9497   rm -f conftest.er1
9498   cat conftest.err >&5
9499   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9500   (exit $ac_status); } &&
9501          { ac_try='test -z "$ac_c_werror_flag"
9502                          || test ! -s conftest.err'
9503   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9504   (eval $ac_try) 2>&5
9505   ac_status=$?
9506   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9507   (exit $ac_status); }; } &&
9508          { ac_try='test -s conftest.$ac_objext'
9509   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9510   (eval $ac_try) 2>&5
9511   ac_status=$?
9512   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9513   (exit $ac_status); }; }; then
9514   ac_hi=-1 ac_mid=-1
9515   while :; do
9516     cat >conftest.$ac_ext <<_ACEOF
9517 /* confdefs.h.  */
9518 _ACEOF
9519 cat confdefs.h >>conftest.$ac_ext
9520 cat >>conftest.$ac_ext <<_ACEOF
9521 /* end confdefs.h.  */
9522 $ac_includes_default
9523 int
9524 main ()
9525 {
9526 static int test_array [1 - 2 * !(((long) (sizeof (char))) >= $ac_mid)];
9527 test_array [0] = 0
9528
9529   ;
9530   return 0;
9531 }
9532 _ACEOF
9533 rm -f conftest.$ac_objext
9534 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9535   (eval $ac_compile) 2>conftest.er1
9536   ac_status=$?
9537   grep -v '^ *+' conftest.er1 >conftest.err
9538   rm -f conftest.er1
9539   cat conftest.err >&5
9540   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9541   (exit $ac_status); } &&
9542          { ac_try='test -z "$ac_c_werror_flag"
9543                          || test ! -s conftest.err'
9544   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9545   (eval $ac_try) 2>&5
9546   ac_status=$?
9547   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9548   (exit $ac_status); }; } &&
9549          { ac_try='test -s conftest.$ac_objext'
9550   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9551   (eval $ac_try) 2>&5
9552   ac_status=$?
9553   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9554   (exit $ac_status); }; }; then
9555   ac_lo=$ac_mid; break
9556 else
9557   echo "$as_me: failed program was:" >&5
9558 sed 's/^/| /' conftest.$ac_ext >&5
9559
9560 ac_hi=`expr '(' $ac_mid ')' - 1`
9561                        if test $ac_mid -le $ac_hi; then
9562                          ac_lo= ac_hi=
9563                          break
9564                        fi
9565                        ac_mid=`expr 2 '*' $ac_mid`
9566 fi
9567 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9568   done
9569 else
9570   echo "$as_me: failed program was:" >&5
9571 sed 's/^/| /' conftest.$ac_ext >&5
9572
9573 ac_lo= ac_hi=
9574 fi
9575 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9576 fi
9577 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9578 # Binary search between lo and hi bounds.
9579 while test "x$ac_lo" != "x$ac_hi"; do
9580   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
9581   cat >conftest.$ac_ext <<_ACEOF
9582 /* confdefs.h.  */
9583 _ACEOF
9584 cat confdefs.h >>conftest.$ac_ext
9585 cat >>conftest.$ac_ext <<_ACEOF
9586 /* end confdefs.h.  */
9587 $ac_includes_default
9588 int
9589 main ()
9590 {
9591 static int test_array [1 - 2 * !(((long) (sizeof (char))) <= $ac_mid)];
9592 test_array [0] = 0
9593
9594   ;
9595   return 0;
9596 }
9597 _ACEOF
9598 rm -f conftest.$ac_objext
9599 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9600   (eval $ac_compile) 2>conftest.er1
9601   ac_status=$?
9602   grep -v '^ *+' conftest.er1 >conftest.err
9603   rm -f conftest.er1
9604   cat conftest.err >&5
9605   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9606   (exit $ac_status); } &&
9607          { ac_try='test -z "$ac_c_werror_flag"
9608                          || test ! -s conftest.err'
9609   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9610   (eval $ac_try) 2>&5
9611   ac_status=$?
9612   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9613   (exit $ac_status); }; } &&
9614          { ac_try='test -s conftest.$ac_objext'
9615   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9616   (eval $ac_try) 2>&5
9617   ac_status=$?
9618   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9619   (exit $ac_status); }; }; then
9620   ac_hi=$ac_mid
9621 else
9622   echo "$as_me: failed program was:" >&5
9623 sed 's/^/| /' conftest.$ac_ext >&5
9624
9625 ac_lo=`expr '(' $ac_mid ')' + 1`
9626 fi
9627 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9628 done
9629 case $ac_lo in
9630 ?*) ac_cv_sizeof_char=$ac_lo;;
9631 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (char), 77
9632 See \`config.log' for more details." >&5
9633 echo "$as_me: error: cannot compute sizeof (char), 77
9634 See \`config.log' for more details." >&2;}
9635    { (exit 1); exit 1; }; } ;;
9636 esac
9637 else
9638   if test "$cross_compiling" = yes; then
9639   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
9640 See \`config.log' for more details." >&5
9641 echo "$as_me: error: cannot run test program while cross compiling
9642 See \`config.log' for more details." >&2;}
9643    { (exit 1); exit 1; }; }
9644 else
9645   cat >conftest.$ac_ext <<_ACEOF
9646 /* confdefs.h.  */
9647 _ACEOF
9648 cat confdefs.h >>conftest.$ac_ext
9649 cat >>conftest.$ac_ext <<_ACEOF
9650 /* end confdefs.h.  */
9651 $ac_includes_default
9652 long longval () { return (long) (sizeof (char)); }
9653 unsigned long ulongval () { return (long) (sizeof (char)); }
9654 #include <stdio.h>
9655 #include <stdlib.h>
9656 int
9657 main ()
9658 {
9659
9660   FILE *f = fopen ("conftest.val", "w");
9661   if (! f)
9662     exit (1);
9663   if (((long) (sizeof (char))) < 0)
9664     {
9665       long i = longval ();
9666       if (i != ((long) (sizeof (char))))
9667         exit (1);
9668       fprintf (f, "%ld\n", i);
9669     }
9670   else
9671     {
9672       unsigned long i = ulongval ();
9673       if (i != ((long) (sizeof (char))))
9674         exit (1);
9675       fprintf (f, "%lu\n", i);
9676     }
9677   exit (ferror (f) || fclose (f) != 0);
9678
9679   ;
9680   return 0;
9681 }
9682 _ACEOF
9683 rm -f conftest$ac_exeext
9684 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9685   (eval $ac_link) 2>&5
9686   ac_status=$?
9687   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9688   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9689   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9690   (eval $ac_try) 2>&5
9691   ac_status=$?
9692   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9693   (exit $ac_status); }; }; then
9694   ac_cv_sizeof_char=`cat conftest.val`
9695 else
9696   echo "$as_me: program exited with status $ac_status" >&5
9697 echo "$as_me: failed program was:" >&5
9698 sed 's/^/| /' conftest.$ac_ext >&5
9699
9700 ( exit $ac_status )
9701 { { echo "$as_me:$LINENO: error: cannot compute sizeof (char), 77
9702 See \`config.log' for more details." >&5
9703 echo "$as_me: error: cannot compute sizeof (char), 77
9704 See \`config.log' for more details." >&2;}
9705    { (exit 1); exit 1; }; }
9706 fi
9707 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9708 fi
9709 fi
9710 rm -f conftest.val
9711 else
9712   ac_cv_sizeof_char=0
9713 fi
9714 fi
9715 echo "$as_me:$LINENO: result: $ac_cv_sizeof_char" >&5
9716 echo "${ECHO_T}$ac_cv_sizeof_char" >&6
9717 cat >>confdefs.h <<_ACEOF
9718 #define SIZEOF_CHAR $ac_cv_sizeof_char
9719 _ACEOF
9720
9721
9722
9723   echo "$as_me:$LINENO: checking for type equivalent to int8_t" >&5
9724 echo $ECHO_N "checking for type equivalent to int8_t... $ECHO_C" >&6
9725   case "$ac_cv_sizeof_char" in
9726     1) acx_cv_type_int8_t=char ;;
9727     *) { { echo "$as_me:$LINENO: error: no 8-bit type" >&5
9728 echo "$as_me: error: no 8-bit type" >&2;}
9729    { (exit please report a bug); exit please report a bug; }; }
9730   esac
9731   echo "$as_me:$LINENO: result: $acx_cv_type_int8_t" >&5
9732 echo "${ECHO_T}$acx_cv_type_int8_t" >&6
9733
9734   echo "$as_me:$LINENO: checking for type equivalent to int16_t" >&5
9735 echo $ECHO_N "checking for type equivalent to int16_t... $ECHO_C" >&6
9736   case "$ac_cv_sizeof_int:$ac_cv_sizeof_short" in
9737     2:*) acx_cv_type_int16_t=int ;;
9738     *:2) acx_cv_type_int16_t=short ;;
9739     *) { { echo "$as_me:$LINENO: error: no 16-bit type" >&5
9740 echo "$as_me: error: no 16-bit type" >&2;}
9741    { (exit please report a bug); exit please report a bug; }; }
9742   esac
9743   echo "$as_me:$LINENO: result: $acx_cv_type_int16_t" >&5
9744 echo "${ECHO_T}$acx_cv_type_int16_t" >&6
9745
9746   echo "$as_me:$LINENO: checking for type equivalent to int32_t" >&5
9747 echo $ECHO_N "checking for type equivalent to int32_t... $ECHO_C" >&6
9748   case "$ac_cv_sizeof_int:$ac_cv_sizeof_long" in
9749     4:*) acx_cv_type_int32_t=int ;;
9750     *:4) acx_cv_type_int32_t=long ;;
9751     *) { { echo "$as_me:$LINENO: error: no 32-bit type" >&5
9752 echo "$as_me: error: no 32-bit type" >&2;}
9753    { (exit please report a bug); exit please report a bug; }; }
9754   esac
9755   echo "$as_me:$LINENO: result: $acx_cv_type_int32_t" >&5
9756 echo "${ECHO_T}$acx_cv_type_int32_t" >&6
9757 fi
9758
9759 # These tests are here to make the output prettier
9760
9761 if test "$ac_cv_type_uint64_t" != yes && test "$ac_cv_type_u_int64_t" != yes; then
9762   case "$ac_cv_sizeof_long" in
9763     8) acx_cv_type_int64_t=long ;;
9764   esac
9765   echo "$as_me:$LINENO: checking for type equivalent to int64_t" >&5
9766 echo $ECHO_N "checking for type equivalent to int64_t... $ECHO_C" >&6
9767   echo "$as_me:$LINENO: result: ${acx_cv_type_int64_t-'using preprocessor symbols'}" >&5
9768 echo "${ECHO_T}${acx_cv_type_int64_t-'using preprocessor symbols'}" >&6
9769 fi
9770
9771 # Now we can use the above types
9772
9773 if test "$ac_cv_type_uintptr_t" != yes; then
9774   echo "$as_me:$LINENO: checking for type equivalent to intptr_t" >&5
9775 echo $ECHO_N "checking for type equivalent to intptr_t... $ECHO_C" >&6
9776   case $ac_cv_sizeof_void_p in
9777     2) acx_cv_type_intptr_t=int16_t ;;
9778     4) acx_cv_type_intptr_t=int32_t ;;
9779     8) acx_cv_type_intptr_t=int64_t ;;
9780     *) { { echo "$as_me:$LINENO: error: no equivalent for intptr_t" >&5
9781 echo "$as_me: error: no equivalent for intptr_t" >&2;}
9782    { (exit please report a bug); exit please report a bug; }; }
9783   esac
9784   echo "$as_me:$LINENO: result: $acx_cv_type_intptr_t" >&5
9785 echo "${ECHO_T}$acx_cv_type_intptr_t" >&6
9786 fi
9787
9788 # ----------------- done all checks, emit header -------------
9789           ac_config_commands="$ac_config_commands gstdint.h"
9790
9791
9792
9793
9794 echo "$as_me:$LINENO: checking for struct stat.st_blksize" >&5
9795 echo $ECHO_N "checking for struct stat.st_blksize... $ECHO_C" >&6
9796 if test "${ac_cv_member_struct_stat_st_blksize+set}" = set; then
9797   echo $ECHO_N "(cached) $ECHO_C" >&6
9798 else
9799   cat >conftest.$ac_ext <<_ACEOF
9800 /* confdefs.h.  */
9801 _ACEOF
9802 cat confdefs.h >>conftest.$ac_ext
9803 cat >>conftest.$ac_ext <<_ACEOF
9804 /* end confdefs.h.  */
9805 $ac_includes_default
9806 int
9807 main ()
9808 {
9809 static struct stat ac_aggr;
9810 if (ac_aggr.st_blksize)
9811 return 0;
9812   ;
9813   return 0;
9814 }
9815 _ACEOF
9816 rm -f conftest.$ac_objext
9817 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9818   (eval $ac_compile) 2>conftest.er1
9819   ac_status=$?
9820   grep -v '^ *+' conftest.er1 >conftest.err
9821   rm -f conftest.er1
9822   cat conftest.err >&5
9823   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9824   (exit $ac_status); } &&
9825          { ac_try='test -z "$ac_c_werror_flag"
9826                          || test ! -s conftest.err'
9827   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9828   (eval $ac_try) 2>&5
9829   ac_status=$?
9830   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9831   (exit $ac_status); }; } &&
9832          { ac_try='test -s conftest.$ac_objext'
9833   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9834   (eval $ac_try) 2>&5
9835   ac_status=$?
9836   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9837   (exit $ac_status); }; }; then
9838   ac_cv_member_struct_stat_st_blksize=yes
9839 else
9840   echo "$as_me: failed program was:" >&5
9841 sed 's/^/| /' conftest.$ac_ext >&5
9842
9843 cat >conftest.$ac_ext <<_ACEOF
9844 /* confdefs.h.  */
9845 _ACEOF
9846 cat confdefs.h >>conftest.$ac_ext
9847 cat >>conftest.$ac_ext <<_ACEOF
9848 /* end confdefs.h.  */
9849 $ac_includes_default
9850 int
9851 main ()
9852 {
9853 static struct stat ac_aggr;
9854 if (sizeof ac_aggr.st_blksize)
9855 return 0;
9856   ;
9857   return 0;
9858 }
9859 _ACEOF
9860 rm -f conftest.$ac_objext
9861 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9862   (eval $ac_compile) 2>conftest.er1
9863   ac_status=$?
9864   grep -v '^ *+' conftest.er1 >conftest.err
9865   rm -f conftest.er1
9866   cat conftest.err >&5
9867   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9868   (exit $ac_status); } &&
9869          { ac_try='test -z "$ac_c_werror_flag"
9870                          || test ! -s conftest.err'
9871   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9872   (eval $ac_try) 2>&5
9873   ac_status=$?
9874   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9875   (exit $ac_status); }; } &&
9876          { ac_try='test -s conftest.$ac_objext'
9877   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9878   (eval $ac_try) 2>&5
9879   ac_status=$?
9880   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9881   (exit $ac_status); }; }; then
9882   ac_cv_member_struct_stat_st_blksize=yes
9883 else
9884   echo "$as_me: failed program was:" >&5
9885 sed 's/^/| /' conftest.$ac_ext >&5
9886
9887 ac_cv_member_struct_stat_st_blksize=no
9888 fi
9889 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9890 fi
9891 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9892 fi
9893 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blksize" >&5
9894 echo "${ECHO_T}$ac_cv_member_struct_stat_st_blksize" >&6
9895 if test $ac_cv_member_struct_stat_st_blksize = yes; then
9896
9897 cat >>confdefs.h <<_ACEOF
9898 #define HAVE_STRUCT_STAT_ST_BLKSIZE 1
9899 _ACEOF
9900
9901
9902 fi
9903
9904 echo "$as_me:$LINENO: checking for struct stat.st_blocks" >&5
9905 echo $ECHO_N "checking for struct stat.st_blocks... $ECHO_C" >&6
9906 if test "${ac_cv_member_struct_stat_st_blocks+set}" = set; then
9907   echo $ECHO_N "(cached) $ECHO_C" >&6
9908 else
9909   cat >conftest.$ac_ext <<_ACEOF
9910 /* confdefs.h.  */
9911 _ACEOF
9912 cat confdefs.h >>conftest.$ac_ext
9913 cat >>conftest.$ac_ext <<_ACEOF
9914 /* end confdefs.h.  */
9915 $ac_includes_default
9916 int
9917 main ()
9918 {
9919 static struct stat ac_aggr;
9920 if (ac_aggr.st_blocks)
9921 return 0;
9922   ;
9923   return 0;
9924 }
9925 _ACEOF
9926 rm -f conftest.$ac_objext
9927 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9928   (eval $ac_compile) 2>conftest.er1
9929   ac_status=$?
9930   grep -v '^ *+' conftest.er1 >conftest.err
9931   rm -f conftest.er1
9932   cat conftest.err >&5
9933   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9934   (exit $ac_status); } &&
9935          { ac_try='test -z "$ac_c_werror_flag"
9936                          || test ! -s conftest.err'
9937   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9938   (eval $ac_try) 2>&5
9939   ac_status=$?
9940   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9941   (exit $ac_status); }; } &&
9942          { ac_try='test -s conftest.$ac_objext'
9943   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9944   (eval $ac_try) 2>&5
9945   ac_status=$?
9946   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9947   (exit $ac_status); }; }; then
9948   ac_cv_member_struct_stat_st_blocks=yes
9949 else
9950   echo "$as_me: failed program was:" >&5
9951 sed 's/^/| /' conftest.$ac_ext >&5
9952
9953 cat >conftest.$ac_ext <<_ACEOF
9954 /* confdefs.h.  */
9955 _ACEOF
9956 cat confdefs.h >>conftest.$ac_ext
9957 cat >>conftest.$ac_ext <<_ACEOF
9958 /* end confdefs.h.  */
9959 $ac_includes_default
9960 int
9961 main ()
9962 {
9963 static struct stat ac_aggr;
9964 if (sizeof ac_aggr.st_blocks)
9965 return 0;
9966   ;
9967   return 0;
9968 }
9969 _ACEOF
9970 rm -f conftest.$ac_objext
9971 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9972   (eval $ac_compile) 2>conftest.er1
9973   ac_status=$?
9974   grep -v '^ *+' conftest.er1 >conftest.err
9975   rm -f conftest.er1
9976   cat conftest.err >&5
9977   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9978   (exit $ac_status); } &&
9979          { ac_try='test -z "$ac_c_werror_flag"
9980                          || test ! -s conftest.err'
9981   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9982   (eval $ac_try) 2>&5
9983   ac_status=$?
9984   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9985   (exit $ac_status); }; } &&
9986          { ac_try='test -s conftest.$ac_objext'
9987   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9988   (eval $ac_try) 2>&5
9989   ac_status=$?
9990   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9991   (exit $ac_status); }; }; then
9992   ac_cv_member_struct_stat_st_blocks=yes
9993 else
9994   echo "$as_me: failed program was:" >&5
9995 sed 's/^/| /' conftest.$ac_ext >&5
9996
9997 ac_cv_member_struct_stat_st_blocks=no
9998 fi
9999 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10000 fi
10001 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10002 fi
10003 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blocks" >&5
10004 echo "${ECHO_T}$ac_cv_member_struct_stat_st_blocks" >&6
10005 if test $ac_cv_member_struct_stat_st_blocks = yes; then
10006
10007 cat >>confdefs.h <<_ACEOF
10008 #define HAVE_STRUCT_STAT_ST_BLOCKS 1
10009 _ACEOF
10010
10011
10012 fi
10013
10014 echo "$as_me:$LINENO: checking for struct stat.st_rdev" >&5
10015 echo $ECHO_N "checking for struct stat.st_rdev... $ECHO_C" >&6
10016 if test "${ac_cv_member_struct_stat_st_rdev+set}" = set; then
10017   echo $ECHO_N "(cached) $ECHO_C" >&6
10018 else
10019   cat >conftest.$ac_ext <<_ACEOF
10020 /* confdefs.h.  */
10021 _ACEOF
10022 cat confdefs.h >>conftest.$ac_ext
10023 cat >>conftest.$ac_ext <<_ACEOF
10024 /* end confdefs.h.  */
10025 $ac_includes_default
10026 int
10027 main ()
10028 {
10029 static struct stat ac_aggr;
10030 if (ac_aggr.st_rdev)
10031 return 0;
10032   ;
10033   return 0;
10034 }
10035 _ACEOF
10036 rm -f conftest.$ac_objext
10037 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10038   (eval $ac_compile) 2>conftest.er1
10039   ac_status=$?
10040   grep -v '^ *+' conftest.er1 >conftest.err
10041   rm -f conftest.er1
10042   cat conftest.err >&5
10043   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10044   (exit $ac_status); } &&
10045          { ac_try='test -z "$ac_c_werror_flag"
10046                          || test ! -s conftest.err'
10047   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10048   (eval $ac_try) 2>&5
10049   ac_status=$?
10050   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10051   (exit $ac_status); }; } &&
10052          { ac_try='test -s conftest.$ac_objext'
10053   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10054   (eval $ac_try) 2>&5
10055   ac_status=$?
10056   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10057   (exit $ac_status); }; }; then
10058   ac_cv_member_struct_stat_st_rdev=yes
10059 else
10060   echo "$as_me: failed program was:" >&5
10061 sed 's/^/| /' conftest.$ac_ext >&5
10062
10063 cat >conftest.$ac_ext <<_ACEOF
10064 /* confdefs.h.  */
10065 _ACEOF
10066 cat confdefs.h >>conftest.$ac_ext
10067 cat >>conftest.$ac_ext <<_ACEOF
10068 /* end confdefs.h.  */
10069 $ac_includes_default
10070 int
10071 main ()
10072 {
10073 static struct stat ac_aggr;
10074 if (sizeof ac_aggr.st_rdev)
10075 return 0;
10076   ;
10077   return 0;
10078 }
10079 _ACEOF
10080 rm -f conftest.$ac_objext
10081 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10082   (eval $ac_compile) 2>conftest.er1
10083   ac_status=$?
10084   grep -v '^ *+' conftest.er1 >conftest.err
10085   rm -f conftest.er1
10086   cat conftest.err >&5
10087   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10088   (exit $ac_status); } &&
10089          { ac_try='test -z "$ac_c_werror_flag"
10090                          || test ! -s conftest.err'
10091   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10092   (eval $ac_try) 2>&5
10093   ac_status=$?
10094   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10095   (exit $ac_status); }; } &&
10096          { ac_try='test -s conftest.$ac_objext'
10097   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10098   (eval $ac_try) 2>&5
10099   ac_status=$?
10100   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10101   (exit $ac_status); }; }; then
10102   ac_cv_member_struct_stat_st_rdev=yes
10103 else
10104   echo "$as_me: failed program was:" >&5
10105 sed 's/^/| /' conftest.$ac_ext >&5
10106
10107 ac_cv_member_struct_stat_st_rdev=no
10108 fi
10109 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10110 fi
10111 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10112 fi
10113 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_rdev" >&5
10114 echo "${ECHO_T}$ac_cv_member_struct_stat_st_rdev" >&6
10115 if test $ac_cv_member_struct_stat_st_rdev = yes; then
10116
10117 cat >>confdefs.h <<_ACEOF
10118 #define HAVE_STRUCT_STAT_ST_RDEV 1
10119 _ACEOF
10120
10121
10122 fi
10123
10124
10125 # Check for library functions.
10126
10127
10128
10129
10130
10131
10132
10133
10134 for ac_func in getrusage times mkstemp strtof strtold snprintf ftruncate chsize
10135 do
10136 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10137 echo "$as_me:$LINENO: checking for $ac_func" >&5
10138 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10139 if eval "test \"\${$as_ac_var+set}\" = set"; then
10140   echo $ECHO_N "(cached) $ECHO_C" >&6
10141 else
10142   if test x$gcc_no_link = xyes; then
10143   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10144 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10145    { (exit 1); exit 1; }; }
10146 fi
10147 cat >conftest.$ac_ext <<_ACEOF
10148 /* confdefs.h.  */
10149 _ACEOF
10150 cat confdefs.h >>conftest.$ac_ext
10151 cat >>conftest.$ac_ext <<_ACEOF
10152 /* end confdefs.h.  */
10153 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10154    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10155 #define $ac_func innocuous_$ac_func
10156
10157 /* System header to define __stub macros and hopefully few prototypes,
10158     which can conflict with char $ac_func (); below.
10159     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10160     <limits.h> exists even on freestanding compilers.  */
10161
10162 #ifdef __STDC__
10163 # include <limits.h>
10164 #else
10165 # include <assert.h>
10166 #endif
10167
10168 #undef $ac_func
10169
10170 /* Override any gcc2 internal prototype to avoid an error.  */
10171 #ifdef __cplusplus
10172 extern "C"
10173 {
10174 #endif
10175 /* We use char because int might match the return type of a gcc2
10176    builtin and then its argument prototype would still apply.  */
10177 char $ac_func ();
10178 /* The GNU C library defines this for functions which it implements
10179     to always fail with ENOSYS.  Some functions are actually named
10180     something starting with __ and the normal name is an alias.  */
10181 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10182 choke me
10183 #else
10184 char (*f) () = $ac_func;
10185 #endif
10186 #ifdef __cplusplus
10187 }
10188 #endif
10189
10190 int
10191 main ()
10192 {
10193 return f != $ac_func;
10194   ;
10195   return 0;
10196 }
10197 _ACEOF
10198 rm -f conftest.$ac_objext conftest$ac_exeext
10199 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10200   (eval $ac_link) 2>conftest.er1
10201   ac_status=$?
10202   grep -v '^ *+' conftest.er1 >conftest.err
10203   rm -f conftest.er1
10204   cat conftest.err >&5
10205   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10206   (exit $ac_status); } &&
10207          { ac_try='test -z "$ac_c_werror_flag"
10208                          || test ! -s conftest.err'
10209   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10210   (eval $ac_try) 2>&5
10211   ac_status=$?
10212   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10213   (exit $ac_status); }; } &&
10214          { ac_try='test -s conftest$ac_exeext'
10215   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10216   (eval $ac_try) 2>&5
10217   ac_status=$?
10218   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10219   (exit $ac_status); }; }; then
10220   eval "$as_ac_var=yes"
10221 else
10222   echo "$as_me: failed program was:" >&5
10223 sed 's/^/| /' conftest.$ac_ext >&5
10224
10225 eval "$as_ac_var=no"
10226 fi
10227 rm -f conftest.err conftest.$ac_objext \
10228       conftest$ac_exeext conftest.$ac_ext
10229 fi
10230 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10231 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10232 if test `eval echo '${'$as_ac_var'}'` = yes; then
10233   cat >>confdefs.h <<_ACEOF
10234 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10235 _ACEOF
10236
10237 fi
10238 done
10239
10240
10241
10242
10243
10244
10245
10246
10247
10248 for ac_func in chdir strerror getlogin gethostname kill link symlink perror
10249 do
10250 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10251 echo "$as_me:$LINENO: checking for $ac_func" >&5
10252 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10253 if eval "test \"\${$as_ac_var+set}\" = set"; then
10254   echo $ECHO_N "(cached) $ECHO_C" >&6
10255 else
10256   if test x$gcc_no_link = xyes; then
10257   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10258 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10259    { (exit 1); exit 1; }; }
10260 fi
10261 cat >conftest.$ac_ext <<_ACEOF
10262 /* confdefs.h.  */
10263 _ACEOF
10264 cat confdefs.h >>conftest.$ac_ext
10265 cat >>conftest.$ac_ext <<_ACEOF
10266 /* end confdefs.h.  */
10267 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10268    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10269 #define $ac_func innocuous_$ac_func
10270
10271 /* System header to define __stub macros and hopefully few prototypes,
10272     which can conflict with char $ac_func (); below.
10273     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10274     <limits.h> exists even on freestanding compilers.  */
10275
10276 #ifdef __STDC__
10277 # include <limits.h>
10278 #else
10279 # include <assert.h>
10280 #endif
10281
10282 #undef $ac_func
10283
10284 /* Override any gcc2 internal prototype to avoid an error.  */
10285 #ifdef __cplusplus
10286 extern "C"
10287 {
10288 #endif
10289 /* We use char because int might match the return type of a gcc2
10290    builtin and then its argument prototype would still apply.  */
10291 char $ac_func ();
10292 /* The GNU C library defines this for functions which it implements
10293     to always fail with ENOSYS.  Some functions are actually named
10294     something starting with __ and the normal name is an alias.  */
10295 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10296 choke me
10297 #else
10298 char (*f) () = $ac_func;
10299 #endif
10300 #ifdef __cplusplus
10301 }
10302 #endif
10303
10304 int
10305 main ()
10306 {
10307 return f != $ac_func;
10308   ;
10309   return 0;
10310 }
10311 _ACEOF
10312 rm -f conftest.$ac_objext conftest$ac_exeext
10313 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10314   (eval $ac_link) 2>conftest.er1
10315   ac_status=$?
10316   grep -v '^ *+' conftest.er1 >conftest.err
10317   rm -f conftest.er1
10318   cat conftest.err >&5
10319   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10320   (exit $ac_status); } &&
10321          { ac_try='test -z "$ac_c_werror_flag"
10322                          || test ! -s conftest.err'
10323   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10324   (eval $ac_try) 2>&5
10325   ac_status=$?
10326   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10327   (exit $ac_status); }; } &&
10328          { ac_try='test -s conftest$ac_exeext'
10329   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10330   (eval $ac_try) 2>&5
10331   ac_status=$?
10332   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10333   (exit $ac_status); }; }; then
10334   eval "$as_ac_var=yes"
10335 else
10336   echo "$as_me: failed program was:" >&5
10337 sed 's/^/| /' conftest.$ac_ext >&5
10338
10339 eval "$as_ac_var=no"
10340 fi
10341 rm -f conftest.err conftest.$ac_objext \
10342       conftest$ac_exeext conftest.$ac_ext
10343 fi
10344 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10345 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10346 if test `eval echo '${'$as_ac_var'}'` = yes; then
10347   cat >>confdefs.h <<_ACEOF
10348 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10349 _ACEOF
10350
10351 fi
10352 done
10353
10354
10355
10356
10357
10358
10359
10360
10361
10362
10363
10364 for ac_func in sleep time ttyname signal alarm ctime clock access fork execl
10365 do
10366 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10367 echo "$as_me:$LINENO: checking for $ac_func" >&5
10368 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10369 if eval "test \"\${$as_ac_var+set}\" = set"; then
10370   echo $ECHO_N "(cached) $ECHO_C" >&6
10371 else
10372   if test x$gcc_no_link = xyes; then
10373   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10374 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10375    { (exit 1); exit 1; }; }
10376 fi
10377 cat >conftest.$ac_ext <<_ACEOF
10378 /* confdefs.h.  */
10379 _ACEOF
10380 cat confdefs.h >>conftest.$ac_ext
10381 cat >>conftest.$ac_ext <<_ACEOF
10382 /* end confdefs.h.  */
10383 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10384    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10385 #define $ac_func innocuous_$ac_func
10386
10387 /* System header to define __stub macros and hopefully few prototypes,
10388     which can conflict with char $ac_func (); below.
10389     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10390     <limits.h> exists even on freestanding compilers.  */
10391
10392 #ifdef __STDC__
10393 # include <limits.h>
10394 #else
10395 # include <assert.h>
10396 #endif
10397
10398 #undef $ac_func
10399
10400 /* Override any gcc2 internal prototype to avoid an error.  */
10401 #ifdef __cplusplus
10402 extern "C"
10403 {
10404 #endif
10405 /* We use char because int might match the return type of a gcc2
10406    builtin and then its argument prototype would still apply.  */
10407 char $ac_func ();
10408 /* The GNU C library defines this for functions which it implements
10409     to always fail with ENOSYS.  Some functions are actually named
10410     something starting with __ and the normal name is an alias.  */
10411 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10412 choke me
10413 #else
10414 char (*f) () = $ac_func;
10415 #endif
10416 #ifdef __cplusplus
10417 }
10418 #endif
10419
10420 int
10421 main ()
10422 {
10423 return f != $ac_func;
10424   ;
10425   return 0;
10426 }
10427 _ACEOF
10428 rm -f conftest.$ac_objext conftest$ac_exeext
10429 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10430   (eval $ac_link) 2>conftest.er1
10431   ac_status=$?
10432   grep -v '^ *+' conftest.er1 >conftest.err
10433   rm -f conftest.er1
10434   cat conftest.err >&5
10435   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10436   (exit $ac_status); } &&
10437          { ac_try='test -z "$ac_c_werror_flag"
10438                          || test ! -s conftest.err'
10439   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10440   (eval $ac_try) 2>&5
10441   ac_status=$?
10442   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10443   (exit $ac_status); }; } &&
10444          { ac_try='test -s conftest$ac_exeext'
10445   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10446   (eval $ac_try) 2>&5
10447   ac_status=$?
10448   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10449   (exit $ac_status); }; }; then
10450   eval "$as_ac_var=yes"
10451 else
10452   echo "$as_me: failed program was:" >&5
10453 sed 's/^/| /' conftest.$ac_ext >&5
10454
10455 eval "$as_ac_var=no"
10456 fi
10457 rm -f conftest.err conftest.$ac_objext \
10458       conftest$ac_exeext conftest.$ac_ext
10459 fi
10460 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10461 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10462 if test `eval echo '${'$as_ac_var'}'` = yes; then
10463   cat >>confdefs.h <<_ACEOF
10464 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10465 _ACEOF
10466
10467 fi
10468 done
10469
10470
10471
10472
10473
10474
10475
10476
10477
10478
10479 for ac_func in wait setmode execvp pipe dup2 close fdopen strcasestr getrlimit
10480 do
10481 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10482 echo "$as_me:$LINENO: checking for $ac_func" >&5
10483 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10484 if eval "test \"\${$as_ac_var+set}\" = set"; then
10485   echo $ECHO_N "(cached) $ECHO_C" >&6
10486 else
10487   if test x$gcc_no_link = xyes; then
10488   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10489 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10490    { (exit 1); exit 1; }; }
10491 fi
10492 cat >conftest.$ac_ext <<_ACEOF
10493 /* confdefs.h.  */
10494 _ACEOF
10495 cat confdefs.h >>conftest.$ac_ext
10496 cat >>conftest.$ac_ext <<_ACEOF
10497 /* end confdefs.h.  */
10498 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10499    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10500 #define $ac_func innocuous_$ac_func
10501
10502 /* System header to define __stub macros and hopefully few prototypes,
10503     which can conflict with char $ac_func (); below.
10504     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10505     <limits.h> exists even on freestanding compilers.  */
10506
10507 #ifdef __STDC__
10508 # include <limits.h>
10509 #else
10510 # include <assert.h>
10511 #endif
10512
10513 #undef $ac_func
10514
10515 /* Override any gcc2 internal prototype to avoid an error.  */
10516 #ifdef __cplusplus
10517 extern "C"
10518 {
10519 #endif
10520 /* We use char because int might match the return type of a gcc2
10521    builtin and then its argument prototype would still apply.  */
10522 char $ac_func ();
10523 /* The GNU C library defines this for functions which it implements
10524     to always fail with ENOSYS.  Some functions are actually named
10525     something starting with __ and the normal name is an alias.  */
10526 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10527 choke me
10528 #else
10529 char (*f) () = $ac_func;
10530 #endif
10531 #ifdef __cplusplus
10532 }
10533 #endif
10534
10535 int
10536 main ()
10537 {
10538 return f != $ac_func;
10539   ;
10540   return 0;
10541 }
10542 _ACEOF
10543 rm -f conftest.$ac_objext conftest$ac_exeext
10544 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10545   (eval $ac_link) 2>conftest.er1
10546   ac_status=$?
10547   grep -v '^ *+' conftest.er1 >conftest.err
10548   rm -f conftest.er1
10549   cat conftest.err >&5
10550   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10551   (exit $ac_status); } &&
10552          { ac_try='test -z "$ac_c_werror_flag"
10553                          || test ! -s conftest.err'
10554   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10555   (eval $ac_try) 2>&5
10556   ac_status=$?
10557   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10558   (exit $ac_status); }; } &&
10559          { ac_try='test -s conftest$ac_exeext'
10560   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10561   (eval $ac_try) 2>&5
10562   ac_status=$?
10563   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10564   (exit $ac_status); }; }; then
10565   eval "$as_ac_var=yes"
10566 else
10567   echo "$as_me: failed program was:" >&5
10568 sed 's/^/| /' conftest.$ac_ext >&5
10569
10570 eval "$as_ac_var=no"
10571 fi
10572 rm -f conftest.err conftest.$ac_objext \
10573       conftest$ac_exeext conftest.$ac_ext
10574 fi
10575 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10576 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10577 if test `eval echo '${'$as_ac_var'}'` = yes; then
10578   cat >>confdefs.h <<_ACEOF
10579 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10580 _ACEOF
10581
10582 fi
10583 done
10584
10585
10586
10587
10588
10589
10590 for ac_func in gettimeofday stat fstat lstat getpwuid
10591 do
10592 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10593 echo "$as_me:$LINENO: checking for $ac_func" >&5
10594 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10595 if eval "test \"\${$as_ac_var+set}\" = set"; then
10596   echo $ECHO_N "(cached) $ECHO_C" >&6
10597 else
10598   if test x$gcc_no_link = xyes; then
10599   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10600 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10601    { (exit 1); exit 1; }; }
10602 fi
10603 cat >conftest.$ac_ext <<_ACEOF
10604 /* confdefs.h.  */
10605 _ACEOF
10606 cat confdefs.h >>conftest.$ac_ext
10607 cat >>conftest.$ac_ext <<_ACEOF
10608 /* end confdefs.h.  */
10609 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10610    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10611 #define $ac_func innocuous_$ac_func
10612
10613 /* System header to define __stub macros and hopefully few prototypes,
10614     which can conflict with char $ac_func (); below.
10615     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10616     <limits.h> exists even on freestanding compilers.  */
10617
10618 #ifdef __STDC__
10619 # include <limits.h>
10620 #else
10621 # include <assert.h>
10622 #endif
10623
10624 #undef $ac_func
10625
10626 /* Override any gcc2 internal prototype to avoid an error.  */
10627 #ifdef __cplusplus
10628 extern "C"
10629 {
10630 #endif
10631 /* We use char because int might match the return type of a gcc2
10632    builtin and then its argument prototype would still apply.  */
10633 char $ac_func ();
10634 /* The GNU C library defines this for functions which it implements
10635     to always fail with ENOSYS.  Some functions are actually named
10636     something starting with __ and the normal name is an alias.  */
10637 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10638 choke me
10639 #else
10640 char (*f) () = $ac_func;
10641 #endif
10642 #ifdef __cplusplus
10643 }
10644 #endif
10645
10646 int
10647 main ()
10648 {
10649 return f != $ac_func;
10650   ;
10651   return 0;
10652 }
10653 _ACEOF
10654 rm -f conftest.$ac_objext conftest$ac_exeext
10655 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10656   (eval $ac_link) 2>conftest.er1
10657   ac_status=$?
10658   grep -v '^ *+' conftest.er1 >conftest.err
10659   rm -f conftest.er1
10660   cat conftest.err >&5
10661   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10662   (exit $ac_status); } &&
10663          { ac_try='test -z "$ac_c_werror_flag"
10664                          || test ! -s conftest.err'
10665   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10666   (eval $ac_try) 2>&5
10667   ac_status=$?
10668   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10669   (exit $ac_status); }; } &&
10670          { ac_try='test -s conftest$ac_exeext'
10671   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10672   (eval $ac_try) 2>&5
10673   ac_status=$?
10674   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10675   (exit $ac_status); }; }; then
10676   eval "$as_ac_var=yes"
10677 else
10678   echo "$as_me: failed program was:" >&5
10679 sed 's/^/| /' conftest.$ac_ext >&5
10680
10681 eval "$as_ac_var=no"
10682 fi
10683 rm -f conftest.err conftest.$ac_objext \
10684       conftest$ac_exeext conftest.$ac_ext
10685 fi
10686 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10687 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10688 if test `eval echo '${'$as_ac_var'}'` = yes; then
10689   cat >>confdefs.h <<_ACEOF
10690 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10691 _ACEOF
10692
10693 fi
10694 done
10695
10696
10697 # Check for glibc backtrace functions
10698
10699
10700 for ac_func in backtrace backtrace_symbols
10701 do
10702 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10703 echo "$as_me:$LINENO: checking for $ac_func" >&5
10704 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10705 if eval "test \"\${$as_ac_var+set}\" = set"; then
10706   echo $ECHO_N "(cached) $ECHO_C" >&6
10707 else
10708   if test x$gcc_no_link = xyes; then
10709   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10710 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10711    { (exit 1); exit 1; }; }
10712 fi
10713 cat >conftest.$ac_ext <<_ACEOF
10714 /* confdefs.h.  */
10715 _ACEOF
10716 cat confdefs.h >>conftest.$ac_ext
10717 cat >>conftest.$ac_ext <<_ACEOF
10718 /* end confdefs.h.  */
10719 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10720    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10721 #define $ac_func innocuous_$ac_func
10722
10723 /* System header to define __stub macros and hopefully few prototypes,
10724     which can conflict with char $ac_func (); below.
10725     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10726     <limits.h> exists even on freestanding compilers.  */
10727
10728 #ifdef __STDC__
10729 # include <limits.h>
10730 #else
10731 # include <assert.h>
10732 #endif
10733
10734 #undef $ac_func
10735
10736 /* Override any gcc2 internal prototype to avoid an error.  */
10737 #ifdef __cplusplus
10738 extern "C"
10739 {
10740 #endif
10741 /* We use char because int might match the return type of a gcc2
10742    builtin and then its argument prototype would still apply.  */
10743 char $ac_func ();
10744 /* The GNU C library defines this for functions which it implements
10745     to always fail with ENOSYS.  Some functions are actually named
10746     something starting with __ and the normal name is an alias.  */
10747 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10748 choke me
10749 #else
10750 char (*f) () = $ac_func;
10751 #endif
10752 #ifdef __cplusplus
10753 }
10754 #endif
10755
10756 int
10757 main ()
10758 {
10759 return f != $ac_func;
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   eval "$as_ac_var=yes"
10787 else
10788   echo "$as_me: failed program was:" >&5
10789 sed 's/^/| /' conftest.$ac_ext >&5
10790
10791 eval "$as_ac_var=no"
10792 fi
10793 rm -f conftest.err conftest.$ac_objext \
10794       conftest$ac_exeext conftest.$ac_ext
10795 fi
10796 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10797 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10798 if test `eval echo '${'$as_ac_var'}'` = yes; then
10799   cat >>confdefs.h <<_ACEOF
10800 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10801 _ACEOF
10802
10803 fi
10804 done
10805
10806
10807 # Check for types
10808 echo "$as_me:$LINENO: checking for intptr_t" >&5
10809 echo $ECHO_N "checking for intptr_t... $ECHO_C" >&6
10810 if test "${ac_cv_type_intptr_t+set}" = set; then
10811   echo $ECHO_N "(cached) $ECHO_C" >&6
10812 else
10813   cat >conftest.$ac_ext <<_ACEOF
10814 /* confdefs.h.  */
10815 _ACEOF
10816 cat confdefs.h >>conftest.$ac_ext
10817 cat >>conftest.$ac_ext <<_ACEOF
10818 /* end confdefs.h.  */
10819 $ac_includes_default
10820 int
10821 main ()
10822 {
10823 if ((intptr_t *) 0)
10824   return 0;
10825 if (sizeof (intptr_t))
10826   return 0;
10827   ;
10828   return 0;
10829 }
10830 _ACEOF
10831 rm -f conftest.$ac_objext
10832 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10833   (eval $ac_compile) 2>conftest.er1
10834   ac_status=$?
10835   grep -v '^ *+' conftest.er1 >conftest.err
10836   rm -f conftest.er1
10837   cat conftest.err >&5
10838   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10839   (exit $ac_status); } &&
10840          { ac_try='test -z "$ac_c_werror_flag"
10841                          || test ! -s conftest.err'
10842   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10843   (eval $ac_try) 2>&5
10844   ac_status=$?
10845   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10846   (exit $ac_status); }; } &&
10847          { ac_try='test -s conftest.$ac_objext'
10848   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10849   (eval $ac_try) 2>&5
10850   ac_status=$?
10851   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10852   (exit $ac_status); }; }; then
10853   ac_cv_type_intptr_t=yes
10854 else
10855   echo "$as_me: failed program was:" >&5
10856 sed 's/^/| /' conftest.$ac_ext >&5
10857
10858 ac_cv_type_intptr_t=no
10859 fi
10860 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10861 fi
10862 echo "$as_me:$LINENO: result: $ac_cv_type_intptr_t" >&5
10863 echo "${ECHO_T}$ac_cv_type_intptr_t" >&6
10864 if test $ac_cv_type_intptr_t = yes; then
10865
10866 cat >>confdefs.h <<_ACEOF
10867 #define HAVE_INTPTR_T 1
10868 _ACEOF
10869
10870
10871 fi
10872
10873
10874 # Check libc for getgid, getpid, getuid
10875 echo "$as_me:$LINENO: checking for getgid in -lc" >&5
10876 echo $ECHO_N "checking for getgid in -lc... $ECHO_C" >&6
10877 if test "${ac_cv_lib_c_getgid+set}" = set; then
10878   echo $ECHO_N "(cached) $ECHO_C" >&6
10879 else
10880   ac_check_lib_save_LIBS=$LIBS
10881 LIBS="-lc  $LIBS"
10882 if test x$gcc_no_link = xyes; then
10883   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10884 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10885    { (exit 1); exit 1; }; }
10886 fi
10887 cat >conftest.$ac_ext <<_ACEOF
10888 /* confdefs.h.  */
10889 _ACEOF
10890 cat confdefs.h >>conftest.$ac_ext
10891 cat >>conftest.$ac_ext <<_ACEOF
10892 /* end confdefs.h.  */
10893
10894 /* Override any gcc2 internal prototype to avoid an error.  */
10895 #ifdef __cplusplus
10896 extern "C"
10897 #endif
10898 /* We use char because int might match the return type of a gcc2
10899    builtin and then its argument prototype would still apply.  */
10900 char getgid ();
10901 int
10902 main ()
10903 {
10904 getgid ();
10905   ;
10906   return 0;
10907 }
10908 _ACEOF
10909 rm -f conftest.$ac_objext conftest$ac_exeext
10910 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10911   (eval $ac_link) 2>conftest.er1
10912   ac_status=$?
10913   grep -v '^ *+' conftest.er1 >conftest.err
10914   rm -f conftest.er1
10915   cat conftest.err >&5
10916   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10917   (exit $ac_status); } &&
10918          { ac_try='test -z "$ac_c_werror_flag"
10919                          || test ! -s conftest.err'
10920   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10921   (eval $ac_try) 2>&5
10922   ac_status=$?
10923   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10924   (exit $ac_status); }; } &&
10925          { ac_try='test -s conftest$ac_exeext'
10926   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10927   (eval $ac_try) 2>&5
10928   ac_status=$?
10929   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10930   (exit $ac_status); }; }; then
10931   ac_cv_lib_c_getgid=yes
10932 else
10933   echo "$as_me: failed program was:" >&5
10934 sed 's/^/| /' conftest.$ac_ext >&5
10935
10936 ac_cv_lib_c_getgid=no
10937 fi
10938 rm -f conftest.err conftest.$ac_objext \
10939       conftest$ac_exeext conftest.$ac_ext
10940 LIBS=$ac_check_lib_save_LIBS
10941 fi
10942 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getgid" >&5
10943 echo "${ECHO_T}$ac_cv_lib_c_getgid" >&6
10944 if test $ac_cv_lib_c_getgid = yes; then
10945
10946 cat >>confdefs.h <<\_ACEOF
10947 #define HAVE_GETGID 1
10948 _ACEOF
10949
10950 fi
10951
10952 echo "$as_me:$LINENO: checking for getpid in -lc" >&5
10953 echo $ECHO_N "checking for getpid in -lc... $ECHO_C" >&6
10954 if test "${ac_cv_lib_c_getpid+set}" = set; then
10955   echo $ECHO_N "(cached) $ECHO_C" >&6
10956 else
10957   ac_check_lib_save_LIBS=$LIBS
10958 LIBS="-lc  $LIBS"
10959 if test x$gcc_no_link = xyes; then
10960   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10961 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10962    { (exit 1); exit 1; }; }
10963 fi
10964 cat >conftest.$ac_ext <<_ACEOF
10965 /* confdefs.h.  */
10966 _ACEOF
10967 cat confdefs.h >>conftest.$ac_ext
10968 cat >>conftest.$ac_ext <<_ACEOF
10969 /* end confdefs.h.  */
10970
10971 /* Override any gcc2 internal prototype to avoid an error.  */
10972 #ifdef __cplusplus
10973 extern "C"
10974 #endif
10975 /* We use char because int might match the return type of a gcc2
10976    builtin and then its argument prototype would still apply.  */
10977 char getpid ();
10978 int
10979 main ()
10980 {
10981 getpid ();
10982   ;
10983   return 0;
10984 }
10985 _ACEOF
10986 rm -f conftest.$ac_objext conftest$ac_exeext
10987 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10988   (eval $ac_link) 2>conftest.er1
10989   ac_status=$?
10990   grep -v '^ *+' conftest.er1 >conftest.err
10991   rm -f conftest.er1
10992   cat conftest.err >&5
10993   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10994   (exit $ac_status); } &&
10995          { ac_try='test -z "$ac_c_werror_flag"
10996                          || test ! -s conftest.err'
10997   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10998   (eval $ac_try) 2>&5
10999   ac_status=$?
11000   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11001   (exit $ac_status); }; } &&
11002          { ac_try='test -s conftest$ac_exeext'
11003   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11004   (eval $ac_try) 2>&5
11005   ac_status=$?
11006   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11007   (exit $ac_status); }; }; then
11008   ac_cv_lib_c_getpid=yes
11009 else
11010   echo "$as_me: failed program was:" >&5
11011 sed 's/^/| /' conftest.$ac_ext >&5
11012
11013 ac_cv_lib_c_getpid=no
11014 fi
11015 rm -f conftest.err conftest.$ac_objext \
11016       conftest$ac_exeext conftest.$ac_ext
11017 LIBS=$ac_check_lib_save_LIBS
11018 fi
11019 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getpid" >&5
11020 echo "${ECHO_T}$ac_cv_lib_c_getpid" >&6
11021 if test $ac_cv_lib_c_getpid = yes; then
11022
11023 cat >>confdefs.h <<\_ACEOF
11024 #define HAVE_GETPID 1
11025 _ACEOF
11026
11027 fi
11028
11029 echo "$as_me:$LINENO: checking for getppid in -lc" >&5
11030 echo $ECHO_N "checking for getppid in -lc... $ECHO_C" >&6
11031 if test "${ac_cv_lib_c_getppid+set}" = set; then
11032   echo $ECHO_N "(cached) $ECHO_C" >&6
11033 else
11034   ac_check_lib_save_LIBS=$LIBS
11035 LIBS="-lc  $LIBS"
11036 if test x$gcc_no_link = xyes; then
11037   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11038 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11039    { (exit 1); exit 1; }; }
11040 fi
11041 cat >conftest.$ac_ext <<_ACEOF
11042 /* confdefs.h.  */
11043 _ACEOF
11044 cat confdefs.h >>conftest.$ac_ext
11045 cat >>conftest.$ac_ext <<_ACEOF
11046 /* end confdefs.h.  */
11047
11048 /* Override any gcc2 internal prototype to avoid an error.  */
11049 #ifdef __cplusplus
11050 extern "C"
11051 #endif
11052 /* We use char because int might match the return type of a gcc2
11053    builtin and then its argument prototype would still apply.  */
11054 char getppid ();
11055 int
11056 main ()
11057 {
11058 getppid ();
11059   ;
11060   return 0;
11061 }
11062 _ACEOF
11063 rm -f conftest.$ac_objext conftest$ac_exeext
11064 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11065   (eval $ac_link) 2>conftest.er1
11066   ac_status=$?
11067   grep -v '^ *+' conftest.er1 >conftest.err
11068   rm -f conftest.er1
11069   cat conftest.err >&5
11070   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11071   (exit $ac_status); } &&
11072          { ac_try='test -z "$ac_c_werror_flag"
11073                          || test ! -s conftest.err'
11074   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11075   (eval $ac_try) 2>&5
11076   ac_status=$?
11077   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11078   (exit $ac_status); }; } &&
11079          { ac_try='test -s conftest$ac_exeext'
11080   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11081   (eval $ac_try) 2>&5
11082   ac_status=$?
11083   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11084   (exit $ac_status); }; }; then
11085   ac_cv_lib_c_getppid=yes
11086 else
11087   echo "$as_me: failed program was:" >&5
11088 sed 's/^/| /' conftest.$ac_ext >&5
11089
11090 ac_cv_lib_c_getppid=no
11091 fi
11092 rm -f conftest.err conftest.$ac_objext \
11093       conftest$ac_exeext conftest.$ac_ext
11094 LIBS=$ac_check_lib_save_LIBS
11095 fi
11096 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getppid" >&5
11097 echo "${ECHO_T}$ac_cv_lib_c_getppid" >&6
11098 if test $ac_cv_lib_c_getppid = yes; then
11099
11100 cat >>confdefs.h <<\_ACEOF
11101 #define HAVE_GETPPID 1
11102 _ACEOF
11103
11104 fi
11105
11106 echo "$as_me:$LINENO: checking for getuid in -lc" >&5
11107 echo $ECHO_N "checking for getuid in -lc... $ECHO_C" >&6
11108 if test "${ac_cv_lib_c_getuid+set}" = set; then
11109   echo $ECHO_N "(cached) $ECHO_C" >&6
11110 else
11111   ac_check_lib_save_LIBS=$LIBS
11112 LIBS="-lc  $LIBS"
11113 if test x$gcc_no_link = xyes; then
11114   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11115 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11116    { (exit 1); exit 1; }; }
11117 fi
11118 cat >conftest.$ac_ext <<_ACEOF
11119 /* confdefs.h.  */
11120 _ACEOF
11121 cat confdefs.h >>conftest.$ac_ext
11122 cat >>conftest.$ac_ext <<_ACEOF
11123 /* end confdefs.h.  */
11124
11125 /* Override any gcc2 internal prototype to avoid an error.  */
11126 #ifdef __cplusplus
11127 extern "C"
11128 #endif
11129 /* We use char because int might match the return type of a gcc2
11130    builtin and then its argument prototype would still apply.  */
11131 char getuid ();
11132 int
11133 main ()
11134 {
11135 getuid ();
11136   ;
11137   return 0;
11138 }
11139 _ACEOF
11140 rm -f conftest.$ac_objext conftest$ac_exeext
11141 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11142   (eval $ac_link) 2>conftest.er1
11143   ac_status=$?
11144   grep -v '^ *+' conftest.er1 >conftest.err
11145   rm -f conftest.er1
11146   cat conftest.err >&5
11147   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11148   (exit $ac_status); } &&
11149          { ac_try='test -z "$ac_c_werror_flag"
11150                          || test ! -s conftest.err'
11151   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11152   (eval $ac_try) 2>&5
11153   ac_status=$?
11154   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11155   (exit $ac_status); }; } &&
11156          { ac_try='test -s conftest$ac_exeext'
11157   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11158   (eval $ac_try) 2>&5
11159   ac_status=$?
11160   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11161   (exit $ac_status); }; }; then
11162   ac_cv_lib_c_getuid=yes
11163 else
11164   echo "$as_me: failed program was:" >&5
11165 sed 's/^/| /' conftest.$ac_ext >&5
11166
11167 ac_cv_lib_c_getuid=no
11168 fi
11169 rm -f conftest.err conftest.$ac_objext \
11170       conftest$ac_exeext conftest.$ac_ext
11171 LIBS=$ac_check_lib_save_LIBS
11172 fi
11173 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getuid" >&5
11174 echo "${ECHO_T}$ac_cv_lib_c_getuid" >&6
11175 if test $ac_cv_lib_c_getuid = yes; then
11176
11177 cat >>confdefs.h <<\_ACEOF
11178 #define HAVE_GETUID 1
11179 _ACEOF
11180
11181 fi
11182
11183 echo "$as_me:$LINENO: checking for geteuid in -lc" >&5
11184 echo $ECHO_N "checking for geteuid in -lc... $ECHO_C" >&6
11185 if test "${ac_cv_lib_c_geteuid+set}" = set; then
11186   echo $ECHO_N "(cached) $ECHO_C" >&6
11187 else
11188   ac_check_lib_save_LIBS=$LIBS
11189 LIBS="-lc  $LIBS"
11190 if test x$gcc_no_link = xyes; then
11191   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11192 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11193    { (exit 1); exit 1; }; }
11194 fi
11195 cat >conftest.$ac_ext <<_ACEOF
11196 /* confdefs.h.  */
11197 _ACEOF
11198 cat confdefs.h >>conftest.$ac_ext
11199 cat >>conftest.$ac_ext <<_ACEOF
11200 /* end confdefs.h.  */
11201
11202 /* Override any gcc2 internal prototype to avoid an error.  */
11203 #ifdef __cplusplus
11204 extern "C"
11205 #endif
11206 /* We use char because int might match the return type of a gcc2
11207    builtin and then its argument prototype would still apply.  */
11208 char geteuid ();
11209 int
11210 main ()
11211 {
11212 geteuid ();
11213   ;
11214   return 0;
11215 }
11216 _ACEOF
11217 rm -f conftest.$ac_objext conftest$ac_exeext
11218 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11219   (eval $ac_link) 2>conftest.er1
11220   ac_status=$?
11221   grep -v '^ *+' conftest.er1 >conftest.err
11222   rm -f conftest.er1
11223   cat conftest.err >&5
11224   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11225   (exit $ac_status); } &&
11226          { ac_try='test -z "$ac_c_werror_flag"
11227                          || test ! -s conftest.err'
11228   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11229   (eval $ac_try) 2>&5
11230   ac_status=$?
11231   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11232   (exit $ac_status); }; } &&
11233          { ac_try='test -s conftest$ac_exeext'
11234   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11235   (eval $ac_try) 2>&5
11236   ac_status=$?
11237   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11238   (exit $ac_status); }; }; then
11239   ac_cv_lib_c_geteuid=yes
11240 else
11241   echo "$as_me: failed program was:" >&5
11242 sed 's/^/| /' conftest.$ac_ext >&5
11243
11244 ac_cv_lib_c_geteuid=no
11245 fi
11246 rm -f conftest.err conftest.$ac_objext \
11247       conftest$ac_exeext conftest.$ac_ext
11248 LIBS=$ac_check_lib_save_LIBS
11249 fi
11250 echo "$as_me:$LINENO: result: $ac_cv_lib_c_geteuid" >&5
11251 echo "${ECHO_T}$ac_cv_lib_c_geteuid" >&6
11252 if test $ac_cv_lib_c_geteuid = yes; then
11253
11254 cat >>confdefs.h <<\_ACEOF
11255 #define HAVE_GETEUID 1
11256 _ACEOF
11257
11258 fi
11259
11260
11261 # Check for C99 (and other IEEE) math functions
11262 echo "$as_me:$LINENO: checking for acosf in -lm" >&5
11263 echo $ECHO_N "checking for acosf in -lm... $ECHO_C" >&6
11264 if test "${ac_cv_lib_m_acosf+set}" = set; then
11265   echo $ECHO_N "(cached) $ECHO_C" >&6
11266 else
11267   ac_check_lib_save_LIBS=$LIBS
11268 LIBS="-lm  $LIBS"
11269 if test x$gcc_no_link = xyes; then
11270   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11271 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11272    { (exit 1); exit 1; }; }
11273 fi
11274 cat >conftest.$ac_ext <<_ACEOF
11275 /* confdefs.h.  */
11276 _ACEOF
11277 cat confdefs.h >>conftest.$ac_ext
11278 cat >>conftest.$ac_ext <<_ACEOF
11279 /* end confdefs.h.  */
11280
11281 /* Override any gcc2 internal prototype to avoid an error.  */
11282 #ifdef __cplusplus
11283 extern "C"
11284 #endif
11285 /* We use char because int might match the return type of a gcc2
11286    builtin and then its argument prototype would still apply.  */
11287 char acosf ();
11288 int
11289 main ()
11290 {
11291 acosf ();
11292   ;
11293   return 0;
11294 }
11295 _ACEOF
11296 rm -f conftest.$ac_objext conftest$ac_exeext
11297 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11298   (eval $ac_link) 2>conftest.er1
11299   ac_status=$?
11300   grep -v '^ *+' conftest.er1 >conftest.err
11301   rm -f conftest.er1
11302   cat conftest.err >&5
11303   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11304   (exit $ac_status); } &&
11305          { ac_try='test -z "$ac_c_werror_flag"
11306                          || test ! -s conftest.err'
11307   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11308   (eval $ac_try) 2>&5
11309   ac_status=$?
11310   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11311   (exit $ac_status); }; } &&
11312          { ac_try='test -s conftest$ac_exeext'
11313   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11314   (eval $ac_try) 2>&5
11315   ac_status=$?
11316   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11317   (exit $ac_status); }; }; then
11318   ac_cv_lib_m_acosf=yes
11319 else
11320   echo "$as_me: failed program was:" >&5
11321 sed 's/^/| /' conftest.$ac_ext >&5
11322
11323 ac_cv_lib_m_acosf=no
11324 fi
11325 rm -f conftest.err conftest.$ac_objext \
11326       conftest$ac_exeext conftest.$ac_ext
11327 LIBS=$ac_check_lib_save_LIBS
11328 fi
11329 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosf" >&5
11330 echo "${ECHO_T}$ac_cv_lib_m_acosf" >&6
11331 if test $ac_cv_lib_m_acosf = yes; then
11332
11333 cat >>confdefs.h <<\_ACEOF
11334 #define HAVE_ACOSF 1
11335 _ACEOF
11336
11337 fi
11338
11339 echo "$as_me:$LINENO: checking for acos in -lm" >&5
11340 echo $ECHO_N "checking for acos in -lm... $ECHO_C" >&6
11341 if test "${ac_cv_lib_m_acos+set}" = set; then
11342   echo $ECHO_N "(cached) $ECHO_C" >&6
11343 else
11344   ac_check_lib_save_LIBS=$LIBS
11345 LIBS="-lm  $LIBS"
11346 if test x$gcc_no_link = xyes; then
11347   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11348 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11349    { (exit 1); exit 1; }; }
11350 fi
11351 cat >conftest.$ac_ext <<_ACEOF
11352 /* confdefs.h.  */
11353 _ACEOF
11354 cat confdefs.h >>conftest.$ac_ext
11355 cat >>conftest.$ac_ext <<_ACEOF
11356 /* end confdefs.h.  */
11357
11358 /* Override any gcc2 internal prototype to avoid an error.  */
11359 #ifdef __cplusplus
11360 extern "C"
11361 #endif
11362 /* We use char because int might match the return type of a gcc2
11363    builtin and then its argument prototype would still apply.  */
11364 char acos ();
11365 int
11366 main ()
11367 {
11368 acos ();
11369   ;
11370   return 0;
11371 }
11372 _ACEOF
11373 rm -f conftest.$ac_objext conftest$ac_exeext
11374 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11375   (eval $ac_link) 2>conftest.er1
11376   ac_status=$?
11377   grep -v '^ *+' conftest.er1 >conftest.err
11378   rm -f conftest.er1
11379   cat conftest.err >&5
11380   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11381   (exit $ac_status); } &&
11382          { ac_try='test -z "$ac_c_werror_flag"
11383                          || test ! -s conftest.err'
11384   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11385   (eval $ac_try) 2>&5
11386   ac_status=$?
11387   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11388   (exit $ac_status); }; } &&
11389          { ac_try='test -s conftest$ac_exeext'
11390   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11391   (eval $ac_try) 2>&5
11392   ac_status=$?
11393   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11394   (exit $ac_status); }; }; then
11395   ac_cv_lib_m_acos=yes
11396 else
11397   echo "$as_me: failed program was:" >&5
11398 sed 's/^/| /' conftest.$ac_ext >&5
11399
11400 ac_cv_lib_m_acos=no
11401 fi
11402 rm -f conftest.err conftest.$ac_objext \
11403       conftest$ac_exeext conftest.$ac_ext
11404 LIBS=$ac_check_lib_save_LIBS
11405 fi
11406 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acos" >&5
11407 echo "${ECHO_T}$ac_cv_lib_m_acos" >&6
11408 if test $ac_cv_lib_m_acos = yes; then
11409
11410 cat >>confdefs.h <<\_ACEOF
11411 #define HAVE_ACOS 1
11412 _ACEOF
11413
11414 fi
11415
11416 echo "$as_me:$LINENO: checking for acosl in -lm" >&5
11417 echo $ECHO_N "checking for acosl in -lm... $ECHO_C" >&6
11418 if test "${ac_cv_lib_m_acosl+set}" = set; then
11419   echo $ECHO_N "(cached) $ECHO_C" >&6
11420 else
11421   ac_check_lib_save_LIBS=$LIBS
11422 LIBS="-lm  $LIBS"
11423 if test x$gcc_no_link = xyes; then
11424   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11425 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11426    { (exit 1); exit 1; }; }
11427 fi
11428 cat >conftest.$ac_ext <<_ACEOF
11429 /* confdefs.h.  */
11430 _ACEOF
11431 cat confdefs.h >>conftest.$ac_ext
11432 cat >>conftest.$ac_ext <<_ACEOF
11433 /* end confdefs.h.  */
11434
11435 /* Override any gcc2 internal prototype to avoid an error.  */
11436 #ifdef __cplusplus
11437 extern "C"
11438 #endif
11439 /* We use char because int might match the return type of a gcc2
11440    builtin and then its argument prototype would still apply.  */
11441 char acosl ();
11442 int
11443 main ()
11444 {
11445 acosl ();
11446   ;
11447   return 0;
11448 }
11449 _ACEOF
11450 rm -f conftest.$ac_objext conftest$ac_exeext
11451 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11452   (eval $ac_link) 2>conftest.er1
11453   ac_status=$?
11454   grep -v '^ *+' conftest.er1 >conftest.err
11455   rm -f conftest.er1
11456   cat conftest.err >&5
11457   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11458   (exit $ac_status); } &&
11459          { ac_try='test -z "$ac_c_werror_flag"
11460                          || test ! -s conftest.err'
11461   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11462   (eval $ac_try) 2>&5
11463   ac_status=$?
11464   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11465   (exit $ac_status); }; } &&
11466          { ac_try='test -s conftest$ac_exeext'
11467   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11468   (eval $ac_try) 2>&5
11469   ac_status=$?
11470   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11471   (exit $ac_status); }; }; then
11472   ac_cv_lib_m_acosl=yes
11473 else
11474   echo "$as_me: failed program was:" >&5
11475 sed 's/^/| /' conftest.$ac_ext >&5
11476
11477 ac_cv_lib_m_acosl=no
11478 fi
11479 rm -f conftest.err conftest.$ac_objext \
11480       conftest$ac_exeext conftest.$ac_ext
11481 LIBS=$ac_check_lib_save_LIBS
11482 fi
11483 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosl" >&5
11484 echo "${ECHO_T}$ac_cv_lib_m_acosl" >&6
11485 if test $ac_cv_lib_m_acosl = yes; then
11486
11487 cat >>confdefs.h <<\_ACEOF
11488 #define HAVE_ACOSL 1
11489 _ACEOF
11490
11491 fi
11492
11493 echo "$as_me:$LINENO: checking for acoshf in -lm" >&5
11494 echo $ECHO_N "checking for acoshf in -lm... $ECHO_C" >&6
11495 if test "${ac_cv_lib_m_acoshf+set}" = set; then
11496   echo $ECHO_N "(cached) $ECHO_C" >&6
11497 else
11498   ac_check_lib_save_LIBS=$LIBS
11499 LIBS="-lm  $LIBS"
11500 if test x$gcc_no_link = xyes; then
11501   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11502 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11503    { (exit 1); exit 1; }; }
11504 fi
11505 cat >conftest.$ac_ext <<_ACEOF
11506 /* confdefs.h.  */
11507 _ACEOF
11508 cat confdefs.h >>conftest.$ac_ext
11509 cat >>conftest.$ac_ext <<_ACEOF
11510 /* end confdefs.h.  */
11511
11512 /* Override any gcc2 internal prototype to avoid an error.  */
11513 #ifdef __cplusplus
11514 extern "C"
11515 #endif
11516 /* We use char because int might match the return type of a gcc2
11517    builtin and then its argument prototype would still apply.  */
11518 char acoshf ();
11519 int
11520 main ()
11521 {
11522 acoshf ();
11523   ;
11524   return 0;
11525 }
11526 _ACEOF
11527 rm -f conftest.$ac_objext conftest$ac_exeext
11528 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11529   (eval $ac_link) 2>conftest.er1
11530   ac_status=$?
11531   grep -v '^ *+' conftest.er1 >conftest.err
11532   rm -f conftest.er1
11533   cat conftest.err >&5
11534   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11535   (exit $ac_status); } &&
11536          { ac_try='test -z "$ac_c_werror_flag"
11537                          || test ! -s conftest.err'
11538   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11539   (eval $ac_try) 2>&5
11540   ac_status=$?
11541   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11542   (exit $ac_status); }; } &&
11543          { ac_try='test -s conftest$ac_exeext'
11544   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11545   (eval $ac_try) 2>&5
11546   ac_status=$?
11547   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11548   (exit $ac_status); }; }; then
11549   ac_cv_lib_m_acoshf=yes
11550 else
11551   echo "$as_me: failed program was:" >&5
11552 sed 's/^/| /' conftest.$ac_ext >&5
11553
11554 ac_cv_lib_m_acoshf=no
11555 fi
11556 rm -f conftest.err conftest.$ac_objext \
11557       conftest$ac_exeext conftest.$ac_ext
11558 LIBS=$ac_check_lib_save_LIBS
11559 fi
11560 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acoshf" >&5
11561 echo "${ECHO_T}$ac_cv_lib_m_acoshf" >&6
11562 if test $ac_cv_lib_m_acoshf = yes; then
11563
11564 cat >>confdefs.h <<\_ACEOF
11565 #define HAVE_ACOSHF 1
11566 _ACEOF
11567
11568 fi
11569
11570 echo "$as_me:$LINENO: checking for acosh in -lm" >&5
11571 echo $ECHO_N "checking for acosh in -lm... $ECHO_C" >&6
11572 if test "${ac_cv_lib_m_acosh+set}" = set; then
11573   echo $ECHO_N "(cached) $ECHO_C" >&6
11574 else
11575   ac_check_lib_save_LIBS=$LIBS
11576 LIBS="-lm  $LIBS"
11577 if test x$gcc_no_link = xyes; then
11578   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11579 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11580    { (exit 1); exit 1; }; }
11581 fi
11582 cat >conftest.$ac_ext <<_ACEOF
11583 /* confdefs.h.  */
11584 _ACEOF
11585 cat confdefs.h >>conftest.$ac_ext
11586 cat >>conftest.$ac_ext <<_ACEOF
11587 /* end confdefs.h.  */
11588
11589 /* Override any gcc2 internal prototype to avoid an error.  */
11590 #ifdef __cplusplus
11591 extern "C"
11592 #endif
11593 /* We use char because int might match the return type of a gcc2
11594    builtin and then its argument prototype would still apply.  */
11595 char acosh ();
11596 int
11597 main ()
11598 {
11599 acosh ();
11600   ;
11601   return 0;
11602 }
11603 _ACEOF
11604 rm -f conftest.$ac_objext conftest$ac_exeext
11605 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11606   (eval $ac_link) 2>conftest.er1
11607   ac_status=$?
11608   grep -v '^ *+' conftest.er1 >conftest.err
11609   rm -f conftest.er1
11610   cat conftest.err >&5
11611   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11612   (exit $ac_status); } &&
11613          { ac_try='test -z "$ac_c_werror_flag"
11614                          || test ! -s conftest.err'
11615   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11616   (eval $ac_try) 2>&5
11617   ac_status=$?
11618   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11619   (exit $ac_status); }; } &&
11620          { ac_try='test -s conftest$ac_exeext'
11621   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11622   (eval $ac_try) 2>&5
11623   ac_status=$?
11624   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11625   (exit $ac_status); }; }; then
11626   ac_cv_lib_m_acosh=yes
11627 else
11628   echo "$as_me: failed program was:" >&5
11629 sed 's/^/| /' conftest.$ac_ext >&5
11630
11631 ac_cv_lib_m_acosh=no
11632 fi
11633 rm -f conftest.err conftest.$ac_objext \
11634       conftest$ac_exeext conftest.$ac_ext
11635 LIBS=$ac_check_lib_save_LIBS
11636 fi
11637 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosh" >&5
11638 echo "${ECHO_T}$ac_cv_lib_m_acosh" >&6
11639 if test $ac_cv_lib_m_acosh = yes; then
11640
11641 cat >>confdefs.h <<\_ACEOF
11642 #define HAVE_ACOSH 1
11643 _ACEOF
11644
11645 fi
11646
11647 echo "$as_me:$LINENO: checking for acoshl in -lm" >&5
11648 echo $ECHO_N "checking for acoshl in -lm... $ECHO_C" >&6
11649 if test "${ac_cv_lib_m_acoshl+set}" = set; then
11650   echo $ECHO_N "(cached) $ECHO_C" >&6
11651 else
11652   ac_check_lib_save_LIBS=$LIBS
11653 LIBS="-lm  $LIBS"
11654 if test x$gcc_no_link = xyes; then
11655   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11656 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11657    { (exit 1); exit 1; }; }
11658 fi
11659 cat >conftest.$ac_ext <<_ACEOF
11660 /* confdefs.h.  */
11661 _ACEOF
11662 cat confdefs.h >>conftest.$ac_ext
11663 cat >>conftest.$ac_ext <<_ACEOF
11664 /* end confdefs.h.  */
11665
11666 /* Override any gcc2 internal prototype to avoid an error.  */
11667 #ifdef __cplusplus
11668 extern "C"
11669 #endif
11670 /* We use char because int might match the return type of a gcc2
11671    builtin and then its argument prototype would still apply.  */
11672 char acoshl ();
11673 int
11674 main ()
11675 {
11676 acoshl ();
11677   ;
11678   return 0;
11679 }
11680 _ACEOF
11681 rm -f conftest.$ac_objext conftest$ac_exeext
11682 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11683   (eval $ac_link) 2>conftest.er1
11684   ac_status=$?
11685   grep -v '^ *+' conftest.er1 >conftest.err
11686   rm -f conftest.er1
11687   cat conftest.err >&5
11688   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11689   (exit $ac_status); } &&
11690          { ac_try='test -z "$ac_c_werror_flag"
11691                          || test ! -s conftest.err'
11692   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11693   (eval $ac_try) 2>&5
11694   ac_status=$?
11695   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11696   (exit $ac_status); }; } &&
11697          { ac_try='test -s conftest$ac_exeext'
11698   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11699   (eval $ac_try) 2>&5
11700   ac_status=$?
11701   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11702   (exit $ac_status); }; }; then
11703   ac_cv_lib_m_acoshl=yes
11704 else
11705   echo "$as_me: failed program was:" >&5
11706 sed 's/^/| /' conftest.$ac_ext >&5
11707
11708 ac_cv_lib_m_acoshl=no
11709 fi
11710 rm -f conftest.err conftest.$ac_objext \
11711       conftest$ac_exeext conftest.$ac_ext
11712 LIBS=$ac_check_lib_save_LIBS
11713 fi
11714 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acoshl" >&5
11715 echo "${ECHO_T}$ac_cv_lib_m_acoshl" >&6
11716 if test $ac_cv_lib_m_acoshl = yes; then
11717
11718 cat >>confdefs.h <<\_ACEOF
11719 #define HAVE_ACOSHL 1
11720 _ACEOF
11721
11722 fi
11723
11724 echo "$as_me:$LINENO: checking for asinf in -lm" >&5
11725 echo $ECHO_N "checking for asinf in -lm... $ECHO_C" >&6
11726 if test "${ac_cv_lib_m_asinf+set}" = set; then
11727   echo $ECHO_N "(cached) $ECHO_C" >&6
11728 else
11729   ac_check_lib_save_LIBS=$LIBS
11730 LIBS="-lm  $LIBS"
11731 if test x$gcc_no_link = xyes; then
11732   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11733 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11734    { (exit 1); exit 1; }; }
11735 fi
11736 cat >conftest.$ac_ext <<_ACEOF
11737 /* confdefs.h.  */
11738 _ACEOF
11739 cat confdefs.h >>conftest.$ac_ext
11740 cat >>conftest.$ac_ext <<_ACEOF
11741 /* end confdefs.h.  */
11742
11743 /* Override any gcc2 internal prototype to avoid an error.  */
11744 #ifdef __cplusplus
11745 extern "C"
11746 #endif
11747 /* We use char because int might match the return type of a gcc2
11748    builtin and then its argument prototype would still apply.  */
11749 char asinf ();
11750 int
11751 main ()
11752 {
11753 asinf ();
11754   ;
11755   return 0;
11756 }
11757 _ACEOF
11758 rm -f conftest.$ac_objext conftest$ac_exeext
11759 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11760   (eval $ac_link) 2>conftest.er1
11761   ac_status=$?
11762   grep -v '^ *+' conftest.er1 >conftest.err
11763   rm -f conftest.er1
11764   cat conftest.err >&5
11765   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11766   (exit $ac_status); } &&
11767          { ac_try='test -z "$ac_c_werror_flag"
11768                          || test ! -s conftest.err'
11769   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11770   (eval $ac_try) 2>&5
11771   ac_status=$?
11772   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11773   (exit $ac_status); }; } &&
11774          { ac_try='test -s conftest$ac_exeext'
11775   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11776   (eval $ac_try) 2>&5
11777   ac_status=$?
11778   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11779   (exit $ac_status); }; }; then
11780   ac_cv_lib_m_asinf=yes
11781 else
11782   echo "$as_me: failed program was:" >&5
11783 sed 's/^/| /' conftest.$ac_ext >&5
11784
11785 ac_cv_lib_m_asinf=no
11786 fi
11787 rm -f conftest.err conftest.$ac_objext \
11788       conftest$ac_exeext conftest.$ac_ext
11789 LIBS=$ac_check_lib_save_LIBS
11790 fi
11791 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinf" >&5
11792 echo "${ECHO_T}$ac_cv_lib_m_asinf" >&6
11793 if test $ac_cv_lib_m_asinf = yes; then
11794
11795 cat >>confdefs.h <<\_ACEOF
11796 #define HAVE_ASINF 1
11797 _ACEOF
11798
11799 fi
11800
11801 echo "$as_me:$LINENO: checking for asin in -lm" >&5
11802 echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
11803 if test "${ac_cv_lib_m_asin+set}" = set; then
11804   echo $ECHO_N "(cached) $ECHO_C" >&6
11805 else
11806   ac_check_lib_save_LIBS=$LIBS
11807 LIBS="-lm  $LIBS"
11808 if test x$gcc_no_link = xyes; then
11809   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11810 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11811    { (exit 1); exit 1; }; }
11812 fi
11813 cat >conftest.$ac_ext <<_ACEOF
11814 /* confdefs.h.  */
11815 _ACEOF
11816 cat confdefs.h >>conftest.$ac_ext
11817 cat >>conftest.$ac_ext <<_ACEOF
11818 /* end confdefs.h.  */
11819
11820 /* Override any gcc2 internal prototype to avoid an error.  */
11821 #ifdef __cplusplus
11822 extern "C"
11823 #endif
11824 /* We use char because int might match the return type of a gcc2
11825    builtin and then its argument prototype would still apply.  */
11826 char asin ();
11827 int
11828 main ()
11829 {
11830 asin ();
11831   ;
11832   return 0;
11833 }
11834 _ACEOF
11835 rm -f conftest.$ac_objext conftest$ac_exeext
11836 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11837   (eval $ac_link) 2>conftest.er1
11838   ac_status=$?
11839   grep -v '^ *+' conftest.er1 >conftest.err
11840   rm -f conftest.er1
11841   cat conftest.err >&5
11842   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11843   (exit $ac_status); } &&
11844          { ac_try='test -z "$ac_c_werror_flag"
11845                          || test ! -s conftest.err'
11846   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11847   (eval $ac_try) 2>&5
11848   ac_status=$?
11849   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11850   (exit $ac_status); }; } &&
11851          { ac_try='test -s conftest$ac_exeext'
11852   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11853   (eval $ac_try) 2>&5
11854   ac_status=$?
11855   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11856   (exit $ac_status); }; }; then
11857   ac_cv_lib_m_asin=yes
11858 else
11859   echo "$as_me: failed program was:" >&5
11860 sed 's/^/| /' conftest.$ac_ext >&5
11861
11862 ac_cv_lib_m_asin=no
11863 fi
11864 rm -f conftest.err conftest.$ac_objext \
11865       conftest$ac_exeext conftest.$ac_ext
11866 LIBS=$ac_check_lib_save_LIBS
11867 fi
11868 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
11869 echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
11870 if test $ac_cv_lib_m_asin = yes; then
11871
11872 cat >>confdefs.h <<\_ACEOF
11873 #define HAVE_ASIN 1
11874 _ACEOF
11875
11876 fi
11877
11878 echo "$as_me:$LINENO: checking for asinl in -lm" >&5
11879 echo $ECHO_N "checking for asinl in -lm... $ECHO_C" >&6
11880 if test "${ac_cv_lib_m_asinl+set}" = set; then
11881   echo $ECHO_N "(cached) $ECHO_C" >&6
11882 else
11883   ac_check_lib_save_LIBS=$LIBS
11884 LIBS="-lm  $LIBS"
11885 if test x$gcc_no_link = xyes; then
11886   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11887 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11888    { (exit 1); exit 1; }; }
11889 fi
11890 cat >conftest.$ac_ext <<_ACEOF
11891 /* confdefs.h.  */
11892 _ACEOF
11893 cat confdefs.h >>conftest.$ac_ext
11894 cat >>conftest.$ac_ext <<_ACEOF
11895 /* end confdefs.h.  */
11896
11897 /* Override any gcc2 internal prototype to avoid an error.  */
11898 #ifdef __cplusplus
11899 extern "C"
11900 #endif
11901 /* We use char because int might match the return type of a gcc2
11902    builtin and then its argument prototype would still apply.  */
11903 char asinl ();
11904 int
11905 main ()
11906 {
11907 asinl ();
11908   ;
11909   return 0;
11910 }
11911 _ACEOF
11912 rm -f conftest.$ac_objext conftest$ac_exeext
11913 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11914   (eval $ac_link) 2>conftest.er1
11915   ac_status=$?
11916   grep -v '^ *+' conftest.er1 >conftest.err
11917   rm -f conftest.er1
11918   cat conftest.err >&5
11919   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11920   (exit $ac_status); } &&
11921          { ac_try='test -z "$ac_c_werror_flag"
11922                          || test ! -s conftest.err'
11923   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11924   (eval $ac_try) 2>&5
11925   ac_status=$?
11926   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11927   (exit $ac_status); }; } &&
11928          { ac_try='test -s conftest$ac_exeext'
11929   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11930   (eval $ac_try) 2>&5
11931   ac_status=$?
11932   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11933   (exit $ac_status); }; }; then
11934   ac_cv_lib_m_asinl=yes
11935 else
11936   echo "$as_me: failed program was:" >&5
11937 sed 's/^/| /' conftest.$ac_ext >&5
11938
11939 ac_cv_lib_m_asinl=no
11940 fi
11941 rm -f conftest.err conftest.$ac_objext \
11942       conftest$ac_exeext conftest.$ac_ext
11943 LIBS=$ac_check_lib_save_LIBS
11944 fi
11945 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinl" >&5
11946 echo "${ECHO_T}$ac_cv_lib_m_asinl" >&6
11947 if test $ac_cv_lib_m_asinl = yes; then
11948
11949 cat >>confdefs.h <<\_ACEOF
11950 #define HAVE_ASINL 1
11951 _ACEOF
11952
11953 fi
11954
11955 echo "$as_me:$LINENO: checking for asinhf in -lm" >&5
11956 echo $ECHO_N "checking for asinhf in -lm... $ECHO_C" >&6
11957 if test "${ac_cv_lib_m_asinhf+set}" = set; then
11958   echo $ECHO_N "(cached) $ECHO_C" >&6
11959 else
11960   ac_check_lib_save_LIBS=$LIBS
11961 LIBS="-lm  $LIBS"
11962 if test x$gcc_no_link = xyes; then
11963   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11964 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11965    { (exit 1); exit 1; }; }
11966 fi
11967 cat >conftest.$ac_ext <<_ACEOF
11968 /* confdefs.h.  */
11969 _ACEOF
11970 cat confdefs.h >>conftest.$ac_ext
11971 cat >>conftest.$ac_ext <<_ACEOF
11972 /* end confdefs.h.  */
11973
11974 /* Override any gcc2 internal prototype to avoid an error.  */
11975 #ifdef __cplusplus
11976 extern "C"
11977 #endif
11978 /* We use char because int might match the return type of a gcc2
11979    builtin and then its argument prototype would still apply.  */
11980 char asinhf ();
11981 int
11982 main ()
11983 {
11984 asinhf ();
11985   ;
11986   return 0;
11987 }
11988 _ACEOF
11989 rm -f conftest.$ac_objext conftest$ac_exeext
11990 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11991   (eval $ac_link) 2>conftest.er1
11992   ac_status=$?
11993   grep -v '^ *+' conftest.er1 >conftest.err
11994   rm -f conftest.er1
11995   cat conftest.err >&5
11996   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11997   (exit $ac_status); } &&
11998          { ac_try='test -z "$ac_c_werror_flag"
11999                          || test ! -s conftest.err'
12000   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12001   (eval $ac_try) 2>&5
12002   ac_status=$?
12003   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12004   (exit $ac_status); }; } &&
12005          { ac_try='test -s conftest$ac_exeext'
12006   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12007   (eval $ac_try) 2>&5
12008   ac_status=$?
12009   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12010   (exit $ac_status); }; }; then
12011   ac_cv_lib_m_asinhf=yes
12012 else
12013   echo "$as_me: failed program was:" >&5
12014 sed 's/^/| /' conftest.$ac_ext >&5
12015
12016 ac_cv_lib_m_asinhf=no
12017 fi
12018 rm -f conftest.err conftest.$ac_objext \
12019       conftest$ac_exeext conftest.$ac_ext
12020 LIBS=$ac_check_lib_save_LIBS
12021 fi
12022 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinhf" >&5
12023 echo "${ECHO_T}$ac_cv_lib_m_asinhf" >&6
12024 if test $ac_cv_lib_m_asinhf = yes; then
12025
12026 cat >>confdefs.h <<\_ACEOF
12027 #define HAVE_ASINHF 1
12028 _ACEOF
12029
12030 fi
12031
12032 echo "$as_me:$LINENO: checking for asinh in -lm" >&5
12033 echo $ECHO_N "checking for asinh in -lm... $ECHO_C" >&6
12034 if test "${ac_cv_lib_m_asinh+set}" = set; then
12035   echo $ECHO_N "(cached) $ECHO_C" >&6
12036 else
12037   ac_check_lib_save_LIBS=$LIBS
12038 LIBS="-lm  $LIBS"
12039 if test x$gcc_no_link = xyes; then
12040   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12041 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12042    { (exit 1); exit 1; }; }
12043 fi
12044 cat >conftest.$ac_ext <<_ACEOF
12045 /* confdefs.h.  */
12046 _ACEOF
12047 cat confdefs.h >>conftest.$ac_ext
12048 cat >>conftest.$ac_ext <<_ACEOF
12049 /* end confdefs.h.  */
12050
12051 /* Override any gcc2 internal prototype to avoid an error.  */
12052 #ifdef __cplusplus
12053 extern "C"
12054 #endif
12055 /* We use char because int might match the return type of a gcc2
12056    builtin and then its argument prototype would still apply.  */
12057 char asinh ();
12058 int
12059 main ()
12060 {
12061 asinh ();
12062   ;
12063   return 0;
12064 }
12065 _ACEOF
12066 rm -f conftest.$ac_objext conftest$ac_exeext
12067 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12068   (eval $ac_link) 2>conftest.er1
12069   ac_status=$?
12070   grep -v '^ *+' conftest.er1 >conftest.err
12071   rm -f conftest.er1
12072   cat conftest.err >&5
12073   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12074   (exit $ac_status); } &&
12075          { ac_try='test -z "$ac_c_werror_flag"
12076                          || test ! -s conftest.err'
12077   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12078   (eval $ac_try) 2>&5
12079   ac_status=$?
12080   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12081   (exit $ac_status); }; } &&
12082          { ac_try='test -s conftest$ac_exeext'
12083   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12084   (eval $ac_try) 2>&5
12085   ac_status=$?
12086   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12087   (exit $ac_status); }; }; then
12088   ac_cv_lib_m_asinh=yes
12089 else
12090   echo "$as_me: failed program was:" >&5
12091 sed 's/^/| /' conftest.$ac_ext >&5
12092
12093 ac_cv_lib_m_asinh=no
12094 fi
12095 rm -f conftest.err conftest.$ac_objext \
12096       conftest$ac_exeext conftest.$ac_ext
12097 LIBS=$ac_check_lib_save_LIBS
12098 fi
12099 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinh" >&5
12100 echo "${ECHO_T}$ac_cv_lib_m_asinh" >&6
12101 if test $ac_cv_lib_m_asinh = yes; then
12102
12103 cat >>confdefs.h <<\_ACEOF
12104 #define HAVE_ASINH 1
12105 _ACEOF
12106
12107 fi
12108
12109 echo "$as_me:$LINENO: checking for asinhl in -lm" >&5
12110 echo $ECHO_N "checking for asinhl in -lm... $ECHO_C" >&6
12111 if test "${ac_cv_lib_m_asinhl+set}" = set; then
12112   echo $ECHO_N "(cached) $ECHO_C" >&6
12113 else
12114   ac_check_lib_save_LIBS=$LIBS
12115 LIBS="-lm  $LIBS"
12116 if test x$gcc_no_link = xyes; then
12117   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12118 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12119    { (exit 1); exit 1; }; }
12120 fi
12121 cat >conftest.$ac_ext <<_ACEOF
12122 /* confdefs.h.  */
12123 _ACEOF
12124 cat confdefs.h >>conftest.$ac_ext
12125 cat >>conftest.$ac_ext <<_ACEOF
12126 /* end confdefs.h.  */
12127
12128 /* Override any gcc2 internal prototype to avoid an error.  */
12129 #ifdef __cplusplus
12130 extern "C"
12131 #endif
12132 /* We use char because int might match the return type of a gcc2
12133    builtin and then its argument prototype would still apply.  */
12134 char asinhl ();
12135 int
12136 main ()
12137 {
12138 asinhl ();
12139   ;
12140   return 0;
12141 }
12142 _ACEOF
12143 rm -f conftest.$ac_objext conftest$ac_exeext
12144 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12145   (eval $ac_link) 2>conftest.er1
12146   ac_status=$?
12147   grep -v '^ *+' conftest.er1 >conftest.err
12148   rm -f conftest.er1
12149   cat conftest.err >&5
12150   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12151   (exit $ac_status); } &&
12152          { ac_try='test -z "$ac_c_werror_flag"
12153                          || test ! -s conftest.err'
12154   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12155   (eval $ac_try) 2>&5
12156   ac_status=$?
12157   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12158   (exit $ac_status); }; } &&
12159          { ac_try='test -s conftest$ac_exeext'
12160   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12161   (eval $ac_try) 2>&5
12162   ac_status=$?
12163   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12164   (exit $ac_status); }; }; then
12165   ac_cv_lib_m_asinhl=yes
12166 else
12167   echo "$as_me: failed program was:" >&5
12168 sed 's/^/| /' conftest.$ac_ext >&5
12169
12170 ac_cv_lib_m_asinhl=no
12171 fi
12172 rm -f conftest.err conftest.$ac_objext \
12173       conftest$ac_exeext conftest.$ac_ext
12174 LIBS=$ac_check_lib_save_LIBS
12175 fi
12176 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinhl" >&5
12177 echo "${ECHO_T}$ac_cv_lib_m_asinhl" >&6
12178 if test $ac_cv_lib_m_asinhl = yes; then
12179
12180 cat >>confdefs.h <<\_ACEOF
12181 #define HAVE_ASINHL 1
12182 _ACEOF
12183
12184 fi
12185
12186 echo "$as_me:$LINENO: checking for atan2f in -lm" >&5
12187 echo $ECHO_N "checking for atan2f in -lm... $ECHO_C" >&6
12188 if test "${ac_cv_lib_m_atan2f+set}" = set; then
12189   echo $ECHO_N "(cached) $ECHO_C" >&6
12190 else
12191   ac_check_lib_save_LIBS=$LIBS
12192 LIBS="-lm  $LIBS"
12193 if test x$gcc_no_link = xyes; then
12194   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12195 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12196    { (exit 1); exit 1; }; }
12197 fi
12198 cat >conftest.$ac_ext <<_ACEOF
12199 /* confdefs.h.  */
12200 _ACEOF
12201 cat confdefs.h >>conftest.$ac_ext
12202 cat >>conftest.$ac_ext <<_ACEOF
12203 /* end confdefs.h.  */
12204
12205 /* Override any gcc2 internal prototype to avoid an error.  */
12206 #ifdef __cplusplus
12207 extern "C"
12208 #endif
12209 /* We use char because int might match the return type of a gcc2
12210    builtin and then its argument prototype would still apply.  */
12211 char atan2f ();
12212 int
12213 main ()
12214 {
12215 atan2f ();
12216   ;
12217   return 0;
12218 }
12219 _ACEOF
12220 rm -f conftest.$ac_objext conftest$ac_exeext
12221 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12222   (eval $ac_link) 2>conftest.er1
12223   ac_status=$?
12224   grep -v '^ *+' conftest.er1 >conftest.err
12225   rm -f conftest.er1
12226   cat conftest.err >&5
12227   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12228   (exit $ac_status); } &&
12229          { ac_try='test -z "$ac_c_werror_flag"
12230                          || test ! -s conftest.err'
12231   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12232   (eval $ac_try) 2>&5
12233   ac_status=$?
12234   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12235   (exit $ac_status); }; } &&
12236          { ac_try='test -s conftest$ac_exeext'
12237   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12238   (eval $ac_try) 2>&5
12239   ac_status=$?
12240   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12241   (exit $ac_status); }; }; then
12242   ac_cv_lib_m_atan2f=yes
12243 else
12244   echo "$as_me: failed program was:" >&5
12245 sed 's/^/| /' conftest.$ac_ext >&5
12246
12247 ac_cv_lib_m_atan2f=no
12248 fi
12249 rm -f conftest.err conftest.$ac_objext \
12250       conftest$ac_exeext conftest.$ac_ext
12251 LIBS=$ac_check_lib_save_LIBS
12252 fi
12253 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2f" >&5
12254 echo "${ECHO_T}$ac_cv_lib_m_atan2f" >&6
12255 if test $ac_cv_lib_m_atan2f = yes; then
12256
12257 cat >>confdefs.h <<\_ACEOF
12258 #define HAVE_ATAN2F 1
12259 _ACEOF
12260
12261 fi
12262
12263 echo "$as_me:$LINENO: checking for atan2 in -lm" >&5
12264 echo $ECHO_N "checking for atan2 in -lm... $ECHO_C" >&6
12265 if test "${ac_cv_lib_m_atan2+set}" = set; then
12266   echo $ECHO_N "(cached) $ECHO_C" >&6
12267 else
12268   ac_check_lib_save_LIBS=$LIBS
12269 LIBS="-lm  $LIBS"
12270 if test x$gcc_no_link = xyes; then
12271   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12272 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12273    { (exit 1); exit 1; }; }
12274 fi
12275 cat >conftest.$ac_ext <<_ACEOF
12276 /* confdefs.h.  */
12277 _ACEOF
12278 cat confdefs.h >>conftest.$ac_ext
12279 cat >>conftest.$ac_ext <<_ACEOF
12280 /* end confdefs.h.  */
12281
12282 /* Override any gcc2 internal prototype to avoid an error.  */
12283 #ifdef __cplusplus
12284 extern "C"
12285 #endif
12286 /* We use char because int might match the return type of a gcc2
12287    builtin and then its argument prototype would still apply.  */
12288 char atan2 ();
12289 int
12290 main ()
12291 {
12292 atan2 ();
12293   ;
12294   return 0;
12295 }
12296 _ACEOF
12297 rm -f conftest.$ac_objext conftest$ac_exeext
12298 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12299   (eval $ac_link) 2>conftest.er1
12300   ac_status=$?
12301   grep -v '^ *+' conftest.er1 >conftest.err
12302   rm -f conftest.er1
12303   cat conftest.err >&5
12304   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12305   (exit $ac_status); } &&
12306          { ac_try='test -z "$ac_c_werror_flag"
12307                          || test ! -s conftest.err'
12308   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12309   (eval $ac_try) 2>&5
12310   ac_status=$?
12311   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12312   (exit $ac_status); }; } &&
12313          { ac_try='test -s conftest$ac_exeext'
12314   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12315   (eval $ac_try) 2>&5
12316   ac_status=$?
12317   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12318   (exit $ac_status); }; }; then
12319   ac_cv_lib_m_atan2=yes
12320 else
12321   echo "$as_me: failed program was:" >&5
12322 sed 's/^/| /' conftest.$ac_ext >&5
12323
12324 ac_cv_lib_m_atan2=no
12325 fi
12326 rm -f conftest.err conftest.$ac_objext \
12327       conftest$ac_exeext conftest.$ac_ext
12328 LIBS=$ac_check_lib_save_LIBS
12329 fi
12330 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2" >&5
12331 echo "${ECHO_T}$ac_cv_lib_m_atan2" >&6
12332 if test $ac_cv_lib_m_atan2 = yes; then
12333
12334 cat >>confdefs.h <<\_ACEOF
12335 #define HAVE_ATAN2 1
12336 _ACEOF
12337
12338 fi
12339
12340 echo "$as_me:$LINENO: checking for atan2l in -lm" >&5
12341 echo $ECHO_N "checking for atan2l in -lm... $ECHO_C" >&6
12342 if test "${ac_cv_lib_m_atan2l+set}" = set; then
12343   echo $ECHO_N "(cached) $ECHO_C" >&6
12344 else
12345   ac_check_lib_save_LIBS=$LIBS
12346 LIBS="-lm  $LIBS"
12347 if test x$gcc_no_link = xyes; then
12348   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12349 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12350    { (exit 1); exit 1; }; }
12351 fi
12352 cat >conftest.$ac_ext <<_ACEOF
12353 /* confdefs.h.  */
12354 _ACEOF
12355 cat confdefs.h >>conftest.$ac_ext
12356 cat >>conftest.$ac_ext <<_ACEOF
12357 /* end confdefs.h.  */
12358
12359 /* Override any gcc2 internal prototype to avoid an error.  */
12360 #ifdef __cplusplus
12361 extern "C"
12362 #endif
12363 /* We use char because int might match the return type of a gcc2
12364    builtin and then its argument prototype would still apply.  */
12365 char atan2l ();
12366 int
12367 main ()
12368 {
12369 atan2l ();
12370   ;
12371   return 0;
12372 }
12373 _ACEOF
12374 rm -f conftest.$ac_objext conftest$ac_exeext
12375 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12376   (eval $ac_link) 2>conftest.er1
12377   ac_status=$?
12378   grep -v '^ *+' conftest.er1 >conftest.err
12379   rm -f conftest.er1
12380   cat conftest.err >&5
12381   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12382   (exit $ac_status); } &&
12383          { ac_try='test -z "$ac_c_werror_flag"
12384                          || test ! -s conftest.err'
12385   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12386   (eval $ac_try) 2>&5
12387   ac_status=$?
12388   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12389   (exit $ac_status); }; } &&
12390          { ac_try='test -s conftest$ac_exeext'
12391   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12392   (eval $ac_try) 2>&5
12393   ac_status=$?
12394   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12395   (exit $ac_status); }; }; then
12396   ac_cv_lib_m_atan2l=yes
12397 else
12398   echo "$as_me: failed program was:" >&5
12399 sed 's/^/| /' conftest.$ac_ext >&5
12400
12401 ac_cv_lib_m_atan2l=no
12402 fi
12403 rm -f conftest.err conftest.$ac_objext \
12404       conftest$ac_exeext conftest.$ac_ext
12405 LIBS=$ac_check_lib_save_LIBS
12406 fi
12407 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2l" >&5
12408 echo "${ECHO_T}$ac_cv_lib_m_atan2l" >&6
12409 if test $ac_cv_lib_m_atan2l = yes; then
12410
12411 cat >>confdefs.h <<\_ACEOF
12412 #define HAVE_ATAN2L 1
12413 _ACEOF
12414
12415 fi
12416
12417 echo "$as_me:$LINENO: checking for atanf in -lm" >&5
12418 echo $ECHO_N "checking for atanf in -lm... $ECHO_C" >&6
12419 if test "${ac_cv_lib_m_atanf+set}" = set; then
12420   echo $ECHO_N "(cached) $ECHO_C" >&6
12421 else
12422   ac_check_lib_save_LIBS=$LIBS
12423 LIBS="-lm  $LIBS"
12424 if test x$gcc_no_link = xyes; then
12425   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12426 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12427    { (exit 1); exit 1; }; }
12428 fi
12429 cat >conftest.$ac_ext <<_ACEOF
12430 /* confdefs.h.  */
12431 _ACEOF
12432 cat confdefs.h >>conftest.$ac_ext
12433 cat >>conftest.$ac_ext <<_ACEOF
12434 /* end confdefs.h.  */
12435
12436 /* Override any gcc2 internal prototype to avoid an error.  */
12437 #ifdef __cplusplus
12438 extern "C"
12439 #endif
12440 /* We use char because int might match the return type of a gcc2
12441    builtin and then its argument prototype would still apply.  */
12442 char atanf ();
12443 int
12444 main ()
12445 {
12446 atanf ();
12447   ;
12448   return 0;
12449 }
12450 _ACEOF
12451 rm -f conftest.$ac_objext conftest$ac_exeext
12452 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12453   (eval $ac_link) 2>conftest.er1
12454   ac_status=$?
12455   grep -v '^ *+' conftest.er1 >conftest.err
12456   rm -f conftest.er1
12457   cat conftest.err >&5
12458   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12459   (exit $ac_status); } &&
12460          { ac_try='test -z "$ac_c_werror_flag"
12461                          || test ! -s conftest.err'
12462   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12463   (eval $ac_try) 2>&5
12464   ac_status=$?
12465   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12466   (exit $ac_status); }; } &&
12467          { ac_try='test -s conftest$ac_exeext'
12468   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12469   (eval $ac_try) 2>&5
12470   ac_status=$?
12471   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12472   (exit $ac_status); }; }; then
12473   ac_cv_lib_m_atanf=yes
12474 else
12475   echo "$as_me: failed program was:" >&5
12476 sed 's/^/| /' conftest.$ac_ext >&5
12477
12478 ac_cv_lib_m_atanf=no
12479 fi
12480 rm -f conftest.err conftest.$ac_objext \
12481       conftest$ac_exeext conftest.$ac_ext
12482 LIBS=$ac_check_lib_save_LIBS
12483 fi
12484 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanf" >&5
12485 echo "${ECHO_T}$ac_cv_lib_m_atanf" >&6
12486 if test $ac_cv_lib_m_atanf = yes; then
12487
12488 cat >>confdefs.h <<\_ACEOF
12489 #define HAVE_ATANF 1
12490 _ACEOF
12491
12492 fi
12493
12494 echo "$as_me:$LINENO: checking for atan in -lm" >&5
12495 echo $ECHO_N "checking for atan in -lm... $ECHO_C" >&6
12496 if test "${ac_cv_lib_m_atan+set}" = set; then
12497   echo $ECHO_N "(cached) $ECHO_C" >&6
12498 else
12499   ac_check_lib_save_LIBS=$LIBS
12500 LIBS="-lm  $LIBS"
12501 if test x$gcc_no_link = xyes; then
12502   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12503 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12504    { (exit 1); exit 1; }; }
12505 fi
12506 cat >conftest.$ac_ext <<_ACEOF
12507 /* confdefs.h.  */
12508 _ACEOF
12509 cat confdefs.h >>conftest.$ac_ext
12510 cat >>conftest.$ac_ext <<_ACEOF
12511 /* end confdefs.h.  */
12512
12513 /* Override any gcc2 internal prototype to avoid an error.  */
12514 #ifdef __cplusplus
12515 extern "C"
12516 #endif
12517 /* We use char because int might match the return type of a gcc2
12518    builtin and then its argument prototype would still apply.  */
12519 char atan ();
12520 int
12521 main ()
12522 {
12523 atan ();
12524   ;
12525   return 0;
12526 }
12527 _ACEOF
12528 rm -f conftest.$ac_objext conftest$ac_exeext
12529 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12530   (eval $ac_link) 2>conftest.er1
12531   ac_status=$?
12532   grep -v '^ *+' conftest.er1 >conftest.err
12533   rm -f conftest.er1
12534   cat conftest.err >&5
12535   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12536   (exit $ac_status); } &&
12537          { ac_try='test -z "$ac_c_werror_flag"
12538                          || test ! -s conftest.err'
12539   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12540   (eval $ac_try) 2>&5
12541   ac_status=$?
12542   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12543   (exit $ac_status); }; } &&
12544          { ac_try='test -s conftest$ac_exeext'
12545   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12546   (eval $ac_try) 2>&5
12547   ac_status=$?
12548   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12549   (exit $ac_status); }; }; then
12550   ac_cv_lib_m_atan=yes
12551 else
12552   echo "$as_me: failed program was:" >&5
12553 sed 's/^/| /' conftest.$ac_ext >&5
12554
12555 ac_cv_lib_m_atan=no
12556 fi
12557 rm -f conftest.err conftest.$ac_objext \
12558       conftest$ac_exeext conftest.$ac_ext
12559 LIBS=$ac_check_lib_save_LIBS
12560 fi
12561 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan" >&5
12562 echo "${ECHO_T}$ac_cv_lib_m_atan" >&6
12563 if test $ac_cv_lib_m_atan = yes; then
12564
12565 cat >>confdefs.h <<\_ACEOF
12566 #define HAVE_ATAN 1
12567 _ACEOF
12568
12569 fi
12570
12571 echo "$as_me:$LINENO: checking for atanl in -lm" >&5
12572 echo $ECHO_N "checking for atanl in -lm... $ECHO_C" >&6
12573 if test "${ac_cv_lib_m_atanl+set}" = set; then
12574   echo $ECHO_N "(cached) $ECHO_C" >&6
12575 else
12576   ac_check_lib_save_LIBS=$LIBS
12577 LIBS="-lm  $LIBS"
12578 if test x$gcc_no_link = xyes; then
12579   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12580 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12581    { (exit 1); exit 1; }; }
12582 fi
12583 cat >conftest.$ac_ext <<_ACEOF
12584 /* confdefs.h.  */
12585 _ACEOF
12586 cat confdefs.h >>conftest.$ac_ext
12587 cat >>conftest.$ac_ext <<_ACEOF
12588 /* end confdefs.h.  */
12589
12590 /* Override any gcc2 internal prototype to avoid an error.  */
12591 #ifdef __cplusplus
12592 extern "C"
12593 #endif
12594 /* We use char because int might match the return type of a gcc2
12595    builtin and then its argument prototype would still apply.  */
12596 char atanl ();
12597 int
12598 main ()
12599 {
12600 atanl ();
12601   ;
12602   return 0;
12603 }
12604 _ACEOF
12605 rm -f conftest.$ac_objext conftest$ac_exeext
12606 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12607   (eval $ac_link) 2>conftest.er1
12608   ac_status=$?
12609   grep -v '^ *+' conftest.er1 >conftest.err
12610   rm -f conftest.er1
12611   cat conftest.err >&5
12612   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12613   (exit $ac_status); } &&
12614          { ac_try='test -z "$ac_c_werror_flag"
12615                          || test ! -s conftest.err'
12616   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12617   (eval $ac_try) 2>&5
12618   ac_status=$?
12619   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12620   (exit $ac_status); }; } &&
12621          { ac_try='test -s conftest$ac_exeext'
12622   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12623   (eval $ac_try) 2>&5
12624   ac_status=$?
12625   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12626   (exit $ac_status); }; }; then
12627   ac_cv_lib_m_atanl=yes
12628 else
12629   echo "$as_me: failed program was:" >&5
12630 sed 's/^/| /' conftest.$ac_ext >&5
12631
12632 ac_cv_lib_m_atanl=no
12633 fi
12634 rm -f conftest.err conftest.$ac_objext \
12635       conftest$ac_exeext conftest.$ac_ext
12636 LIBS=$ac_check_lib_save_LIBS
12637 fi
12638 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanl" >&5
12639 echo "${ECHO_T}$ac_cv_lib_m_atanl" >&6
12640 if test $ac_cv_lib_m_atanl = yes; then
12641
12642 cat >>confdefs.h <<\_ACEOF
12643 #define HAVE_ATANL 1
12644 _ACEOF
12645
12646 fi
12647
12648 echo "$as_me:$LINENO: checking for atanhf in -lm" >&5
12649 echo $ECHO_N "checking for atanhf in -lm... $ECHO_C" >&6
12650 if test "${ac_cv_lib_m_atanhf+set}" = set; then
12651   echo $ECHO_N "(cached) $ECHO_C" >&6
12652 else
12653   ac_check_lib_save_LIBS=$LIBS
12654 LIBS="-lm  $LIBS"
12655 if test x$gcc_no_link = xyes; then
12656   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12657 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12658    { (exit 1); exit 1; }; }
12659 fi
12660 cat >conftest.$ac_ext <<_ACEOF
12661 /* confdefs.h.  */
12662 _ACEOF
12663 cat confdefs.h >>conftest.$ac_ext
12664 cat >>conftest.$ac_ext <<_ACEOF
12665 /* end confdefs.h.  */
12666
12667 /* Override any gcc2 internal prototype to avoid an error.  */
12668 #ifdef __cplusplus
12669 extern "C"
12670 #endif
12671 /* We use char because int might match the return type of a gcc2
12672    builtin and then its argument prototype would still apply.  */
12673 char atanhf ();
12674 int
12675 main ()
12676 {
12677 atanhf ();
12678   ;
12679   return 0;
12680 }
12681 _ACEOF
12682 rm -f conftest.$ac_objext conftest$ac_exeext
12683 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12684   (eval $ac_link) 2>conftest.er1
12685   ac_status=$?
12686   grep -v '^ *+' conftest.er1 >conftest.err
12687   rm -f conftest.er1
12688   cat conftest.err >&5
12689   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12690   (exit $ac_status); } &&
12691          { ac_try='test -z "$ac_c_werror_flag"
12692                          || test ! -s conftest.err'
12693   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12694   (eval $ac_try) 2>&5
12695   ac_status=$?
12696   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12697   (exit $ac_status); }; } &&
12698          { ac_try='test -s conftest$ac_exeext'
12699   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12700   (eval $ac_try) 2>&5
12701   ac_status=$?
12702   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12703   (exit $ac_status); }; }; then
12704   ac_cv_lib_m_atanhf=yes
12705 else
12706   echo "$as_me: failed program was:" >&5
12707 sed 's/^/| /' conftest.$ac_ext >&5
12708
12709 ac_cv_lib_m_atanhf=no
12710 fi
12711 rm -f conftest.err conftest.$ac_objext \
12712       conftest$ac_exeext conftest.$ac_ext
12713 LIBS=$ac_check_lib_save_LIBS
12714 fi
12715 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanhf" >&5
12716 echo "${ECHO_T}$ac_cv_lib_m_atanhf" >&6
12717 if test $ac_cv_lib_m_atanhf = yes; then
12718
12719 cat >>confdefs.h <<\_ACEOF
12720 #define HAVE_ATANHF 1
12721 _ACEOF
12722
12723 fi
12724
12725 echo "$as_me:$LINENO: checking for atanh in -lm" >&5
12726 echo $ECHO_N "checking for atanh in -lm... $ECHO_C" >&6
12727 if test "${ac_cv_lib_m_atanh+set}" = set; then
12728   echo $ECHO_N "(cached) $ECHO_C" >&6
12729 else
12730   ac_check_lib_save_LIBS=$LIBS
12731 LIBS="-lm  $LIBS"
12732 if test x$gcc_no_link = xyes; then
12733   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12734 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12735    { (exit 1); exit 1; }; }
12736 fi
12737 cat >conftest.$ac_ext <<_ACEOF
12738 /* confdefs.h.  */
12739 _ACEOF
12740 cat confdefs.h >>conftest.$ac_ext
12741 cat >>conftest.$ac_ext <<_ACEOF
12742 /* end confdefs.h.  */
12743
12744 /* Override any gcc2 internal prototype to avoid an error.  */
12745 #ifdef __cplusplus
12746 extern "C"
12747 #endif
12748 /* We use char because int might match the return type of a gcc2
12749    builtin and then its argument prototype would still apply.  */
12750 char atanh ();
12751 int
12752 main ()
12753 {
12754 atanh ();
12755   ;
12756   return 0;
12757 }
12758 _ACEOF
12759 rm -f conftest.$ac_objext conftest$ac_exeext
12760 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12761   (eval $ac_link) 2>conftest.er1
12762   ac_status=$?
12763   grep -v '^ *+' conftest.er1 >conftest.err
12764   rm -f conftest.er1
12765   cat conftest.err >&5
12766   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12767   (exit $ac_status); } &&
12768          { ac_try='test -z "$ac_c_werror_flag"
12769                          || test ! -s conftest.err'
12770   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12771   (eval $ac_try) 2>&5
12772   ac_status=$?
12773   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12774   (exit $ac_status); }; } &&
12775          { ac_try='test -s conftest$ac_exeext'
12776   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12777   (eval $ac_try) 2>&5
12778   ac_status=$?
12779   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12780   (exit $ac_status); }; }; then
12781   ac_cv_lib_m_atanh=yes
12782 else
12783   echo "$as_me: failed program was:" >&5
12784 sed 's/^/| /' conftest.$ac_ext >&5
12785
12786 ac_cv_lib_m_atanh=no
12787 fi
12788 rm -f conftest.err conftest.$ac_objext \
12789       conftest$ac_exeext conftest.$ac_ext
12790 LIBS=$ac_check_lib_save_LIBS
12791 fi
12792 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanh" >&5
12793 echo "${ECHO_T}$ac_cv_lib_m_atanh" >&6
12794 if test $ac_cv_lib_m_atanh = yes; then
12795
12796 cat >>confdefs.h <<\_ACEOF
12797 #define HAVE_ATANH 1
12798 _ACEOF
12799
12800 fi
12801
12802 echo "$as_me:$LINENO: checking for atanhl in -lm" >&5
12803 echo $ECHO_N "checking for atanhl in -lm... $ECHO_C" >&6
12804 if test "${ac_cv_lib_m_atanhl+set}" = set; then
12805   echo $ECHO_N "(cached) $ECHO_C" >&6
12806 else
12807   ac_check_lib_save_LIBS=$LIBS
12808 LIBS="-lm  $LIBS"
12809 if test x$gcc_no_link = xyes; then
12810   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12811 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12812    { (exit 1); exit 1; }; }
12813 fi
12814 cat >conftest.$ac_ext <<_ACEOF
12815 /* confdefs.h.  */
12816 _ACEOF
12817 cat confdefs.h >>conftest.$ac_ext
12818 cat >>conftest.$ac_ext <<_ACEOF
12819 /* end confdefs.h.  */
12820
12821 /* Override any gcc2 internal prototype to avoid an error.  */
12822 #ifdef __cplusplus
12823 extern "C"
12824 #endif
12825 /* We use char because int might match the return type of a gcc2
12826    builtin and then its argument prototype would still apply.  */
12827 char atanhl ();
12828 int
12829 main ()
12830 {
12831 atanhl ();
12832   ;
12833   return 0;
12834 }
12835 _ACEOF
12836 rm -f conftest.$ac_objext conftest$ac_exeext
12837 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12838   (eval $ac_link) 2>conftest.er1
12839   ac_status=$?
12840   grep -v '^ *+' conftest.er1 >conftest.err
12841   rm -f conftest.er1
12842   cat conftest.err >&5
12843   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12844   (exit $ac_status); } &&
12845          { ac_try='test -z "$ac_c_werror_flag"
12846                          || test ! -s conftest.err'
12847   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12848   (eval $ac_try) 2>&5
12849   ac_status=$?
12850   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12851   (exit $ac_status); }; } &&
12852          { ac_try='test -s conftest$ac_exeext'
12853   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12854   (eval $ac_try) 2>&5
12855   ac_status=$?
12856   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12857   (exit $ac_status); }; }; then
12858   ac_cv_lib_m_atanhl=yes
12859 else
12860   echo "$as_me: failed program was:" >&5
12861 sed 's/^/| /' conftest.$ac_ext >&5
12862
12863 ac_cv_lib_m_atanhl=no
12864 fi
12865 rm -f conftest.err conftest.$ac_objext \
12866       conftest$ac_exeext conftest.$ac_ext
12867 LIBS=$ac_check_lib_save_LIBS
12868 fi
12869 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanhl" >&5
12870 echo "${ECHO_T}$ac_cv_lib_m_atanhl" >&6
12871 if test $ac_cv_lib_m_atanhl = yes; then
12872
12873 cat >>confdefs.h <<\_ACEOF
12874 #define HAVE_ATANHL 1
12875 _ACEOF
12876
12877 fi
12878
12879 echo "$as_me:$LINENO: checking for cargf in -lm" >&5
12880 echo $ECHO_N "checking for cargf in -lm... $ECHO_C" >&6
12881 if test "${ac_cv_lib_m_cargf+set}" = set; then
12882   echo $ECHO_N "(cached) $ECHO_C" >&6
12883 else
12884   ac_check_lib_save_LIBS=$LIBS
12885 LIBS="-lm  $LIBS"
12886 if test x$gcc_no_link = xyes; then
12887   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12888 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12889    { (exit 1); exit 1; }; }
12890 fi
12891 cat >conftest.$ac_ext <<_ACEOF
12892 /* confdefs.h.  */
12893 _ACEOF
12894 cat confdefs.h >>conftest.$ac_ext
12895 cat >>conftest.$ac_ext <<_ACEOF
12896 /* end confdefs.h.  */
12897
12898 /* Override any gcc2 internal prototype to avoid an error.  */
12899 #ifdef __cplusplus
12900 extern "C"
12901 #endif
12902 /* We use char because int might match the return type of a gcc2
12903    builtin and then its argument prototype would still apply.  */
12904 char cargf ();
12905 int
12906 main ()
12907 {
12908 cargf ();
12909   ;
12910   return 0;
12911 }
12912 _ACEOF
12913 rm -f conftest.$ac_objext conftest$ac_exeext
12914 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12915   (eval $ac_link) 2>conftest.er1
12916   ac_status=$?
12917   grep -v '^ *+' conftest.er1 >conftest.err
12918   rm -f conftest.er1
12919   cat conftest.err >&5
12920   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12921   (exit $ac_status); } &&
12922          { ac_try='test -z "$ac_c_werror_flag"
12923                          || test ! -s conftest.err'
12924   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12925   (eval $ac_try) 2>&5
12926   ac_status=$?
12927   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12928   (exit $ac_status); }; } &&
12929          { ac_try='test -s conftest$ac_exeext'
12930   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12931   (eval $ac_try) 2>&5
12932   ac_status=$?
12933   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12934   (exit $ac_status); }; }; then
12935   ac_cv_lib_m_cargf=yes
12936 else
12937   echo "$as_me: failed program was:" >&5
12938 sed 's/^/| /' conftest.$ac_ext >&5
12939
12940 ac_cv_lib_m_cargf=no
12941 fi
12942 rm -f conftest.err conftest.$ac_objext \
12943       conftest$ac_exeext conftest.$ac_ext
12944 LIBS=$ac_check_lib_save_LIBS
12945 fi
12946 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cargf" >&5
12947 echo "${ECHO_T}$ac_cv_lib_m_cargf" >&6
12948 if test $ac_cv_lib_m_cargf = yes; then
12949
12950 cat >>confdefs.h <<\_ACEOF
12951 #define HAVE_CARGF 1
12952 _ACEOF
12953
12954 fi
12955
12956 echo "$as_me:$LINENO: checking for carg in -lm" >&5
12957 echo $ECHO_N "checking for carg in -lm... $ECHO_C" >&6
12958 if test "${ac_cv_lib_m_carg+set}" = set; then
12959   echo $ECHO_N "(cached) $ECHO_C" >&6
12960 else
12961   ac_check_lib_save_LIBS=$LIBS
12962 LIBS="-lm  $LIBS"
12963 if test x$gcc_no_link = xyes; then
12964   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12965 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12966    { (exit 1); exit 1; }; }
12967 fi
12968 cat >conftest.$ac_ext <<_ACEOF
12969 /* confdefs.h.  */
12970 _ACEOF
12971 cat confdefs.h >>conftest.$ac_ext
12972 cat >>conftest.$ac_ext <<_ACEOF
12973 /* end confdefs.h.  */
12974
12975 /* Override any gcc2 internal prototype to avoid an error.  */
12976 #ifdef __cplusplus
12977 extern "C"
12978 #endif
12979 /* We use char because int might match the return type of a gcc2
12980    builtin and then its argument prototype would still apply.  */
12981 char carg ();
12982 int
12983 main ()
12984 {
12985 carg ();
12986   ;
12987   return 0;
12988 }
12989 _ACEOF
12990 rm -f conftest.$ac_objext conftest$ac_exeext
12991 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12992   (eval $ac_link) 2>conftest.er1
12993   ac_status=$?
12994   grep -v '^ *+' conftest.er1 >conftest.err
12995   rm -f conftest.er1
12996   cat conftest.err >&5
12997   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12998   (exit $ac_status); } &&
12999          { ac_try='test -z "$ac_c_werror_flag"
13000                          || test ! -s conftest.err'
13001   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13002   (eval $ac_try) 2>&5
13003   ac_status=$?
13004   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13005   (exit $ac_status); }; } &&
13006          { ac_try='test -s conftest$ac_exeext'
13007   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13008   (eval $ac_try) 2>&5
13009   ac_status=$?
13010   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13011   (exit $ac_status); }; }; then
13012   ac_cv_lib_m_carg=yes
13013 else
13014   echo "$as_me: failed program was:" >&5
13015 sed 's/^/| /' conftest.$ac_ext >&5
13016
13017 ac_cv_lib_m_carg=no
13018 fi
13019 rm -f conftest.err conftest.$ac_objext \
13020       conftest$ac_exeext conftest.$ac_ext
13021 LIBS=$ac_check_lib_save_LIBS
13022 fi
13023 echo "$as_me:$LINENO: result: $ac_cv_lib_m_carg" >&5
13024 echo "${ECHO_T}$ac_cv_lib_m_carg" >&6
13025 if test $ac_cv_lib_m_carg = yes; then
13026
13027 cat >>confdefs.h <<\_ACEOF
13028 #define HAVE_CARG 1
13029 _ACEOF
13030
13031 fi
13032
13033 echo "$as_me:$LINENO: checking for cargl in -lm" >&5
13034 echo $ECHO_N "checking for cargl in -lm... $ECHO_C" >&6
13035 if test "${ac_cv_lib_m_cargl+set}" = set; then
13036   echo $ECHO_N "(cached) $ECHO_C" >&6
13037 else
13038   ac_check_lib_save_LIBS=$LIBS
13039 LIBS="-lm  $LIBS"
13040 if test x$gcc_no_link = xyes; then
13041   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13042 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13043    { (exit 1); exit 1; }; }
13044 fi
13045 cat >conftest.$ac_ext <<_ACEOF
13046 /* confdefs.h.  */
13047 _ACEOF
13048 cat confdefs.h >>conftest.$ac_ext
13049 cat >>conftest.$ac_ext <<_ACEOF
13050 /* end confdefs.h.  */
13051
13052 /* Override any gcc2 internal prototype to avoid an error.  */
13053 #ifdef __cplusplus
13054 extern "C"
13055 #endif
13056 /* We use char because int might match the return type of a gcc2
13057    builtin and then its argument prototype would still apply.  */
13058 char cargl ();
13059 int
13060 main ()
13061 {
13062 cargl ();
13063   ;
13064   return 0;
13065 }
13066 _ACEOF
13067 rm -f conftest.$ac_objext conftest$ac_exeext
13068 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13069   (eval $ac_link) 2>conftest.er1
13070   ac_status=$?
13071   grep -v '^ *+' conftest.er1 >conftest.err
13072   rm -f conftest.er1
13073   cat conftest.err >&5
13074   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13075   (exit $ac_status); } &&
13076          { ac_try='test -z "$ac_c_werror_flag"
13077                          || test ! -s conftest.err'
13078   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13079   (eval $ac_try) 2>&5
13080   ac_status=$?
13081   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13082   (exit $ac_status); }; } &&
13083          { ac_try='test -s conftest$ac_exeext'
13084   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13085   (eval $ac_try) 2>&5
13086   ac_status=$?
13087   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13088   (exit $ac_status); }; }; then
13089   ac_cv_lib_m_cargl=yes
13090 else
13091   echo "$as_me: failed program was:" >&5
13092 sed 's/^/| /' conftest.$ac_ext >&5
13093
13094 ac_cv_lib_m_cargl=no
13095 fi
13096 rm -f conftest.err conftest.$ac_objext \
13097       conftest$ac_exeext conftest.$ac_ext
13098 LIBS=$ac_check_lib_save_LIBS
13099 fi
13100 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cargl" >&5
13101 echo "${ECHO_T}$ac_cv_lib_m_cargl" >&6
13102 if test $ac_cv_lib_m_cargl = yes; then
13103
13104 cat >>confdefs.h <<\_ACEOF
13105 #define HAVE_CARGL 1
13106 _ACEOF
13107
13108 fi
13109
13110 echo "$as_me:$LINENO: checking for ceilf in -lm" >&5
13111 echo $ECHO_N "checking for ceilf in -lm... $ECHO_C" >&6
13112 if test "${ac_cv_lib_m_ceilf+set}" = set; then
13113   echo $ECHO_N "(cached) $ECHO_C" >&6
13114 else
13115   ac_check_lib_save_LIBS=$LIBS
13116 LIBS="-lm  $LIBS"
13117 if test x$gcc_no_link = xyes; then
13118   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13119 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13120    { (exit 1); exit 1; }; }
13121 fi
13122 cat >conftest.$ac_ext <<_ACEOF
13123 /* confdefs.h.  */
13124 _ACEOF
13125 cat confdefs.h >>conftest.$ac_ext
13126 cat >>conftest.$ac_ext <<_ACEOF
13127 /* end confdefs.h.  */
13128
13129 /* Override any gcc2 internal prototype to avoid an error.  */
13130 #ifdef __cplusplus
13131 extern "C"
13132 #endif
13133 /* We use char because int might match the return type of a gcc2
13134    builtin and then its argument prototype would still apply.  */
13135 char ceilf ();
13136 int
13137 main ()
13138 {
13139 ceilf ();
13140   ;
13141   return 0;
13142 }
13143 _ACEOF
13144 rm -f conftest.$ac_objext conftest$ac_exeext
13145 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13146   (eval $ac_link) 2>conftest.er1
13147   ac_status=$?
13148   grep -v '^ *+' conftest.er1 >conftest.err
13149   rm -f conftest.er1
13150   cat conftest.err >&5
13151   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13152   (exit $ac_status); } &&
13153          { ac_try='test -z "$ac_c_werror_flag"
13154                          || test ! -s conftest.err'
13155   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13156   (eval $ac_try) 2>&5
13157   ac_status=$?
13158   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13159   (exit $ac_status); }; } &&
13160          { ac_try='test -s conftest$ac_exeext'
13161   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13162   (eval $ac_try) 2>&5
13163   ac_status=$?
13164   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13165   (exit $ac_status); }; }; then
13166   ac_cv_lib_m_ceilf=yes
13167 else
13168   echo "$as_me: failed program was:" >&5
13169 sed 's/^/| /' conftest.$ac_ext >&5
13170
13171 ac_cv_lib_m_ceilf=no
13172 fi
13173 rm -f conftest.err conftest.$ac_objext \
13174       conftest$ac_exeext conftest.$ac_ext
13175 LIBS=$ac_check_lib_save_LIBS
13176 fi
13177 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceilf" >&5
13178 echo "${ECHO_T}$ac_cv_lib_m_ceilf" >&6
13179 if test $ac_cv_lib_m_ceilf = yes; then
13180
13181 cat >>confdefs.h <<\_ACEOF
13182 #define HAVE_CEILF 1
13183 _ACEOF
13184
13185 fi
13186
13187 echo "$as_me:$LINENO: checking for ceil in -lm" >&5
13188 echo $ECHO_N "checking for ceil in -lm... $ECHO_C" >&6
13189 if test "${ac_cv_lib_m_ceil+set}" = set; then
13190   echo $ECHO_N "(cached) $ECHO_C" >&6
13191 else
13192   ac_check_lib_save_LIBS=$LIBS
13193 LIBS="-lm  $LIBS"
13194 if test x$gcc_no_link = xyes; then
13195   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13196 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13197    { (exit 1); exit 1; }; }
13198 fi
13199 cat >conftest.$ac_ext <<_ACEOF
13200 /* confdefs.h.  */
13201 _ACEOF
13202 cat confdefs.h >>conftest.$ac_ext
13203 cat >>conftest.$ac_ext <<_ACEOF
13204 /* end confdefs.h.  */
13205
13206 /* Override any gcc2 internal prototype to avoid an error.  */
13207 #ifdef __cplusplus
13208 extern "C"
13209 #endif
13210 /* We use char because int might match the return type of a gcc2
13211    builtin and then its argument prototype would still apply.  */
13212 char ceil ();
13213 int
13214 main ()
13215 {
13216 ceil ();
13217   ;
13218   return 0;
13219 }
13220 _ACEOF
13221 rm -f conftest.$ac_objext conftest$ac_exeext
13222 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13223   (eval $ac_link) 2>conftest.er1
13224   ac_status=$?
13225   grep -v '^ *+' conftest.er1 >conftest.err
13226   rm -f conftest.er1
13227   cat conftest.err >&5
13228   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13229   (exit $ac_status); } &&
13230          { ac_try='test -z "$ac_c_werror_flag"
13231                          || test ! -s conftest.err'
13232   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13233   (eval $ac_try) 2>&5
13234   ac_status=$?
13235   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13236   (exit $ac_status); }; } &&
13237          { ac_try='test -s conftest$ac_exeext'
13238   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13239   (eval $ac_try) 2>&5
13240   ac_status=$?
13241   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13242   (exit $ac_status); }; }; then
13243   ac_cv_lib_m_ceil=yes
13244 else
13245   echo "$as_me: failed program was:" >&5
13246 sed 's/^/| /' conftest.$ac_ext >&5
13247
13248 ac_cv_lib_m_ceil=no
13249 fi
13250 rm -f conftest.err conftest.$ac_objext \
13251       conftest$ac_exeext conftest.$ac_ext
13252 LIBS=$ac_check_lib_save_LIBS
13253 fi
13254 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceil" >&5
13255 echo "${ECHO_T}$ac_cv_lib_m_ceil" >&6
13256 if test $ac_cv_lib_m_ceil = yes; then
13257
13258 cat >>confdefs.h <<\_ACEOF
13259 #define HAVE_CEIL 1
13260 _ACEOF
13261
13262 fi
13263
13264 echo "$as_me:$LINENO: checking for ceill in -lm" >&5
13265 echo $ECHO_N "checking for ceill in -lm... $ECHO_C" >&6
13266 if test "${ac_cv_lib_m_ceill+set}" = set; then
13267   echo $ECHO_N "(cached) $ECHO_C" >&6
13268 else
13269   ac_check_lib_save_LIBS=$LIBS
13270 LIBS="-lm  $LIBS"
13271 if test x$gcc_no_link = xyes; then
13272   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13273 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13274    { (exit 1); exit 1; }; }
13275 fi
13276 cat >conftest.$ac_ext <<_ACEOF
13277 /* confdefs.h.  */
13278 _ACEOF
13279 cat confdefs.h >>conftest.$ac_ext
13280 cat >>conftest.$ac_ext <<_ACEOF
13281 /* end confdefs.h.  */
13282
13283 /* Override any gcc2 internal prototype to avoid an error.  */
13284 #ifdef __cplusplus
13285 extern "C"
13286 #endif
13287 /* We use char because int might match the return type of a gcc2
13288    builtin and then its argument prototype would still apply.  */
13289 char ceill ();
13290 int
13291 main ()
13292 {
13293 ceill ();
13294   ;
13295   return 0;
13296 }
13297 _ACEOF
13298 rm -f conftest.$ac_objext conftest$ac_exeext
13299 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13300   (eval $ac_link) 2>conftest.er1
13301   ac_status=$?
13302   grep -v '^ *+' conftest.er1 >conftest.err
13303   rm -f conftest.er1
13304   cat conftest.err >&5
13305   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13306   (exit $ac_status); } &&
13307          { ac_try='test -z "$ac_c_werror_flag"
13308                          || test ! -s conftest.err'
13309   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13310   (eval $ac_try) 2>&5
13311   ac_status=$?
13312   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13313   (exit $ac_status); }; } &&
13314          { ac_try='test -s conftest$ac_exeext'
13315   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13316   (eval $ac_try) 2>&5
13317   ac_status=$?
13318   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13319   (exit $ac_status); }; }; then
13320   ac_cv_lib_m_ceill=yes
13321 else
13322   echo "$as_me: failed program was:" >&5
13323 sed 's/^/| /' conftest.$ac_ext >&5
13324
13325 ac_cv_lib_m_ceill=no
13326 fi
13327 rm -f conftest.err conftest.$ac_objext \
13328       conftest$ac_exeext conftest.$ac_ext
13329 LIBS=$ac_check_lib_save_LIBS
13330 fi
13331 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceill" >&5
13332 echo "${ECHO_T}$ac_cv_lib_m_ceill" >&6
13333 if test $ac_cv_lib_m_ceill = yes; then
13334
13335 cat >>confdefs.h <<\_ACEOF
13336 #define HAVE_CEILL 1
13337 _ACEOF
13338
13339 fi
13340
13341 echo "$as_me:$LINENO: checking for copysignf in -lm" >&5
13342 echo $ECHO_N "checking for copysignf in -lm... $ECHO_C" >&6
13343 if test "${ac_cv_lib_m_copysignf+set}" = set; then
13344   echo $ECHO_N "(cached) $ECHO_C" >&6
13345 else
13346   ac_check_lib_save_LIBS=$LIBS
13347 LIBS="-lm  $LIBS"
13348 if test x$gcc_no_link = xyes; then
13349   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13350 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13351    { (exit 1); exit 1; }; }
13352 fi
13353 cat >conftest.$ac_ext <<_ACEOF
13354 /* confdefs.h.  */
13355 _ACEOF
13356 cat confdefs.h >>conftest.$ac_ext
13357 cat >>conftest.$ac_ext <<_ACEOF
13358 /* end confdefs.h.  */
13359
13360 /* Override any gcc2 internal prototype to avoid an error.  */
13361 #ifdef __cplusplus
13362 extern "C"
13363 #endif
13364 /* We use char because int might match the return type of a gcc2
13365    builtin and then its argument prototype would still apply.  */
13366 char copysignf ();
13367 int
13368 main ()
13369 {
13370 copysignf ();
13371   ;
13372   return 0;
13373 }
13374 _ACEOF
13375 rm -f conftest.$ac_objext conftest$ac_exeext
13376 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13377   (eval $ac_link) 2>conftest.er1
13378   ac_status=$?
13379   grep -v '^ *+' conftest.er1 >conftest.err
13380   rm -f conftest.er1
13381   cat conftest.err >&5
13382   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13383   (exit $ac_status); } &&
13384          { ac_try='test -z "$ac_c_werror_flag"
13385                          || test ! -s conftest.err'
13386   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13387   (eval $ac_try) 2>&5
13388   ac_status=$?
13389   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13390   (exit $ac_status); }; } &&
13391          { ac_try='test -s conftest$ac_exeext'
13392   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13393   (eval $ac_try) 2>&5
13394   ac_status=$?
13395   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13396   (exit $ac_status); }; }; then
13397   ac_cv_lib_m_copysignf=yes
13398 else
13399   echo "$as_me: failed program was:" >&5
13400 sed 's/^/| /' conftest.$ac_ext >&5
13401
13402 ac_cv_lib_m_copysignf=no
13403 fi
13404 rm -f conftest.err conftest.$ac_objext \
13405       conftest$ac_exeext conftest.$ac_ext
13406 LIBS=$ac_check_lib_save_LIBS
13407 fi
13408 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysignf" >&5
13409 echo "${ECHO_T}$ac_cv_lib_m_copysignf" >&6
13410 if test $ac_cv_lib_m_copysignf = yes; then
13411
13412 cat >>confdefs.h <<\_ACEOF
13413 #define HAVE_COPYSIGNF 1
13414 _ACEOF
13415
13416 fi
13417
13418 echo "$as_me:$LINENO: checking for copysign in -lm" >&5
13419 echo $ECHO_N "checking for copysign in -lm... $ECHO_C" >&6
13420 if test "${ac_cv_lib_m_copysign+set}" = set; then
13421   echo $ECHO_N "(cached) $ECHO_C" >&6
13422 else
13423   ac_check_lib_save_LIBS=$LIBS
13424 LIBS="-lm  $LIBS"
13425 if test x$gcc_no_link = xyes; then
13426   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13427 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13428    { (exit 1); exit 1; }; }
13429 fi
13430 cat >conftest.$ac_ext <<_ACEOF
13431 /* confdefs.h.  */
13432 _ACEOF
13433 cat confdefs.h >>conftest.$ac_ext
13434 cat >>conftest.$ac_ext <<_ACEOF
13435 /* end confdefs.h.  */
13436
13437 /* Override any gcc2 internal prototype to avoid an error.  */
13438 #ifdef __cplusplus
13439 extern "C"
13440 #endif
13441 /* We use char because int might match the return type of a gcc2
13442    builtin and then its argument prototype would still apply.  */
13443 char copysign ();
13444 int
13445 main ()
13446 {
13447 copysign ();
13448   ;
13449   return 0;
13450 }
13451 _ACEOF
13452 rm -f conftest.$ac_objext conftest$ac_exeext
13453 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13454   (eval $ac_link) 2>conftest.er1
13455   ac_status=$?
13456   grep -v '^ *+' conftest.er1 >conftest.err
13457   rm -f conftest.er1
13458   cat conftest.err >&5
13459   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13460   (exit $ac_status); } &&
13461          { ac_try='test -z "$ac_c_werror_flag"
13462                          || test ! -s conftest.err'
13463   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13464   (eval $ac_try) 2>&5
13465   ac_status=$?
13466   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13467   (exit $ac_status); }; } &&
13468          { ac_try='test -s conftest$ac_exeext'
13469   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13470   (eval $ac_try) 2>&5
13471   ac_status=$?
13472   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13473   (exit $ac_status); }; }; then
13474   ac_cv_lib_m_copysign=yes
13475 else
13476   echo "$as_me: failed program was:" >&5
13477 sed 's/^/| /' conftest.$ac_ext >&5
13478
13479 ac_cv_lib_m_copysign=no
13480 fi
13481 rm -f conftest.err conftest.$ac_objext \
13482       conftest$ac_exeext conftest.$ac_ext
13483 LIBS=$ac_check_lib_save_LIBS
13484 fi
13485 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysign" >&5
13486 echo "${ECHO_T}$ac_cv_lib_m_copysign" >&6
13487 if test $ac_cv_lib_m_copysign = yes; then
13488
13489 cat >>confdefs.h <<\_ACEOF
13490 #define HAVE_COPYSIGN 1
13491 _ACEOF
13492
13493 fi
13494
13495 echo "$as_me:$LINENO: checking for copysignl in -lm" >&5
13496 echo $ECHO_N "checking for copysignl in -lm... $ECHO_C" >&6
13497 if test "${ac_cv_lib_m_copysignl+set}" = set; then
13498   echo $ECHO_N "(cached) $ECHO_C" >&6
13499 else
13500   ac_check_lib_save_LIBS=$LIBS
13501 LIBS="-lm  $LIBS"
13502 if test x$gcc_no_link = xyes; then
13503   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13504 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13505    { (exit 1); exit 1; }; }
13506 fi
13507 cat >conftest.$ac_ext <<_ACEOF
13508 /* confdefs.h.  */
13509 _ACEOF
13510 cat confdefs.h >>conftest.$ac_ext
13511 cat >>conftest.$ac_ext <<_ACEOF
13512 /* end confdefs.h.  */
13513
13514 /* Override any gcc2 internal prototype to avoid an error.  */
13515 #ifdef __cplusplus
13516 extern "C"
13517 #endif
13518 /* We use char because int might match the return type of a gcc2
13519    builtin and then its argument prototype would still apply.  */
13520 char copysignl ();
13521 int
13522 main ()
13523 {
13524 copysignl ();
13525   ;
13526   return 0;
13527 }
13528 _ACEOF
13529 rm -f conftest.$ac_objext conftest$ac_exeext
13530 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13531   (eval $ac_link) 2>conftest.er1
13532   ac_status=$?
13533   grep -v '^ *+' conftest.er1 >conftest.err
13534   rm -f conftest.er1
13535   cat conftest.err >&5
13536   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13537   (exit $ac_status); } &&
13538          { ac_try='test -z "$ac_c_werror_flag"
13539                          || test ! -s conftest.err'
13540   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13541   (eval $ac_try) 2>&5
13542   ac_status=$?
13543   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13544   (exit $ac_status); }; } &&
13545          { ac_try='test -s conftest$ac_exeext'
13546   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13547   (eval $ac_try) 2>&5
13548   ac_status=$?
13549   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13550   (exit $ac_status); }; }; then
13551   ac_cv_lib_m_copysignl=yes
13552 else
13553   echo "$as_me: failed program was:" >&5
13554 sed 's/^/| /' conftest.$ac_ext >&5
13555
13556 ac_cv_lib_m_copysignl=no
13557 fi
13558 rm -f conftest.err conftest.$ac_objext \
13559       conftest$ac_exeext conftest.$ac_ext
13560 LIBS=$ac_check_lib_save_LIBS
13561 fi
13562 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysignl" >&5
13563 echo "${ECHO_T}$ac_cv_lib_m_copysignl" >&6
13564 if test $ac_cv_lib_m_copysignl = yes; then
13565
13566 cat >>confdefs.h <<\_ACEOF
13567 #define HAVE_COPYSIGNL 1
13568 _ACEOF
13569
13570 fi
13571
13572 echo "$as_me:$LINENO: checking for cosf in -lm" >&5
13573 echo $ECHO_N "checking for cosf in -lm... $ECHO_C" >&6
13574 if test "${ac_cv_lib_m_cosf+set}" = set; then
13575   echo $ECHO_N "(cached) $ECHO_C" >&6
13576 else
13577   ac_check_lib_save_LIBS=$LIBS
13578 LIBS="-lm  $LIBS"
13579 if test x$gcc_no_link = xyes; then
13580   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13581 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13582    { (exit 1); exit 1; }; }
13583 fi
13584 cat >conftest.$ac_ext <<_ACEOF
13585 /* confdefs.h.  */
13586 _ACEOF
13587 cat confdefs.h >>conftest.$ac_ext
13588 cat >>conftest.$ac_ext <<_ACEOF
13589 /* end confdefs.h.  */
13590
13591 /* Override any gcc2 internal prototype to avoid an error.  */
13592 #ifdef __cplusplus
13593 extern "C"
13594 #endif
13595 /* We use char because int might match the return type of a gcc2
13596    builtin and then its argument prototype would still apply.  */
13597 char cosf ();
13598 int
13599 main ()
13600 {
13601 cosf ();
13602   ;
13603   return 0;
13604 }
13605 _ACEOF
13606 rm -f conftest.$ac_objext conftest$ac_exeext
13607 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13608   (eval $ac_link) 2>conftest.er1
13609   ac_status=$?
13610   grep -v '^ *+' conftest.er1 >conftest.err
13611   rm -f conftest.er1
13612   cat conftest.err >&5
13613   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13614   (exit $ac_status); } &&
13615          { ac_try='test -z "$ac_c_werror_flag"
13616                          || test ! -s conftest.err'
13617   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13618   (eval $ac_try) 2>&5
13619   ac_status=$?
13620   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13621   (exit $ac_status); }; } &&
13622          { ac_try='test -s conftest$ac_exeext'
13623   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13624   (eval $ac_try) 2>&5
13625   ac_status=$?
13626   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13627   (exit $ac_status); }; }; then
13628   ac_cv_lib_m_cosf=yes
13629 else
13630   echo "$as_me: failed program was:" >&5
13631 sed 's/^/| /' conftest.$ac_ext >&5
13632
13633 ac_cv_lib_m_cosf=no
13634 fi
13635 rm -f conftest.err conftest.$ac_objext \
13636       conftest$ac_exeext conftest.$ac_ext
13637 LIBS=$ac_check_lib_save_LIBS
13638 fi
13639 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosf" >&5
13640 echo "${ECHO_T}$ac_cv_lib_m_cosf" >&6
13641 if test $ac_cv_lib_m_cosf = yes; then
13642
13643 cat >>confdefs.h <<\_ACEOF
13644 #define HAVE_COSF 1
13645 _ACEOF
13646
13647 fi
13648
13649 echo "$as_me:$LINENO: checking for cos in -lm" >&5
13650 echo $ECHO_N "checking for cos in -lm... $ECHO_C" >&6
13651 if test "${ac_cv_lib_m_cos+set}" = set; then
13652   echo $ECHO_N "(cached) $ECHO_C" >&6
13653 else
13654   ac_check_lib_save_LIBS=$LIBS
13655 LIBS="-lm  $LIBS"
13656 if test x$gcc_no_link = xyes; then
13657   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13658 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13659    { (exit 1); exit 1; }; }
13660 fi
13661 cat >conftest.$ac_ext <<_ACEOF
13662 /* confdefs.h.  */
13663 _ACEOF
13664 cat confdefs.h >>conftest.$ac_ext
13665 cat >>conftest.$ac_ext <<_ACEOF
13666 /* end confdefs.h.  */
13667
13668 /* Override any gcc2 internal prototype to avoid an error.  */
13669 #ifdef __cplusplus
13670 extern "C"
13671 #endif
13672 /* We use char because int might match the return type of a gcc2
13673    builtin and then its argument prototype would still apply.  */
13674 char cos ();
13675 int
13676 main ()
13677 {
13678 cos ();
13679   ;
13680   return 0;
13681 }
13682 _ACEOF
13683 rm -f conftest.$ac_objext conftest$ac_exeext
13684 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13685   (eval $ac_link) 2>conftest.er1
13686   ac_status=$?
13687   grep -v '^ *+' conftest.er1 >conftest.err
13688   rm -f conftest.er1
13689   cat conftest.err >&5
13690   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13691   (exit $ac_status); } &&
13692          { ac_try='test -z "$ac_c_werror_flag"
13693                          || test ! -s conftest.err'
13694   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13695   (eval $ac_try) 2>&5
13696   ac_status=$?
13697   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13698   (exit $ac_status); }; } &&
13699          { ac_try='test -s conftest$ac_exeext'
13700   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13701   (eval $ac_try) 2>&5
13702   ac_status=$?
13703   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13704   (exit $ac_status); }; }; then
13705   ac_cv_lib_m_cos=yes
13706 else
13707   echo "$as_me: failed program was:" >&5
13708 sed 's/^/| /' conftest.$ac_ext >&5
13709
13710 ac_cv_lib_m_cos=no
13711 fi
13712 rm -f conftest.err conftest.$ac_objext \
13713       conftest$ac_exeext conftest.$ac_ext
13714 LIBS=$ac_check_lib_save_LIBS
13715 fi
13716 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cos" >&5
13717 echo "${ECHO_T}$ac_cv_lib_m_cos" >&6
13718 if test $ac_cv_lib_m_cos = yes; then
13719
13720 cat >>confdefs.h <<\_ACEOF
13721 #define HAVE_COS 1
13722 _ACEOF
13723
13724 fi
13725
13726 echo "$as_me:$LINENO: checking for cosl in -lm" >&5
13727 echo $ECHO_N "checking for cosl in -lm... $ECHO_C" >&6
13728 if test "${ac_cv_lib_m_cosl+set}" = set; then
13729   echo $ECHO_N "(cached) $ECHO_C" >&6
13730 else
13731   ac_check_lib_save_LIBS=$LIBS
13732 LIBS="-lm  $LIBS"
13733 if test x$gcc_no_link = xyes; then
13734   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13735 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13736    { (exit 1); exit 1; }; }
13737 fi
13738 cat >conftest.$ac_ext <<_ACEOF
13739 /* confdefs.h.  */
13740 _ACEOF
13741 cat confdefs.h >>conftest.$ac_ext
13742 cat >>conftest.$ac_ext <<_ACEOF
13743 /* end confdefs.h.  */
13744
13745 /* Override any gcc2 internal prototype to avoid an error.  */
13746 #ifdef __cplusplus
13747 extern "C"
13748 #endif
13749 /* We use char because int might match the return type of a gcc2
13750    builtin and then its argument prototype would still apply.  */
13751 char cosl ();
13752 int
13753 main ()
13754 {
13755 cosl ();
13756   ;
13757   return 0;
13758 }
13759 _ACEOF
13760 rm -f conftest.$ac_objext conftest$ac_exeext
13761 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13762   (eval $ac_link) 2>conftest.er1
13763   ac_status=$?
13764   grep -v '^ *+' conftest.er1 >conftest.err
13765   rm -f conftest.er1
13766   cat conftest.err >&5
13767   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13768   (exit $ac_status); } &&
13769          { ac_try='test -z "$ac_c_werror_flag"
13770                          || test ! -s conftest.err'
13771   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13772   (eval $ac_try) 2>&5
13773   ac_status=$?
13774   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13775   (exit $ac_status); }; } &&
13776          { ac_try='test -s conftest$ac_exeext'
13777   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13778   (eval $ac_try) 2>&5
13779   ac_status=$?
13780   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13781   (exit $ac_status); }; }; then
13782   ac_cv_lib_m_cosl=yes
13783 else
13784   echo "$as_me: failed program was:" >&5
13785 sed 's/^/| /' conftest.$ac_ext >&5
13786
13787 ac_cv_lib_m_cosl=no
13788 fi
13789 rm -f conftest.err conftest.$ac_objext \
13790       conftest$ac_exeext conftest.$ac_ext
13791 LIBS=$ac_check_lib_save_LIBS
13792 fi
13793 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosl" >&5
13794 echo "${ECHO_T}$ac_cv_lib_m_cosl" >&6
13795 if test $ac_cv_lib_m_cosl = yes; then
13796
13797 cat >>confdefs.h <<\_ACEOF
13798 #define HAVE_COSL 1
13799 _ACEOF
13800
13801 fi
13802
13803 echo "$as_me:$LINENO: checking for ccosf in -lm" >&5
13804 echo $ECHO_N "checking for ccosf in -lm... $ECHO_C" >&6
13805 if test "${ac_cv_lib_m_ccosf+set}" = set; then
13806   echo $ECHO_N "(cached) $ECHO_C" >&6
13807 else
13808   ac_check_lib_save_LIBS=$LIBS
13809 LIBS="-lm  $LIBS"
13810 if test x$gcc_no_link = xyes; then
13811   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13812 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13813    { (exit 1); exit 1; }; }
13814 fi
13815 cat >conftest.$ac_ext <<_ACEOF
13816 /* confdefs.h.  */
13817 _ACEOF
13818 cat confdefs.h >>conftest.$ac_ext
13819 cat >>conftest.$ac_ext <<_ACEOF
13820 /* end confdefs.h.  */
13821
13822 /* Override any gcc2 internal prototype to avoid an error.  */
13823 #ifdef __cplusplus
13824 extern "C"
13825 #endif
13826 /* We use char because int might match the return type of a gcc2
13827    builtin and then its argument prototype would still apply.  */
13828 char ccosf ();
13829 int
13830 main ()
13831 {
13832 ccosf ();
13833   ;
13834   return 0;
13835 }
13836 _ACEOF
13837 rm -f conftest.$ac_objext conftest$ac_exeext
13838 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13839   (eval $ac_link) 2>conftest.er1
13840   ac_status=$?
13841   grep -v '^ *+' conftest.er1 >conftest.err
13842   rm -f conftest.er1
13843   cat conftest.err >&5
13844   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13845   (exit $ac_status); } &&
13846          { ac_try='test -z "$ac_c_werror_flag"
13847                          || test ! -s conftest.err'
13848   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13849   (eval $ac_try) 2>&5
13850   ac_status=$?
13851   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13852   (exit $ac_status); }; } &&
13853          { ac_try='test -s conftest$ac_exeext'
13854   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13855   (eval $ac_try) 2>&5
13856   ac_status=$?
13857   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13858   (exit $ac_status); }; }; then
13859   ac_cv_lib_m_ccosf=yes
13860 else
13861   echo "$as_me: failed program was:" >&5
13862 sed 's/^/| /' conftest.$ac_ext >&5
13863
13864 ac_cv_lib_m_ccosf=no
13865 fi
13866 rm -f conftest.err conftest.$ac_objext \
13867       conftest$ac_exeext conftest.$ac_ext
13868 LIBS=$ac_check_lib_save_LIBS
13869 fi
13870 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosf" >&5
13871 echo "${ECHO_T}$ac_cv_lib_m_ccosf" >&6
13872 if test $ac_cv_lib_m_ccosf = yes; then
13873
13874 cat >>confdefs.h <<\_ACEOF
13875 #define HAVE_CCOSF 1
13876 _ACEOF
13877
13878 fi
13879
13880 echo "$as_me:$LINENO: checking for ccos in -lm" >&5
13881 echo $ECHO_N "checking for ccos in -lm... $ECHO_C" >&6
13882 if test "${ac_cv_lib_m_ccos+set}" = set; then
13883   echo $ECHO_N "(cached) $ECHO_C" >&6
13884 else
13885   ac_check_lib_save_LIBS=$LIBS
13886 LIBS="-lm  $LIBS"
13887 if test x$gcc_no_link = xyes; then
13888   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13889 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13890    { (exit 1); exit 1; }; }
13891 fi
13892 cat >conftest.$ac_ext <<_ACEOF
13893 /* confdefs.h.  */
13894 _ACEOF
13895 cat confdefs.h >>conftest.$ac_ext
13896 cat >>conftest.$ac_ext <<_ACEOF
13897 /* end confdefs.h.  */
13898
13899 /* Override any gcc2 internal prototype to avoid an error.  */
13900 #ifdef __cplusplus
13901 extern "C"
13902 #endif
13903 /* We use char because int might match the return type of a gcc2
13904    builtin and then its argument prototype would still apply.  */
13905 char ccos ();
13906 int
13907 main ()
13908 {
13909 ccos ();
13910   ;
13911   return 0;
13912 }
13913 _ACEOF
13914 rm -f conftest.$ac_objext conftest$ac_exeext
13915 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13916   (eval $ac_link) 2>conftest.er1
13917   ac_status=$?
13918   grep -v '^ *+' conftest.er1 >conftest.err
13919   rm -f conftest.er1
13920   cat conftest.err >&5
13921   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13922   (exit $ac_status); } &&
13923          { ac_try='test -z "$ac_c_werror_flag"
13924                          || test ! -s conftest.err'
13925   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13926   (eval $ac_try) 2>&5
13927   ac_status=$?
13928   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13929   (exit $ac_status); }; } &&
13930          { ac_try='test -s conftest$ac_exeext'
13931   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13932   (eval $ac_try) 2>&5
13933   ac_status=$?
13934   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13935   (exit $ac_status); }; }; then
13936   ac_cv_lib_m_ccos=yes
13937 else
13938   echo "$as_me: failed program was:" >&5
13939 sed 's/^/| /' conftest.$ac_ext >&5
13940
13941 ac_cv_lib_m_ccos=no
13942 fi
13943 rm -f conftest.err conftest.$ac_objext \
13944       conftest$ac_exeext conftest.$ac_ext
13945 LIBS=$ac_check_lib_save_LIBS
13946 fi
13947 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccos" >&5
13948 echo "${ECHO_T}$ac_cv_lib_m_ccos" >&6
13949 if test $ac_cv_lib_m_ccos = yes; then
13950
13951 cat >>confdefs.h <<\_ACEOF
13952 #define HAVE_CCOS 1
13953 _ACEOF
13954
13955 fi
13956
13957 echo "$as_me:$LINENO: checking for ccosl in -lm" >&5
13958 echo $ECHO_N "checking for ccosl in -lm... $ECHO_C" >&6
13959 if test "${ac_cv_lib_m_ccosl+set}" = set; then
13960   echo $ECHO_N "(cached) $ECHO_C" >&6
13961 else
13962   ac_check_lib_save_LIBS=$LIBS
13963 LIBS="-lm  $LIBS"
13964 if test x$gcc_no_link = xyes; then
13965   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13966 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13967    { (exit 1); exit 1; }; }
13968 fi
13969 cat >conftest.$ac_ext <<_ACEOF
13970 /* confdefs.h.  */
13971 _ACEOF
13972 cat confdefs.h >>conftest.$ac_ext
13973 cat >>conftest.$ac_ext <<_ACEOF
13974 /* end confdefs.h.  */
13975
13976 /* Override any gcc2 internal prototype to avoid an error.  */
13977 #ifdef __cplusplus
13978 extern "C"
13979 #endif
13980 /* We use char because int might match the return type of a gcc2
13981    builtin and then its argument prototype would still apply.  */
13982 char ccosl ();
13983 int
13984 main ()
13985 {
13986 ccosl ();
13987   ;
13988   return 0;
13989 }
13990 _ACEOF
13991 rm -f conftest.$ac_objext conftest$ac_exeext
13992 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13993   (eval $ac_link) 2>conftest.er1
13994   ac_status=$?
13995   grep -v '^ *+' conftest.er1 >conftest.err
13996   rm -f conftest.er1
13997   cat conftest.err >&5
13998   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13999   (exit $ac_status); } &&
14000          { ac_try='test -z "$ac_c_werror_flag"
14001                          || test ! -s conftest.err'
14002   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14003   (eval $ac_try) 2>&5
14004   ac_status=$?
14005   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14006   (exit $ac_status); }; } &&
14007          { ac_try='test -s conftest$ac_exeext'
14008   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14009   (eval $ac_try) 2>&5
14010   ac_status=$?
14011   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14012   (exit $ac_status); }; }; then
14013   ac_cv_lib_m_ccosl=yes
14014 else
14015   echo "$as_me: failed program was:" >&5
14016 sed 's/^/| /' conftest.$ac_ext >&5
14017
14018 ac_cv_lib_m_ccosl=no
14019 fi
14020 rm -f conftest.err conftest.$ac_objext \
14021       conftest$ac_exeext conftest.$ac_ext
14022 LIBS=$ac_check_lib_save_LIBS
14023 fi
14024 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosl" >&5
14025 echo "${ECHO_T}$ac_cv_lib_m_ccosl" >&6
14026 if test $ac_cv_lib_m_ccosl = yes; then
14027
14028 cat >>confdefs.h <<\_ACEOF
14029 #define HAVE_CCOSL 1
14030 _ACEOF
14031
14032 fi
14033
14034 echo "$as_me:$LINENO: checking for coshf in -lm" >&5
14035 echo $ECHO_N "checking for coshf in -lm... $ECHO_C" >&6
14036 if test "${ac_cv_lib_m_coshf+set}" = set; then
14037   echo $ECHO_N "(cached) $ECHO_C" >&6
14038 else
14039   ac_check_lib_save_LIBS=$LIBS
14040 LIBS="-lm  $LIBS"
14041 if test x$gcc_no_link = xyes; then
14042   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14043 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14044    { (exit 1); exit 1; }; }
14045 fi
14046 cat >conftest.$ac_ext <<_ACEOF
14047 /* confdefs.h.  */
14048 _ACEOF
14049 cat confdefs.h >>conftest.$ac_ext
14050 cat >>conftest.$ac_ext <<_ACEOF
14051 /* end confdefs.h.  */
14052
14053 /* Override any gcc2 internal prototype to avoid an error.  */
14054 #ifdef __cplusplus
14055 extern "C"
14056 #endif
14057 /* We use char because int might match the return type of a gcc2
14058    builtin and then its argument prototype would still apply.  */
14059 char coshf ();
14060 int
14061 main ()
14062 {
14063 coshf ();
14064   ;
14065   return 0;
14066 }
14067 _ACEOF
14068 rm -f conftest.$ac_objext conftest$ac_exeext
14069 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14070   (eval $ac_link) 2>conftest.er1
14071   ac_status=$?
14072   grep -v '^ *+' conftest.er1 >conftest.err
14073   rm -f conftest.er1
14074   cat conftest.err >&5
14075   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14076   (exit $ac_status); } &&
14077          { ac_try='test -z "$ac_c_werror_flag"
14078                          || test ! -s conftest.err'
14079   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14080   (eval $ac_try) 2>&5
14081   ac_status=$?
14082   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14083   (exit $ac_status); }; } &&
14084          { ac_try='test -s conftest$ac_exeext'
14085   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14086   (eval $ac_try) 2>&5
14087   ac_status=$?
14088   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14089   (exit $ac_status); }; }; then
14090   ac_cv_lib_m_coshf=yes
14091 else
14092   echo "$as_me: failed program was:" >&5
14093 sed 's/^/| /' conftest.$ac_ext >&5
14094
14095 ac_cv_lib_m_coshf=no
14096 fi
14097 rm -f conftest.err conftest.$ac_objext \
14098       conftest$ac_exeext conftest.$ac_ext
14099 LIBS=$ac_check_lib_save_LIBS
14100 fi
14101 echo "$as_me:$LINENO: result: $ac_cv_lib_m_coshf" >&5
14102 echo "${ECHO_T}$ac_cv_lib_m_coshf" >&6
14103 if test $ac_cv_lib_m_coshf = yes; then
14104
14105 cat >>confdefs.h <<\_ACEOF
14106 #define HAVE_COSHF 1
14107 _ACEOF
14108
14109 fi
14110
14111 echo "$as_me:$LINENO: checking for cosh in -lm" >&5
14112 echo $ECHO_N "checking for cosh in -lm... $ECHO_C" >&6
14113 if test "${ac_cv_lib_m_cosh+set}" = set; then
14114   echo $ECHO_N "(cached) $ECHO_C" >&6
14115 else
14116   ac_check_lib_save_LIBS=$LIBS
14117 LIBS="-lm  $LIBS"
14118 if test x$gcc_no_link = xyes; then
14119   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14120 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14121    { (exit 1); exit 1; }; }
14122 fi
14123 cat >conftest.$ac_ext <<_ACEOF
14124 /* confdefs.h.  */
14125 _ACEOF
14126 cat confdefs.h >>conftest.$ac_ext
14127 cat >>conftest.$ac_ext <<_ACEOF
14128 /* end confdefs.h.  */
14129
14130 /* Override any gcc2 internal prototype to avoid an error.  */
14131 #ifdef __cplusplus
14132 extern "C"
14133 #endif
14134 /* We use char because int might match the return type of a gcc2
14135    builtin and then its argument prototype would still apply.  */
14136 char cosh ();
14137 int
14138 main ()
14139 {
14140 cosh ();
14141   ;
14142   return 0;
14143 }
14144 _ACEOF
14145 rm -f conftest.$ac_objext conftest$ac_exeext
14146 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14147   (eval $ac_link) 2>conftest.er1
14148   ac_status=$?
14149   grep -v '^ *+' conftest.er1 >conftest.err
14150   rm -f conftest.er1
14151   cat conftest.err >&5
14152   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14153   (exit $ac_status); } &&
14154          { ac_try='test -z "$ac_c_werror_flag"
14155                          || test ! -s conftest.err'
14156   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14157   (eval $ac_try) 2>&5
14158   ac_status=$?
14159   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14160   (exit $ac_status); }; } &&
14161          { ac_try='test -s conftest$ac_exeext'
14162   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14163   (eval $ac_try) 2>&5
14164   ac_status=$?
14165   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14166   (exit $ac_status); }; }; then
14167   ac_cv_lib_m_cosh=yes
14168 else
14169   echo "$as_me: failed program was:" >&5
14170 sed 's/^/| /' conftest.$ac_ext >&5
14171
14172 ac_cv_lib_m_cosh=no
14173 fi
14174 rm -f conftest.err conftest.$ac_objext \
14175       conftest$ac_exeext conftest.$ac_ext
14176 LIBS=$ac_check_lib_save_LIBS
14177 fi
14178 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosh" >&5
14179 echo "${ECHO_T}$ac_cv_lib_m_cosh" >&6
14180 if test $ac_cv_lib_m_cosh = yes; then
14181
14182 cat >>confdefs.h <<\_ACEOF
14183 #define HAVE_COSH 1
14184 _ACEOF
14185
14186 fi
14187
14188 echo "$as_me:$LINENO: checking for coshl in -lm" >&5
14189 echo $ECHO_N "checking for coshl in -lm... $ECHO_C" >&6
14190 if test "${ac_cv_lib_m_coshl+set}" = set; then
14191   echo $ECHO_N "(cached) $ECHO_C" >&6
14192 else
14193   ac_check_lib_save_LIBS=$LIBS
14194 LIBS="-lm  $LIBS"
14195 if test x$gcc_no_link = xyes; then
14196   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14197 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14198    { (exit 1); exit 1; }; }
14199 fi
14200 cat >conftest.$ac_ext <<_ACEOF
14201 /* confdefs.h.  */
14202 _ACEOF
14203 cat confdefs.h >>conftest.$ac_ext
14204 cat >>conftest.$ac_ext <<_ACEOF
14205 /* end confdefs.h.  */
14206
14207 /* Override any gcc2 internal prototype to avoid an error.  */
14208 #ifdef __cplusplus
14209 extern "C"
14210 #endif
14211 /* We use char because int might match the return type of a gcc2
14212    builtin and then its argument prototype would still apply.  */
14213 char coshl ();
14214 int
14215 main ()
14216 {
14217 coshl ();
14218   ;
14219   return 0;
14220 }
14221 _ACEOF
14222 rm -f conftest.$ac_objext conftest$ac_exeext
14223 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14224   (eval $ac_link) 2>conftest.er1
14225   ac_status=$?
14226   grep -v '^ *+' conftest.er1 >conftest.err
14227   rm -f conftest.er1
14228   cat conftest.err >&5
14229   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14230   (exit $ac_status); } &&
14231          { ac_try='test -z "$ac_c_werror_flag"
14232                          || test ! -s conftest.err'
14233   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14234   (eval $ac_try) 2>&5
14235   ac_status=$?
14236   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14237   (exit $ac_status); }; } &&
14238          { ac_try='test -s conftest$ac_exeext'
14239   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14240   (eval $ac_try) 2>&5
14241   ac_status=$?
14242   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14243   (exit $ac_status); }; }; then
14244   ac_cv_lib_m_coshl=yes
14245 else
14246   echo "$as_me: failed program was:" >&5
14247 sed 's/^/| /' conftest.$ac_ext >&5
14248
14249 ac_cv_lib_m_coshl=no
14250 fi
14251 rm -f conftest.err conftest.$ac_objext \
14252       conftest$ac_exeext conftest.$ac_ext
14253 LIBS=$ac_check_lib_save_LIBS
14254 fi
14255 echo "$as_me:$LINENO: result: $ac_cv_lib_m_coshl" >&5
14256 echo "${ECHO_T}$ac_cv_lib_m_coshl" >&6
14257 if test $ac_cv_lib_m_coshl = yes; then
14258
14259 cat >>confdefs.h <<\_ACEOF
14260 #define HAVE_COSHL 1
14261 _ACEOF
14262
14263 fi
14264
14265 echo "$as_me:$LINENO: checking for ccoshf in -lm" >&5
14266 echo $ECHO_N "checking for ccoshf in -lm... $ECHO_C" >&6
14267 if test "${ac_cv_lib_m_ccoshf+set}" = set; then
14268   echo $ECHO_N "(cached) $ECHO_C" >&6
14269 else
14270   ac_check_lib_save_LIBS=$LIBS
14271 LIBS="-lm  $LIBS"
14272 if test x$gcc_no_link = xyes; then
14273   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14274 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14275    { (exit 1); exit 1; }; }
14276 fi
14277 cat >conftest.$ac_ext <<_ACEOF
14278 /* confdefs.h.  */
14279 _ACEOF
14280 cat confdefs.h >>conftest.$ac_ext
14281 cat >>conftest.$ac_ext <<_ACEOF
14282 /* end confdefs.h.  */
14283
14284 /* Override any gcc2 internal prototype to avoid an error.  */
14285 #ifdef __cplusplus
14286 extern "C"
14287 #endif
14288 /* We use char because int might match the return type of a gcc2
14289    builtin and then its argument prototype would still apply.  */
14290 char ccoshf ();
14291 int
14292 main ()
14293 {
14294 ccoshf ();
14295   ;
14296   return 0;
14297 }
14298 _ACEOF
14299 rm -f conftest.$ac_objext conftest$ac_exeext
14300 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14301   (eval $ac_link) 2>conftest.er1
14302   ac_status=$?
14303   grep -v '^ *+' conftest.er1 >conftest.err
14304   rm -f conftest.er1
14305   cat conftest.err >&5
14306   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14307   (exit $ac_status); } &&
14308          { ac_try='test -z "$ac_c_werror_flag"
14309                          || test ! -s conftest.err'
14310   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14311   (eval $ac_try) 2>&5
14312   ac_status=$?
14313   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14314   (exit $ac_status); }; } &&
14315          { ac_try='test -s conftest$ac_exeext'
14316   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14317   (eval $ac_try) 2>&5
14318   ac_status=$?
14319   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14320   (exit $ac_status); }; }; then
14321   ac_cv_lib_m_ccoshf=yes
14322 else
14323   echo "$as_me: failed program was:" >&5
14324 sed 's/^/| /' conftest.$ac_ext >&5
14325
14326 ac_cv_lib_m_ccoshf=no
14327 fi
14328 rm -f conftest.err conftest.$ac_objext \
14329       conftest$ac_exeext conftest.$ac_ext
14330 LIBS=$ac_check_lib_save_LIBS
14331 fi
14332 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccoshf" >&5
14333 echo "${ECHO_T}$ac_cv_lib_m_ccoshf" >&6
14334 if test $ac_cv_lib_m_ccoshf = yes; then
14335
14336 cat >>confdefs.h <<\_ACEOF
14337 #define HAVE_CCOSHF 1
14338 _ACEOF
14339
14340 fi
14341
14342 echo "$as_me:$LINENO: checking for ccosh in -lm" >&5
14343 echo $ECHO_N "checking for ccosh in -lm... $ECHO_C" >&6
14344 if test "${ac_cv_lib_m_ccosh+set}" = set; then
14345   echo $ECHO_N "(cached) $ECHO_C" >&6
14346 else
14347   ac_check_lib_save_LIBS=$LIBS
14348 LIBS="-lm  $LIBS"
14349 if test x$gcc_no_link = xyes; then
14350   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14351 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14352    { (exit 1); exit 1; }; }
14353 fi
14354 cat >conftest.$ac_ext <<_ACEOF
14355 /* confdefs.h.  */
14356 _ACEOF
14357 cat confdefs.h >>conftest.$ac_ext
14358 cat >>conftest.$ac_ext <<_ACEOF
14359 /* end confdefs.h.  */
14360
14361 /* Override any gcc2 internal prototype to avoid an error.  */
14362 #ifdef __cplusplus
14363 extern "C"
14364 #endif
14365 /* We use char because int might match the return type of a gcc2
14366    builtin and then its argument prototype would still apply.  */
14367 char ccosh ();
14368 int
14369 main ()
14370 {
14371 ccosh ();
14372   ;
14373   return 0;
14374 }
14375 _ACEOF
14376 rm -f conftest.$ac_objext conftest$ac_exeext
14377 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14378   (eval $ac_link) 2>conftest.er1
14379   ac_status=$?
14380   grep -v '^ *+' conftest.er1 >conftest.err
14381   rm -f conftest.er1
14382   cat conftest.err >&5
14383   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14384   (exit $ac_status); } &&
14385          { ac_try='test -z "$ac_c_werror_flag"
14386                          || test ! -s conftest.err'
14387   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14388   (eval $ac_try) 2>&5
14389   ac_status=$?
14390   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14391   (exit $ac_status); }; } &&
14392          { ac_try='test -s conftest$ac_exeext'
14393   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14394   (eval $ac_try) 2>&5
14395   ac_status=$?
14396   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14397   (exit $ac_status); }; }; then
14398   ac_cv_lib_m_ccosh=yes
14399 else
14400   echo "$as_me: failed program was:" >&5
14401 sed 's/^/| /' conftest.$ac_ext >&5
14402
14403 ac_cv_lib_m_ccosh=no
14404 fi
14405 rm -f conftest.err conftest.$ac_objext \
14406       conftest$ac_exeext conftest.$ac_ext
14407 LIBS=$ac_check_lib_save_LIBS
14408 fi
14409 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosh" >&5
14410 echo "${ECHO_T}$ac_cv_lib_m_ccosh" >&6
14411 if test $ac_cv_lib_m_ccosh = yes; then
14412
14413 cat >>confdefs.h <<\_ACEOF
14414 #define HAVE_CCOSH 1
14415 _ACEOF
14416
14417 fi
14418
14419 echo "$as_me:$LINENO: checking for ccoshl in -lm" >&5
14420 echo $ECHO_N "checking for ccoshl in -lm... $ECHO_C" >&6
14421 if test "${ac_cv_lib_m_ccoshl+set}" = set; then
14422   echo $ECHO_N "(cached) $ECHO_C" >&6
14423 else
14424   ac_check_lib_save_LIBS=$LIBS
14425 LIBS="-lm  $LIBS"
14426 if test x$gcc_no_link = xyes; then
14427   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14428 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14429    { (exit 1); exit 1; }; }
14430 fi
14431 cat >conftest.$ac_ext <<_ACEOF
14432 /* confdefs.h.  */
14433 _ACEOF
14434 cat confdefs.h >>conftest.$ac_ext
14435 cat >>conftest.$ac_ext <<_ACEOF
14436 /* end confdefs.h.  */
14437
14438 /* Override any gcc2 internal prototype to avoid an error.  */
14439 #ifdef __cplusplus
14440 extern "C"
14441 #endif
14442 /* We use char because int might match the return type of a gcc2
14443    builtin and then its argument prototype would still apply.  */
14444 char ccoshl ();
14445 int
14446 main ()
14447 {
14448 ccoshl ();
14449   ;
14450   return 0;
14451 }
14452 _ACEOF
14453 rm -f conftest.$ac_objext conftest$ac_exeext
14454 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14455   (eval $ac_link) 2>conftest.er1
14456   ac_status=$?
14457   grep -v '^ *+' conftest.er1 >conftest.err
14458   rm -f conftest.er1
14459   cat conftest.err >&5
14460   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14461   (exit $ac_status); } &&
14462          { ac_try='test -z "$ac_c_werror_flag"
14463                          || test ! -s conftest.err'
14464   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14465   (eval $ac_try) 2>&5
14466   ac_status=$?
14467   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14468   (exit $ac_status); }; } &&
14469          { ac_try='test -s conftest$ac_exeext'
14470   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14471   (eval $ac_try) 2>&5
14472   ac_status=$?
14473   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14474   (exit $ac_status); }; }; then
14475   ac_cv_lib_m_ccoshl=yes
14476 else
14477   echo "$as_me: failed program was:" >&5
14478 sed 's/^/| /' conftest.$ac_ext >&5
14479
14480 ac_cv_lib_m_ccoshl=no
14481 fi
14482 rm -f conftest.err conftest.$ac_objext \
14483       conftest$ac_exeext conftest.$ac_ext
14484 LIBS=$ac_check_lib_save_LIBS
14485 fi
14486 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccoshl" >&5
14487 echo "${ECHO_T}$ac_cv_lib_m_ccoshl" >&6
14488 if test $ac_cv_lib_m_ccoshl = yes; then
14489
14490 cat >>confdefs.h <<\_ACEOF
14491 #define HAVE_CCOSHL 1
14492 _ACEOF
14493
14494 fi
14495
14496 echo "$as_me:$LINENO: checking for expf in -lm" >&5
14497 echo $ECHO_N "checking for expf in -lm... $ECHO_C" >&6
14498 if test "${ac_cv_lib_m_expf+set}" = set; then
14499   echo $ECHO_N "(cached) $ECHO_C" >&6
14500 else
14501   ac_check_lib_save_LIBS=$LIBS
14502 LIBS="-lm  $LIBS"
14503 if test x$gcc_no_link = xyes; then
14504   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14505 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14506    { (exit 1); exit 1; }; }
14507 fi
14508 cat >conftest.$ac_ext <<_ACEOF
14509 /* confdefs.h.  */
14510 _ACEOF
14511 cat confdefs.h >>conftest.$ac_ext
14512 cat >>conftest.$ac_ext <<_ACEOF
14513 /* end confdefs.h.  */
14514
14515 /* Override any gcc2 internal prototype to avoid an error.  */
14516 #ifdef __cplusplus
14517 extern "C"
14518 #endif
14519 /* We use char because int might match the return type of a gcc2
14520    builtin and then its argument prototype would still apply.  */
14521 char expf ();
14522 int
14523 main ()
14524 {
14525 expf ();
14526   ;
14527   return 0;
14528 }
14529 _ACEOF
14530 rm -f conftest.$ac_objext conftest$ac_exeext
14531 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14532   (eval $ac_link) 2>conftest.er1
14533   ac_status=$?
14534   grep -v '^ *+' conftest.er1 >conftest.err
14535   rm -f conftest.er1
14536   cat conftest.err >&5
14537   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14538   (exit $ac_status); } &&
14539          { ac_try='test -z "$ac_c_werror_flag"
14540                          || test ! -s conftest.err'
14541   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14542   (eval $ac_try) 2>&5
14543   ac_status=$?
14544   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14545   (exit $ac_status); }; } &&
14546          { ac_try='test -s conftest$ac_exeext'
14547   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14548   (eval $ac_try) 2>&5
14549   ac_status=$?
14550   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14551   (exit $ac_status); }; }; then
14552   ac_cv_lib_m_expf=yes
14553 else
14554   echo "$as_me: failed program was:" >&5
14555 sed 's/^/| /' conftest.$ac_ext >&5
14556
14557 ac_cv_lib_m_expf=no
14558 fi
14559 rm -f conftest.err conftest.$ac_objext \
14560       conftest$ac_exeext conftest.$ac_ext
14561 LIBS=$ac_check_lib_save_LIBS
14562 fi
14563 echo "$as_me:$LINENO: result: $ac_cv_lib_m_expf" >&5
14564 echo "${ECHO_T}$ac_cv_lib_m_expf" >&6
14565 if test $ac_cv_lib_m_expf = yes; then
14566
14567 cat >>confdefs.h <<\_ACEOF
14568 #define HAVE_EXPF 1
14569 _ACEOF
14570
14571 fi
14572
14573 echo "$as_me:$LINENO: checking for exp in -lm" >&5
14574 echo $ECHO_N "checking for exp in -lm... $ECHO_C" >&6
14575 if test "${ac_cv_lib_m_exp+set}" = set; then
14576   echo $ECHO_N "(cached) $ECHO_C" >&6
14577 else
14578   ac_check_lib_save_LIBS=$LIBS
14579 LIBS="-lm  $LIBS"
14580 if test x$gcc_no_link = xyes; then
14581   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14582 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14583    { (exit 1); exit 1; }; }
14584 fi
14585 cat >conftest.$ac_ext <<_ACEOF
14586 /* confdefs.h.  */
14587 _ACEOF
14588 cat confdefs.h >>conftest.$ac_ext
14589 cat >>conftest.$ac_ext <<_ACEOF
14590 /* end confdefs.h.  */
14591
14592 /* Override any gcc2 internal prototype to avoid an error.  */
14593 #ifdef __cplusplus
14594 extern "C"
14595 #endif
14596 /* We use char because int might match the return type of a gcc2
14597    builtin and then its argument prototype would still apply.  */
14598 char exp ();
14599 int
14600 main ()
14601 {
14602 exp ();
14603   ;
14604   return 0;
14605 }
14606 _ACEOF
14607 rm -f conftest.$ac_objext conftest$ac_exeext
14608 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14609   (eval $ac_link) 2>conftest.er1
14610   ac_status=$?
14611   grep -v '^ *+' conftest.er1 >conftest.err
14612   rm -f conftest.er1
14613   cat conftest.err >&5
14614   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14615   (exit $ac_status); } &&
14616          { ac_try='test -z "$ac_c_werror_flag"
14617                          || test ! -s conftest.err'
14618   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14619   (eval $ac_try) 2>&5
14620   ac_status=$?
14621   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14622   (exit $ac_status); }; } &&
14623          { ac_try='test -s conftest$ac_exeext'
14624   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14625   (eval $ac_try) 2>&5
14626   ac_status=$?
14627   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14628   (exit $ac_status); }; }; then
14629   ac_cv_lib_m_exp=yes
14630 else
14631   echo "$as_me: failed program was:" >&5
14632 sed 's/^/| /' conftest.$ac_ext >&5
14633
14634 ac_cv_lib_m_exp=no
14635 fi
14636 rm -f conftest.err conftest.$ac_objext \
14637       conftest$ac_exeext conftest.$ac_ext
14638 LIBS=$ac_check_lib_save_LIBS
14639 fi
14640 echo "$as_me:$LINENO: result: $ac_cv_lib_m_exp" >&5
14641 echo "${ECHO_T}$ac_cv_lib_m_exp" >&6
14642 if test $ac_cv_lib_m_exp = yes; then
14643
14644 cat >>confdefs.h <<\_ACEOF
14645 #define HAVE_EXP 1
14646 _ACEOF
14647
14648 fi
14649
14650 echo "$as_me:$LINENO: checking for expl in -lm" >&5
14651 echo $ECHO_N "checking for expl in -lm... $ECHO_C" >&6
14652 if test "${ac_cv_lib_m_expl+set}" = set; then
14653   echo $ECHO_N "(cached) $ECHO_C" >&6
14654 else
14655   ac_check_lib_save_LIBS=$LIBS
14656 LIBS="-lm  $LIBS"
14657 if test x$gcc_no_link = xyes; then
14658   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14659 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14660    { (exit 1); exit 1; }; }
14661 fi
14662 cat >conftest.$ac_ext <<_ACEOF
14663 /* confdefs.h.  */
14664 _ACEOF
14665 cat confdefs.h >>conftest.$ac_ext
14666 cat >>conftest.$ac_ext <<_ACEOF
14667 /* end confdefs.h.  */
14668
14669 /* Override any gcc2 internal prototype to avoid an error.  */
14670 #ifdef __cplusplus
14671 extern "C"
14672 #endif
14673 /* We use char because int might match the return type of a gcc2
14674    builtin and then its argument prototype would still apply.  */
14675 char expl ();
14676 int
14677 main ()
14678 {
14679 expl ();
14680   ;
14681   return 0;
14682 }
14683 _ACEOF
14684 rm -f conftest.$ac_objext conftest$ac_exeext
14685 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14686   (eval $ac_link) 2>conftest.er1
14687   ac_status=$?
14688   grep -v '^ *+' conftest.er1 >conftest.err
14689   rm -f conftest.er1
14690   cat conftest.err >&5
14691   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14692   (exit $ac_status); } &&
14693          { ac_try='test -z "$ac_c_werror_flag"
14694                          || test ! -s conftest.err'
14695   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14696   (eval $ac_try) 2>&5
14697   ac_status=$?
14698   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14699   (exit $ac_status); }; } &&
14700          { ac_try='test -s conftest$ac_exeext'
14701   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14702   (eval $ac_try) 2>&5
14703   ac_status=$?
14704   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14705   (exit $ac_status); }; }; then
14706   ac_cv_lib_m_expl=yes
14707 else
14708   echo "$as_me: failed program was:" >&5
14709 sed 's/^/| /' conftest.$ac_ext >&5
14710
14711 ac_cv_lib_m_expl=no
14712 fi
14713 rm -f conftest.err conftest.$ac_objext \
14714       conftest$ac_exeext conftest.$ac_ext
14715 LIBS=$ac_check_lib_save_LIBS
14716 fi
14717 echo "$as_me:$LINENO: result: $ac_cv_lib_m_expl" >&5
14718 echo "${ECHO_T}$ac_cv_lib_m_expl" >&6
14719 if test $ac_cv_lib_m_expl = yes; then
14720
14721 cat >>confdefs.h <<\_ACEOF
14722 #define HAVE_EXPL 1
14723 _ACEOF
14724
14725 fi
14726
14727 echo "$as_me:$LINENO: checking for cexpf in -lm" >&5
14728 echo $ECHO_N "checking for cexpf in -lm... $ECHO_C" >&6
14729 if test "${ac_cv_lib_m_cexpf+set}" = set; then
14730   echo $ECHO_N "(cached) $ECHO_C" >&6
14731 else
14732   ac_check_lib_save_LIBS=$LIBS
14733 LIBS="-lm  $LIBS"
14734 if test x$gcc_no_link = xyes; then
14735   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14736 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14737    { (exit 1); exit 1; }; }
14738 fi
14739 cat >conftest.$ac_ext <<_ACEOF
14740 /* confdefs.h.  */
14741 _ACEOF
14742 cat confdefs.h >>conftest.$ac_ext
14743 cat >>conftest.$ac_ext <<_ACEOF
14744 /* end confdefs.h.  */
14745
14746 /* Override any gcc2 internal prototype to avoid an error.  */
14747 #ifdef __cplusplus
14748 extern "C"
14749 #endif
14750 /* We use char because int might match the return type of a gcc2
14751    builtin and then its argument prototype would still apply.  */
14752 char cexpf ();
14753 int
14754 main ()
14755 {
14756 cexpf ();
14757   ;
14758   return 0;
14759 }
14760 _ACEOF
14761 rm -f conftest.$ac_objext conftest$ac_exeext
14762 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14763   (eval $ac_link) 2>conftest.er1
14764   ac_status=$?
14765   grep -v '^ *+' conftest.er1 >conftest.err
14766   rm -f conftest.er1
14767   cat conftest.err >&5
14768   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14769   (exit $ac_status); } &&
14770          { ac_try='test -z "$ac_c_werror_flag"
14771                          || test ! -s conftest.err'
14772   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14773   (eval $ac_try) 2>&5
14774   ac_status=$?
14775   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14776   (exit $ac_status); }; } &&
14777          { ac_try='test -s conftest$ac_exeext'
14778   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14779   (eval $ac_try) 2>&5
14780   ac_status=$?
14781   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14782   (exit $ac_status); }; }; then
14783   ac_cv_lib_m_cexpf=yes
14784 else
14785   echo "$as_me: failed program was:" >&5
14786 sed 's/^/| /' conftest.$ac_ext >&5
14787
14788 ac_cv_lib_m_cexpf=no
14789 fi
14790 rm -f conftest.err conftest.$ac_objext \
14791       conftest$ac_exeext conftest.$ac_ext
14792 LIBS=$ac_check_lib_save_LIBS
14793 fi
14794 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexpf" >&5
14795 echo "${ECHO_T}$ac_cv_lib_m_cexpf" >&6
14796 if test $ac_cv_lib_m_cexpf = yes; then
14797
14798 cat >>confdefs.h <<\_ACEOF
14799 #define HAVE_CEXPF 1
14800 _ACEOF
14801
14802 fi
14803
14804 echo "$as_me:$LINENO: checking for cexp in -lm" >&5
14805 echo $ECHO_N "checking for cexp in -lm... $ECHO_C" >&6
14806 if test "${ac_cv_lib_m_cexp+set}" = set; then
14807   echo $ECHO_N "(cached) $ECHO_C" >&6
14808 else
14809   ac_check_lib_save_LIBS=$LIBS
14810 LIBS="-lm  $LIBS"
14811 if test x$gcc_no_link = xyes; then
14812   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14813 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14814    { (exit 1); exit 1; }; }
14815 fi
14816 cat >conftest.$ac_ext <<_ACEOF
14817 /* confdefs.h.  */
14818 _ACEOF
14819 cat confdefs.h >>conftest.$ac_ext
14820 cat >>conftest.$ac_ext <<_ACEOF
14821 /* end confdefs.h.  */
14822
14823 /* Override any gcc2 internal prototype to avoid an error.  */
14824 #ifdef __cplusplus
14825 extern "C"
14826 #endif
14827 /* We use char because int might match the return type of a gcc2
14828    builtin and then its argument prototype would still apply.  */
14829 char cexp ();
14830 int
14831 main ()
14832 {
14833 cexp ();
14834   ;
14835   return 0;
14836 }
14837 _ACEOF
14838 rm -f conftest.$ac_objext conftest$ac_exeext
14839 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14840   (eval $ac_link) 2>conftest.er1
14841   ac_status=$?
14842   grep -v '^ *+' conftest.er1 >conftest.err
14843   rm -f conftest.er1
14844   cat conftest.err >&5
14845   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14846   (exit $ac_status); } &&
14847          { ac_try='test -z "$ac_c_werror_flag"
14848                          || test ! -s conftest.err'
14849   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14850   (eval $ac_try) 2>&5
14851   ac_status=$?
14852   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14853   (exit $ac_status); }; } &&
14854          { ac_try='test -s conftest$ac_exeext'
14855   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14856   (eval $ac_try) 2>&5
14857   ac_status=$?
14858   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14859   (exit $ac_status); }; }; then
14860   ac_cv_lib_m_cexp=yes
14861 else
14862   echo "$as_me: failed program was:" >&5
14863 sed 's/^/| /' conftest.$ac_ext >&5
14864
14865 ac_cv_lib_m_cexp=no
14866 fi
14867 rm -f conftest.err conftest.$ac_objext \
14868       conftest$ac_exeext conftest.$ac_ext
14869 LIBS=$ac_check_lib_save_LIBS
14870 fi
14871 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexp" >&5
14872 echo "${ECHO_T}$ac_cv_lib_m_cexp" >&6
14873 if test $ac_cv_lib_m_cexp = yes; then
14874
14875 cat >>confdefs.h <<\_ACEOF
14876 #define HAVE_CEXP 1
14877 _ACEOF
14878
14879 fi
14880
14881 echo "$as_me:$LINENO: checking for cexpl in -lm" >&5
14882 echo $ECHO_N "checking for cexpl in -lm... $ECHO_C" >&6
14883 if test "${ac_cv_lib_m_cexpl+set}" = set; then
14884   echo $ECHO_N "(cached) $ECHO_C" >&6
14885 else
14886   ac_check_lib_save_LIBS=$LIBS
14887 LIBS="-lm  $LIBS"
14888 if test x$gcc_no_link = xyes; then
14889   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14890 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14891    { (exit 1); exit 1; }; }
14892 fi
14893 cat >conftest.$ac_ext <<_ACEOF
14894 /* confdefs.h.  */
14895 _ACEOF
14896 cat confdefs.h >>conftest.$ac_ext
14897 cat >>conftest.$ac_ext <<_ACEOF
14898 /* end confdefs.h.  */
14899
14900 /* Override any gcc2 internal prototype to avoid an error.  */
14901 #ifdef __cplusplus
14902 extern "C"
14903 #endif
14904 /* We use char because int might match the return type of a gcc2
14905    builtin and then its argument prototype would still apply.  */
14906 char cexpl ();
14907 int
14908 main ()
14909 {
14910 cexpl ();
14911   ;
14912   return 0;
14913 }
14914 _ACEOF
14915 rm -f conftest.$ac_objext conftest$ac_exeext
14916 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14917   (eval $ac_link) 2>conftest.er1
14918   ac_status=$?
14919   grep -v '^ *+' conftest.er1 >conftest.err
14920   rm -f conftest.er1
14921   cat conftest.err >&5
14922   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14923   (exit $ac_status); } &&
14924          { ac_try='test -z "$ac_c_werror_flag"
14925                          || test ! -s conftest.err'
14926   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14927   (eval $ac_try) 2>&5
14928   ac_status=$?
14929   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14930   (exit $ac_status); }; } &&
14931          { ac_try='test -s conftest$ac_exeext'
14932   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14933   (eval $ac_try) 2>&5
14934   ac_status=$?
14935   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14936   (exit $ac_status); }; }; then
14937   ac_cv_lib_m_cexpl=yes
14938 else
14939   echo "$as_me: failed program was:" >&5
14940 sed 's/^/| /' conftest.$ac_ext >&5
14941
14942 ac_cv_lib_m_cexpl=no
14943 fi
14944 rm -f conftest.err conftest.$ac_objext \
14945       conftest$ac_exeext conftest.$ac_ext
14946 LIBS=$ac_check_lib_save_LIBS
14947 fi
14948 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexpl" >&5
14949 echo "${ECHO_T}$ac_cv_lib_m_cexpl" >&6
14950 if test $ac_cv_lib_m_cexpl = yes; then
14951
14952 cat >>confdefs.h <<\_ACEOF
14953 #define HAVE_CEXPL 1
14954 _ACEOF
14955
14956 fi
14957
14958 echo "$as_me:$LINENO: checking for fabsf in -lm" >&5
14959 echo $ECHO_N "checking for fabsf in -lm... $ECHO_C" >&6
14960 if test "${ac_cv_lib_m_fabsf+set}" = set; then
14961   echo $ECHO_N "(cached) $ECHO_C" >&6
14962 else
14963   ac_check_lib_save_LIBS=$LIBS
14964 LIBS="-lm  $LIBS"
14965 if test x$gcc_no_link = xyes; then
14966   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14967 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14968    { (exit 1); exit 1; }; }
14969 fi
14970 cat >conftest.$ac_ext <<_ACEOF
14971 /* confdefs.h.  */
14972 _ACEOF
14973 cat confdefs.h >>conftest.$ac_ext
14974 cat >>conftest.$ac_ext <<_ACEOF
14975 /* end confdefs.h.  */
14976
14977 /* Override any gcc2 internal prototype to avoid an error.  */
14978 #ifdef __cplusplus
14979 extern "C"
14980 #endif
14981 /* We use char because int might match the return type of a gcc2
14982    builtin and then its argument prototype would still apply.  */
14983 char fabsf ();
14984 int
14985 main ()
14986 {
14987 fabsf ();
14988   ;
14989   return 0;
14990 }
14991 _ACEOF
14992 rm -f conftest.$ac_objext conftest$ac_exeext
14993 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14994   (eval $ac_link) 2>conftest.er1
14995   ac_status=$?
14996   grep -v '^ *+' conftest.er1 >conftest.err
14997   rm -f conftest.er1
14998   cat conftest.err >&5
14999   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15000   (exit $ac_status); } &&
15001          { ac_try='test -z "$ac_c_werror_flag"
15002                          || test ! -s conftest.err'
15003   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15004   (eval $ac_try) 2>&5
15005   ac_status=$?
15006   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15007   (exit $ac_status); }; } &&
15008          { ac_try='test -s conftest$ac_exeext'
15009   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15010   (eval $ac_try) 2>&5
15011   ac_status=$?
15012   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15013   (exit $ac_status); }; }; then
15014   ac_cv_lib_m_fabsf=yes
15015 else
15016   echo "$as_me: failed program was:" >&5
15017 sed 's/^/| /' conftest.$ac_ext >&5
15018
15019 ac_cv_lib_m_fabsf=no
15020 fi
15021 rm -f conftest.err conftest.$ac_objext \
15022       conftest$ac_exeext conftest.$ac_ext
15023 LIBS=$ac_check_lib_save_LIBS
15024 fi
15025 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabsf" >&5
15026 echo "${ECHO_T}$ac_cv_lib_m_fabsf" >&6
15027 if test $ac_cv_lib_m_fabsf = yes; then
15028
15029 cat >>confdefs.h <<\_ACEOF
15030 #define HAVE_FABSF 1
15031 _ACEOF
15032
15033 fi
15034
15035 echo "$as_me:$LINENO: checking for fabs in -lm" >&5
15036 echo $ECHO_N "checking for fabs in -lm... $ECHO_C" >&6
15037 if test "${ac_cv_lib_m_fabs+set}" = set; then
15038   echo $ECHO_N "(cached) $ECHO_C" >&6
15039 else
15040   ac_check_lib_save_LIBS=$LIBS
15041 LIBS="-lm  $LIBS"
15042 if test x$gcc_no_link = xyes; then
15043   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15044 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15045    { (exit 1); exit 1; }; }
15046 fi
15047 cat >conftest.$ac_ext <<_ACEOF
15048 /* confdefs.h.  */
15049 _ACEOF
15050 cat confdefs.h >>conftest.$ac_ext
15051 cat >>conftest.$ac_ext <<_ACEOF
15052 /* end confdefs.h.  */
15053
15054 /* Override any gcc2 internal prototype to avoid an error.  */
15055 #ifdef __cplusplus
15056 extern "C"
15057 #endif
15058 /* We use char because int might match the return type of a gcc2
15059    builtin and then its argument prototype would still apply.  */
15060 char fabs ();
15061 int
15062 main ()
15063 {
15064 fabs ();
15065   ;
15066   return 0;
15067 }
15068 _ACEOF
15069 rm -f conftest.$ac_objext conftest$ac_exeext
15070 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15071   (eval $ac_link) 2>conftest.er1
15072   ac_status=$?
15073   grep -v '^ *+' conftest.er1 >conftest.err
15074   rm -f conftest.er1
15075   cat conftest.err >&5
15076   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15077   (exit $ac_status); } &&
15078          { ac_try='test -z "$ac_c_werror_flag"
15079                          || test ! -s conftest.err'
15080   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15081   (eval $ac_try) 2>&5
15082   ac_status=$?
15083   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15084   (exit $ac_status); }; } &&
15085          { ac_try='test -s conftest$ac_exeext'
15086   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15087   (eval $ac_try) 2>&5
15088   ac_status=$?
15089   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15090   (exit $ac_status); }; }; then
15091   ac_cv_lib_m_fabs=yes
15092 else
15093   echo "$as_me: failed program was:" >&5
15094 sed 's/^/| /' conftest.$ac_ext >&5
15095
15096 ac_cv_lib_m_fabs=no
15097 fi
15098 rm -f conftest.err conftest.$ac_objext \
15099       conftest$ac_exeext conftest.$ac_ext
15100 LIBS=$ac_check_lib_save_LIBS
15101 fi
15102 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabs" >&5
15103 echo "${ECHO_T}$ac_cv_lib_m_fabs" >&6
15104 if test $ac_cv_lib_m_fabs = yes; then
15105
15106 cat >>confdefs.h <<\_ACEOF
15107 #define HAVE_FABS 1
15108 _ACEOF
15109
15110 fi
15111
15112 echo "$as_me:$LINENO: checking for fabsl in -lm" >&5
15113 echo $ECHO_N "checking for fabsl in -lm... $ECHO_C" >&6
15114 if test "${ac_cv_lib_m_fabsl+set}" = set; then
15115   echo $ECHO_N "(cached) $ECHO_C" >&6
15116 else
15117   ac_check_lib_save_LIBS=$LIBS
15118 LIBS="-lm  $LIBS"
15119 if test x$gcc_no_link = xyes; then
15120   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15121 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15122    { (exit 1); exit 1; }; }
15123 fi
15124 cat >conftest.$ac_ext <<_ACEOF
15125 /* confdefs.h.  */
15126 _ACEOF
15127 cat confdefs.h >>conftest.$ac_ext
15128 cat >>conftest.$ac_ext <<_ACEOF
15129 /* end confdefs.h.  */
15130
15131 /* Override any gcc2 internal prototype to avoid an error.  */
15132 #ifdef __cplusplus
15133 extern "C"
15134 #endif
15135 /* We use char because int might match the return type of a gcc2
15136    builtin and then its argument prototype would still apply.  */
15137 char fabsl ();
15138 int
15139 main ()
15140 {
15141 fabsl ();
15142   ;
15143   return 0;
15144 }
15145 _ACEOF
15146 rm -f conftest.$ac_objext conftest$ac_exeext
15147 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15148   (eval $ac_link) 2>conftest.er1
15149   ac_status=$?
15150   grep -v '^ *+' conftest.er1 >conftest.err
15151   rm -f conftest.er1
15152   cat conftest.err >&5
15153   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15154   (exit $ac_status); } &&
15155          { ac_try='test -z "$ac_c_werror_flag"
15156                          || test ! -s conftest.err'
15157   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15158   (eval $ac_try) 2>&5
15159   ac_status=$?
15160   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15161   (exit $ac_status); }; } &&
15162          { ac_try='test -s conftest$ac_exeext'
15163   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15164   (eval $ac_try) 2>&5
15165   ac_status=$?
15166   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15167   (exit $ac_status); }; }; then
15168   ac_cv_lib_m_fabsl=yes
15169 else
15170   echo "$as_me: failed program was:" >&5
15171 sed 's/^/| /' conftest.$ac_ext >&5
15172
15173 ac_cv_lib_m_fabsl=no
15174 fi
15175 rm -f conftest.err conftest.$ac_objext \
15176       conftest$ac_exeext conftest.$ac_ext
15177 LIBS=$ac_check_lib_save_LIBS
15178 fi
15179 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabsl" >&5
15180 echo "${ECHO_T}$ac_cv_lib_m_fabsl" >&6
15181 if test $ac_cv_lib_m_fabsl = yes; then
15182
15183 cat >>confdefs.h <<\_ACEOF
15184 #define HAVE_FABSL 1
15185 _ACEOF
15186
15187 fi
15188
15189 echo "$as_me:$LINENO: checking for cabsf in -lm" >&5
15190 echo $ECHO_N "checking for cabsf in -lm... $ECHO_C" >&6
15191 if test "${ac_cv_lib_m_cabsf+set}" = set; then
15192   echo $ECHO_N "(cached) $ECHO_C" >&6
15193 else
15194   ac_check_lib_save_LIBS=$LIBS
15195 LIBS="-lm  $LIBS"
15196 if test x$gcc_no_link = xyes; then
15197   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15198 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15199    { (exit 1); exit 1; }; }
15200 fi
15201 cat >conftest.$ac_ext <<_ACEOF
15202 /* confdefs.h.  */
15203 _ACEOF
15204 cat confdefs.h >>conftest.$ac_ext
15205 cat >>conftest.$ac_ext <<_ACEOF
15206 /* end confdefs.h.  */
15207
15208 /* Override any gcc2 internal prototype to avoid an error.  */
15209 #ifdef __cplusplus
15210 extern "C"
15211 #endif
15212 /* We use char because int might match the return type of a gcc2
15213    builtin and then its argument prototype would still apply.  */
15214 char cabsf ();
15215 int
15216 main ()
15217 {
15218 cabsf ();
15219   ;
15220   return 0;
15221 }
15222 _ACEOF
15223 rm -f conftest.$ac_objext conftest$ac_exeext
15224 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15225   (eval $ac_link) 2>conftest.er1
15226   ac_status=$?
15227   grep -v '^ *+' conftest.er1 >conftest.err
15228   rm -f conftest.er1
15229   cat conftest.err >&5
15230   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15231   (exit $ac_status); } &&
15232          { ac_try='test -z "$ac_c_werror_flag"
15233                          || test ! -s conftest.err'
15234   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15235   (eval $ac_try) 2>&5
15236   ac_status=$?
15237   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15238   (exit $ac_status); }; } &&
15239          { ac_try='test -s conftest$ac_exeext'
15240   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15241   (eval $ac_try) 2>&5
15242   ac_status=$?
15243   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15244   (exit $ac_status); }; }; then
15245   ac_cv_lib_m_cabsf=yes
15246 else
15247   echo "$as_me: failed program was:" >&5
15248 sed 's/^/| /' conftest.$ac_ext >&5
15249
15250 ac_cv_lib_m_cabsf=no
15251 fi
15252 rm -f conftest.err conftest.$ac_objext \
15253       conftest$ac_exeext conftest.$ac_ext
15254 LIBS=$ac_check_lib_save_LIBS
15255 fi
15256 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabsf" >&5
15257 echo "${ECHO_T}$ac_cv_lib_m_cabsf" >&6
15258 if test $ac_cv_lib_m_cabsf = yes; then
15259
15260 cat >>confdefs.h <<\_ACEOF
15261 #define HAVE_CABSF 1
15262 _ACEOF
15263
15264 fi
15265
15266 echo "$as_me:$LINENO: checking for cabs in -lm" >&5
15267 echo $ECHO_N "checking for cabs in -lm... $ECHO_C" >&6
15268 if test "${ac_cv_lib_m_cabs+set}" = set; then
15269   echo $ECHO_N "(cached) $ECHO_C" >&6
15270 else
15271   ac_check_lib_save_LIBS=$LIBS
15272 LIBS="-lm  $LIBS"
15273 if test x$gcc_no_link = xyes; then
15274   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15275 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15276    { (exit 1); exit 1; }; }
15277 fi
15278 cat >conftest.$ac_ext <<_ACEOF
15279 /* confdefs.h.  */
15280 _ACEOF
15281 cat confdefs.h >>conftest.$ac_ext
15282 cat >>conftest.$ac_ext <<_ACEOF
15283 /* end confdefs.h.  */
15284
15285 /* Override any gcc2 internal prototype to avoid an error.  */
15286 #ifdef __cplusplus
15287 extern "C"
15288 #endif
15289 /* We use char because int might match the return type of a gcc2
15290    builtin and then its argument prototype would still apply.  */
15291 char cabs ();
15292 int
15293 main ()
15294 {
15295 cabs ();
15296   ;
15297   return 0;
15298 }
15299 _ACEOF
15300 rm -f conftest.$ac_objext conftest$ac_exeext
15301 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15302   (eval $ac_link) 2>conftest.er1
15303   ac_status=$?
15304   grep -v '^ *+' conftest.er1 >conftest.err
15305   rm -f conftest.er1
15306   cat conftest.err >&5
15307   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15308   (exit $ac_status); } &&
15309          { ac_try='test -z "$ac_c_werror_flag"
15310                          || test ! -s conftest.err'
15311   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15312   (eval $ac_try) 2>&5
15313   ac_status=$?
15314   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15315   (exit $ac_status); }; } &&
15316          { ac_try='test -s conftest$ac_exeext'
15317   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15318   (eval $ac_try) 2>&5
15319   ac_status=$?
15320   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15321   (exit $ac_status); }; }; then
15322   ac_cv_lib_m_cabs=yes
15323 else
15324   echo "$as_me: failed program was:" >&5
15325 sed 's/^/| /' conftest.$ac_ext >&5
15326
15327 ac_cv_lib_m_cabs=no
15328 fi
15329 rm -f conftest.err conftest.$ac_objext \
15330       conftest$ac_exeext conftest.$ac_ext
15331 LIBS=$ac_check_lib_save_LIBS
15332 fi
15333 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabs" >&5
15334 echo "${ECHO_T}$ac_cv_lib_m_cabs" >&6
15335 if test $ac_cv_lib_m_cabs = yes; then
15336
15337 cat >>confdefs.h <<\_ACEOF
15338 #define HAVE_CABS 1
15339 _ACEOF
15340
15341 fi
15342
15343 echo "$as_me:$LINENO: checking for cabsl in -lm" >&5
15344 echo $ECHO_N "checking for cabsl in -lm... $ECHO_C" >&6
15345 if test "${ac_cv_lib_m_cabsl+set}" = set; then
15346   echo $ECHO_N "(cached) $ECHO_C" >&6
15347 else
15348   ac_check_lib_save_LIBS=$LIBS
15349 LIBS="-lm  $LIBS"
15350 if test x$gcc_no_link = xyes; then
15351   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15352 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15353    { (exit 1); exit 1; }; }
15354 fi
15355 cat >conftest.$ac_ext <<_ACEOF
15356 /* confdefs.h.  */
15357 _ACEOF
15358 cat confdefs.h >>conftest.$ac_ext
15359 cat >>conftest.$ac_ext <<_ACEOF
15360 /* end confdefs.h.  */
15361
15362 /* Override any gcc2 internal prototype to avoid an error.  */
15363 #ifdef __cplusplus
15364 extern "C"
15365 #endif
15366 /* We use char because int might match the return type of a gcc2
15367    builtin and then its argument prototype would still apply.  */
15368 char cabsl ();
15369 int
15370 main ()
15371 {
15372 cabsl ();
15373   ;
15374   return 0;
15375 }
15376 _ACEOF
15377 rm -f conftest.$ac_objext conftest$ac_exeext
15378 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15379   (eval $ac_link) 2>conftest.er1
15380   ac_status=$?
15381   grep -v '^ *+' conftest.er1 >conftest.err
15382   rm -f conftest.er1
15383   cat conftest.err >&5
15384   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15385   (exit $ac_status); } &&
15386          { ac_try='test -z "$ac_c_werror_flag"
15387                          || test ! -s conftest.err'
15388   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15389   (eval $ac_try) 2>&5
15390   ac_status=$?
15391   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15392   (exit $ac_status); }; } &&
15393          { ac_try='test -s conftest$ac_exeext'
15394   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15395   (eval $ac_try) 2>&5
15396   ac_status=$?
15397   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15398   (exit $ac_status); }; }; then
15399   ac_cv_lib_m_cabsl=yes
15400 else
15401   echo "$as_me: failed program was:" >&5
15402 sed 's/^/| /' conftest.$ac_ext >&5
15403
15404 ac_cv_lib_m_cabsl=no
15405 fi
15406 rm -f conftest.err conftest.$ac_objext \
15407       conftest$ac_exeext conftest.$ac_ext
15408 LIBS=$ac_check_lib_save_LIBS
15409 fi
15410 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabsl" >&5
15411 echo "${ECHO_T}$ac_cv_lib_m_cabsl" >&6
15412 if test $ac_cv_lib_m_cabsl = yes; then
15413
15414 cat >>confdefs.h <<\_ACEOF
15415 #define HAVE_CABSL 1
15416 _ACEOF
15417
15418 fi
15419
15420 echo "$as_me:$LINENO: checking for floorf in -lm" >&5
15421 echo $ECHO_N "checking for floorf in -lm... $ECHO_C" >&6
15422 if test "${ac_cv_lib_m_floorf+set}" = set; then
15423   echo $ECHO_N "(cached) $ECHO_C" >&6
15424 else
15425   ac_check_lib_save_LIBS=$LIBS
15426 LIBS="-lm  $LIBS"
15427 if test x$gcc_no_link = xyes; then
15428   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15429 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15430    { (exit 1); exit 1; }; }
15431 fi
15432 cat >conftest.$ac_ext <<_ACEOF
15433 /* confdefs.h.  */
15434 _ACEOF
15435 cat confdefs.h >>conftest.$ac_ext
15436 cat >>conftest.$ac_ext <<_ACEOF
15437 /* end confdefs.h.  */
15438
15439 /* Override any gcc2 internal prototype to avoid an error.  */
15440 #ifdef __cplusplus
15441 extern "C"
15442 #endif
15443 /* We use char because int might match the return type of a gcc2
15444    builtin and then its argument prototype would still apply.  */
15445 char floorf ();
15446 int
15447 main ()
15448 {
15449 floorf ();
15450   ;
15451   return 0;
15452 }
15453 _ACEOF
15454 rm -f conftest.$ac_objext conftest$ac_exeext
15455 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15456   (eval $ac_link) 2>conftest.er1
15457   ac_status=$?
15458   grep -v '^ *+' conftest.er1 >conftest.err
15459   rm -f conftest.er1
15460   cat conftest.err >&5
15461   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15462   (exit $ac_status); } &&
15463          { ac_try='test -z "$ac_c_werror_flag"
15464                          || test ! -s conftest.err'
15465   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15466   (eval $ac_try) 2>&5
15467   ac_status=$?
15468   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15469   (exit $ac_status); }; } &&
15470          { ac_try='test -s conftest$ac_exeext'
15471   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15472   (eval $ac_try) 2>&5
15473   ac_status=$?
15474   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15475   (exit $ac_status); }; }; then
15476   ac_cv_lib_m_floorf=yes
15477 else
15478   echo "$as_me: failed program was:" >&5
15479 sed 's/^/| /' conftest.$ac_ext >&5
15480
15481 ac_cv_lib_m_floorf=no
15482 fi
15483 rm -f conftest.err conftest.$ac_objext \
15484       conftest$ac_exeext conftest.$ac_ext
15485 LIBS=$ac_check_lib_save_LIBS
15486 fi
15487 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floorf" >&5
15488 echo "${ECHO_T}$ac_cv_lib_m_floorf" >&6
15489 if test $ac_cv_lib_m_floorf = yes; then
15490
15491 cat >>confdefs.h <<\_ACEOF
15492 #define HAVE_FLOORF 1
15493 _ACEOF
15494
15495 fi
15496
15497 echo "$as_me:$LINENO: checking for floor in -lm" >&5
15498 echo $ECHO_N "checking for floor in -lm... $ECHO_C" >&6
15499 if test "${ac_cv_lib_m_floor+set}" = set; then
15500   echo $ECHO_N "(cached) $ECHO_C" >&6
15501 else
15502   ac_check_lib_save_LIBS=$LIBS
15503 LIBS="-lm  $LIBS"
15504 if test x$gcc_no_link = xyes; then
15505   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15506 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15507    { (exit 1); exit 1; }; }
15508 fi
15509 cat >conftest.$ac_ext <<_ACEOF
15510 /* confdefs.h.  */
15511 _ACEOF
15512 cat confdefs.h >>conftest.$ac_ext
15513 cat >>conftest.$ac_ext <<_ACEOF
15514 /* end confdefs.h.  */
15515
15516 /* Override any gcc2 internal prototype to avoid an error.  */
15517 #ifdef __cplusplus
15518 extern "C"
15519 #endif
15520 /* We use char because int might match the return type of a gcc2
15521    builtin and then its argument prototype would still apply.  */
15522 char floor ();
15523 int
15524 main ()
15525 {
15526 floor ();
15527   ;
15528   return 0;
15529 }
15530 _ACEOF
15531 rm -f conftest.$ac_objext conftest$ac_exeext
15532 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15533   (eval $ac_link) 2>conftest.er1
15534   ac_status=$?
15535   grep -v '^ *+' conftest.er1 >conftest.err
15536   rm -f conftest.er1
15537   cat conftest.err >&5
15538   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15539   (exit $ac_status); } &&
15540          { ac_try='test -z "$ac_c_werror_flag"
15541                          || test ! -s conftest.err'
15542   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15543   (eval $ac_try) 2>&5
15544   ac_status=$?
15545   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15546   (exit $ac_status); }; } &&
15547          { ac_try='test -s conftest$ac_exeext'
15548   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15549   (eval $ac_try) 2>&5
15550   ac_status=$?
15551   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15552   (exit $ac_status); }; }; then
15553   ac_cv_lib_m_floor=yes
15554 else
15555   echo "$as_me: failed program was:" >&5
15556 sed 's/^/| /' conftest.$ac_ext >&5
15557
15558 ac_cv_lib_m_floor=no
15559 fi
15560 rm -f conftest.err conftest.$ac_objext \
15561       conftest$ac_exeext conftest.$ac_ext
15562 LIBS=$ac_check_lib_save_LIBS
15563 fi
15564 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floor" >&5
15565 echo "${ECHO_T}$ac_cv_lib_m_floor" >&6
15566 if test $ac_cv_lib_m_floor = yes; then
15567
15568 cat >>confdefs.h <<\_ACEOF
15569 #define HAVE_FLOOR 1
15570 _ACEOF
15571
15572 fi
15573
15574 echo "$as_me:$LINENO: checking for floorl in -lm" >&5
15575 echo $ECHO_N "checking for floorl in -lm... $ECHO_C" >&6
15576 if test "${ac_cv_lib_m_floorl+set}" = set; then
15577   echo $ECHO_N "(cached) $ECHO_C" >&6
15578 else
15579   ac_check_lib_save_LIBS=$LIBS
15580 LIBS="-lm  $LIBS"
15581 if test x$gcc_no_link = xyes; then
15582   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15583 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15584    { (exit 1); exit 1; }; }
15585 fi
15586 cat >conftest.$ac_ext <<_ACEOF
15587 /* confdefs.h.  */
15588 _ACEOF
15589 cat confdefs.h >>conftest.$ac_ext
15590 cat >>conftest.$ac_ext <<_ACEOF
15591 /* end confdefs.h.  */
15592
15593 /* Override any gcc2 internal prototype to avoid an error.  */
15594 #ifdef __cplusplus
15595 extern "C"
15596 #endif
15597 /* We use char because int might match the return type of a gcc2
15598    builtin and then its argument prototype would still apply.  */
15599 char floorl ();
15600 int
15601 main ()
15602 {
15603 floorl ();
15604   ;
15605   return 0;
15606 }
15607 _ACEOF
15608 rm -f conftest.$ac_objext conftest$ac_exeext
15609 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15610   (eval $ac_link) 2>conftest.er1
15611   ac_status=$?
15612   grep -v '^ *+' conftest.er1 >conftest.err
15613   rm -f conftest.er1
15614   cat conftest.err >&5
15615   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15616   (exit $ac_status); } &&
15617          { ac_try='test -z "$ac_c_werror_flag"
15618                          || test ! -s conftest.err'
15619   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15620   (eval $ac_try) 2>&5
15621   ac_status=$?
15622   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15623   (exit $ac_status); }; } &&
15624          { ac_try='test -s conftest$ac_exeext'
15625   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15626   (eval $ac_try) 2>&5
15627   ac_status=$?
15628   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15629   (exit $ac_status); }; }; then
15630   ac_cv_lib_m_floorl=yes
15631 else
15632   echo "$as_me: failed program was:" >&5
15633 sed 's/^/| /' conftest.$ac_ext >&5
15634
15635 ac_cv_lib_m_floorl=no
15636 fi
15637 rm -f conftest.err conftest.$ac_objext \
15638       conftest$ac_exeext conftest.$ac_ext
15639 LIBS=$ac_check_lib_save_LIBS
15640 fi
15641 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floorl" >&5
15642 echo "${ECHO_T}$ac_cv_lib_m_floorl" >&6
15643 if test $ac_cv_lib_m_floorl = yes; then
15644
15645 cat >>confdefs.h <<\_ACEOF
15646 #define HAVE_FLOORL 1
15647 _ACEOF
15648
15649 fi
15650
15651 echo "$as_me:$LINENO: checking for fmodf in -lm" >&5
15652 echo $ECHO_N "checking for fmodf in -lm... $ECHO_C" >&6
15653 if test "${ac_cv_lib_m_fmodf+set}" = set; then
15654   echo $ECHO_N "(cached) $ECHO_C" >&6
15655 else
15656   ac_check_lib_save_LIBS=$LIBS
15657 LIBS="-lm  $LIBS"
15658 if test x$gcc_no_link = xyes; then
15659   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15660 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15661    { (exit 1); exit 1; }; }
15662 fi
15663 cat >conftest.$ac_ext <<_ACEOF
15664 /* confdefs.h.  */
15665 _ACEOF
15666 cat confdefs.h >>conftest.$ac_ext
15667 cat >>conftest.$ac_ext <<_ACEOF
15668 /* end confdefs.h.  */
15669
15670 /* Override any gcc2 internal prototype to avoid an error.  */
15671 #ifdef __cplusplus
15672 extern "C"
15673 #endif
15674 /* We use char because int might match the return type of a gcc2
15675    builtin and then its argument prototype would still apply.  */
15676 char fmodf ();
15677 int
15678 main ()
15679 {
15680 fmodf ();
15681   ;
15682   return 0;
15683 }
15684 _ACEOF
15685 rm -f conftest.$ac_objext conftest$ac_exeext
15686 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15687   (eval $ac_link) 2>conftest.er1
15688   ac_status=$?
15689   grep -v '^ *+' conftest.er1 >conftest.err
15690   rm -f conftest.er1
15691   cat conftest.err >&5
15692   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15693   (exit $ac_status); } &&
15694          { ac_try='test -z "$ac_c_werror_flag"
15695                          || test ! -s conftest.err'
15696   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15697   (eval $ac_try) 2>&5
15698   ac_status=$?
15699   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15700   (exit $ac_status); }; } &&
15701          { ac_try='test -s conftest$ac_exeext'
15702   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15703   (eval $ac_try) 2>&5
15704   ac_status=$?
15705   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15706   (exit $ac_status); }; }; then
15707   ac_cv_lib_m_fmodf=yes
15708 else
15709   echo "$as_me: failed program was:" >&5
15710 sed 's/^/| /' conftest.$ac_ext >&5
15711
15712 ac_cv_lib_m_fmodf=no
15713 fi
15714 rm -f conftest.err conftest.$ac_objext \
15715       conftest$ac_exeext conftest.$ac_ext
15716 LIBS=$ac_check_lib_save_LIBS
15717 fi
15718 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fmodf" >&5
15719 echo "${ECHO_T}$ac_cv_lib_m_fmodf" >&6
15720 if test $ac_cv_lib_m_fmodf = yes; then
15721
15722 cat >>confdefs.h <<\_ACEOF
15723 #define HAVE_FMODF 1
15724 _ACEOF
15725
15726 fi
15727
15728 echo "$as_me:$LINENO: checking for fmod in -lm" >&5
15729 echo $ECHO_N "checking for fmod in -lm... $ECHO_C" >&6
15730 if test "${ac_cv_lib_m_fmod+set}" = set; then
15731   echo $ECHO_N "(cached) $ECHO_C" >&6
15732 else
15733   ac_check_lib_save_LIBS=$LIBS
15734 LIBS="-lm  $LIBS"
15735 if test x$gcc_no_link = xyes; then
15736   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15737 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15738    { (exit 1); exit 1; }; }
15739 fi
15740 cat >conftest.$ac_ext <<_ACEOF
15741 /* confdefs.h.  */
15742 _ACEOF
15743 cat confdefs.h >>conftest.$ac_ext
15744 cat >>conftest.$ac_ext <<_ACEOF
15745 /* end confdefs.h.  */
15746
15747 /* Override any gcc2 internal prototype to avoid an error.  */
15748 #ifdef __cplusplus
15749 extern "C"
15750 #endif
15751 /* We use char because int might match the return type of a gcc2
15752    builtin and then its argument prototype would still apply.  */
15753 char fmod ();
15754 int
15755 main ()
15756 {
15757 fmod ();
15758   ;
15759   return 0;
15760 }
15761 _ACEOF
15762 rm -f conftest.$ac_objext conftest$ac_exeext
15763 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15764   (eval $ac_link) 2>conftest.er1
15765   ac_status=$?
15766   grep -v '^ *+' conftest.er1 >conftest.err
15767   rm -f conftest.er1
15768   cat conftest.err >&5
15769   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15770   (exit $ac_status); } &&
15771          { ac_try='test -z "$ac_c_werror_flag"
15772                          || test ! -s conftest.err'
15773   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15774   (eval $ac_try) 2>&5
15775   ac_status=$?
15776   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15777   (exit $ac_status); }; } &&
15778          { ac_try='test -s conftest$ac_exeext'
15779   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15780   (eval $ac_try) 2>&5
15781   ac_status=$?
15782   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15783   (exit $ac_status); }; }; then
15784   ac_cv_lib_m_fmod=yes
15785 else
15786   echo "$as_me: failed program was:" >&5
15787 sed 's/^/| /' conftest.$ac_ext >&5
15788
15789 ac_cv_lib_m_fmod=no
15790 fi
15791 rm -f conftest.err conftest.$ac_objext \
15792       conftest$ac_exeext conftest.$ac_ext
15793 LIBS=$ac_check_lib_save_LIBS
15794 fi
15795 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fmod" >&5
15796 echo "${ECHO_T}$ac_cv_lib_m_fmod" >&6
15797 if test $ac_cv_lib_m_fmod = yes; then
15798
15799 cat >>confdefs.h <<\_ACEOF
15800 #define HAVE_FMOD 1
15801 _ACEOF
15802
15803 fi
15804
15805 echo "$as_me:$LINENO: checking for fmodl in -lm" >&5
15806 echo $ECHO_N "checking for fmodl in -lm... $ECHO_C" >&6
15807 if test "${ac_cv_lib_m_fmodl+set}" = set; then
15808   echo $ECHO_N "(cached) $ECHO_C" >&6
15809 else
15810   ac_check_lib_save_LIBS=$LIBS
15811 LIBS="-lm  $LIBS"
15812 if test x$gcc_no_link = xyes; then
15813   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15814 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15815    { (exit 1); exit 1; }; }
15816 fi
15817 cat >conftest.$ac_ext <<_ACEOF
15818 /* confdefs.h.  */
15819 _ACEOF
15820 cat confdefs.h >>conftest.$ac_ext
15821 cat >>conftest.$ac_ext <<_ACEOF
15822 /* end confdefs.h.  */
15823
15824 /* Override any gcc2 internal prototype to avoid an error.  */
15825 #ifdef __cplusplus
15826 extern "C"
15827 #endif
15828 /* We use char because int might match the return type of a gcc2
15829    builtin and then its argument prototype would still apply.  */
15830 char fmodl ();
15831 int
15832 main ()
15833 {
15834 fmodl ();
15835   ;
15836   return 0;
15837 }
15838 _ACEOF
15839 rm -f conftest.$ac_objext conftest$ac_exeext
15840 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15841   (eval $ac_link) 2>conftest.er1
15842   ac_status=$?
15843   grep -v '^ *+' conftest.er1 >conftest.err
15844   rm -f conftest.er1
15845   cat conftest.err >&5
15846   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15847   (exit $ac_status); } &&
15848          { ac_try='test -z "$ac_c_werror_flag"
15849                          || test ! -s conftest.err'
15850   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15851   (eval $ac_try) 2>&5
15852   ac_status=$?
15853   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15854   (exit $ac_status); }; } &&
15855          { ac_try='test -s conftest$ac_exeext'
15856   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15857   (eval $ac_try) 2>&5
15858   ac_status=$?
15859   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15860   (exit $ac_status); }; }; then
15861   ac_cv_lib_m_fmodl=yes
15862 else
15863   echo "$as_me: failed program was:" >&5
15864 sed 's/^/| /' conftest.$ac_ext >&5
15865
15866 ac_cv_lib_m_fmodl=no
15867 fi
15868 rm -f conftest.err conftest.$ac_objext \
15869       conftest$ac_exeext conftest.$ac_ext
15870 LIBS=$ac_check_lib_save_LIBS
15871 fi
15872 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fmodl" >&5
15873 echo "${ECHO_T}$ac_cv_lib_m_fmodl" >&6
15874 if test $ac_cv_lib_m_fmodl = yes; then
15875
15876 cat >>confdefs.h <<\_ACEOF
15877 #define HAVE_FMODL 1
15878 _ACEOF
15879
15880 fi
15881
15882 echo "$as_me:$LINENO: checking for frexpf in -lm" >&5
15883 echo $ECHO_N "checking for frexpf in -lm... $ECHO_C" >&6
15884 if test "${ac_cv_lib_m_frexpf+set}" = set; then
15885   echo $ECHO_N "(cached) $ECHO_C" >&6
15886 else
15887   ac_check_lib_save_LIBS=$LIBS
15888 LIBS="-lm  $LIBS"
15889 if test x$gcc_no_link = xyes; then
15890   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15891 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15892    { (exit 1); exit 1; }; }
15893 fi
15894 cat >conftest.$ac_ext <<_ACEOF
15895 /* confdefs.h.  */
15896 _ACEOF
15897 cat confdefs.h >>conftest.$ac_ext
15898 cat >>conftest.$ac_ext <<_ACEOF
15899 /* end confdefs.h.  */
15900
15901 /* Override any gcc2 internal prototype to avoid an error.  */
15902 #ifdef __cplusplus
15903 extern "C"
15904 #endif
15905 /* We use char because int might match the return type of a gcc2
15906    builtin and then its argument prototype would still apply.  */
15907 char frexpf ();
15908 int
15909 main ()
15910 {
15911 frexpf ();
15912   ;
15913   return 0;
15914 }
15915 _ACEOF
15916 rm -f conftest.$ac_objext conftest$ac_exeext
15917 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15918   (eval $ac_link) 2>conftest.er1
15919   ac_status=$?
15920   grep -v '^ *+' conftest.er1 >conftest.err
15921   rm -f conftest.er1
15922   cat conftest.err >&5
15923   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15924   (exit $ac_status); } &&
15925          { ac_try='test -z "$ac_c_werror_flag"
15926                          || test ! -s conftest.err'
15927   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15928   (eval $ac_try) 2>&5
15929   ac_status=$?
15930   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15931   (exit $ac_status); }; } &&
15932          { ac_try='test -s conftest$ac_exeext'
15933   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15934   (eval $ac_try) 2>&5
15935   ac_status=$?
15936   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15937   (exit $ac_status); }; }; then
15938   ac_cv_lib_m_frexpf=yes
15939 else
15940   echo "$as_me: failed program was:" >&5
15941 sed 's/^/| /' conftest.$ac_ext >&5
15942
15943 ac_cv_lib_m_frexpf=no
15944 fi
15945 rm -f conftest.err conftest.$ac_objext \
15946       conftest$ac_exeext conftest.$ac_ext
15947 LIBS=$ac_check_lib_save_LIBS
15948 fi
15949 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexpf" >&5
15950 echo "${ECHO_T}$ac_cv_lib_m_frexpf" >&6
15951 if test $ac_cv_lib_m_frexpf = yes; then
15952
15953 cat >>confdefs.h <<\_ACEOF
15954 #define HAVE_FREXPF 1
15955 _ACEOF
15956
15957 fi
15958
15959 echo "$as_me:$LINENO: checking for frexp in -lm" >&5
15960 echo $ECHO_N "checking for frexp in -lm... $ECHO_C" >&6
15961 if test "${ac_cv_lib_m_frexp+set}" = set; then
15962   echo $ECHO_N "(cached) $ECHO_C" >&6
15963 else
15964   ac_check_lib_save_LIBS=$LIBS
15965 LIBS="-lm  $LIBS"
15966 if test x$gcc_no_link = xyes; then
15967   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15968 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15969    { (exit 1); exit 1; }; }
15970 fi
15971 cat >conftest.$ac_ext <<_ACEOF
15972 /* confdefs.h.  */
15973 _ACEOF
15974 cat confdefs.h >>conftest.$ac_ext
15975 cat >>conftest.$ac_ext <<_ACEOF
15976 /* end confdefs.h.  */
15977
15978 /* Override any gcc2 internal prototype to avoid an error.  */
15979 #ifdef __cplusplus
15980 extern "C"
15981 #endif
15982 /* We use char because int might match the return type of a gcc2
15983    builtin and then its argument prototype would still apply.  */
15984 char frexp ();
15985 int
15986 main ()
15987 {
15988 frexp ();
15989   ;
15990   return 0;
15991 }
15992 _ACEOF
15993 rm -f conftest.$ac_objext conftest$ac_exeext
15994 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15995   (eval $ac_link) 2>conftest.er1
15996   ac_status=$?
15997   grep -v '^ *+' conftest.er1 >conftest.err
15998   rm -f conftest.er1
15999   cat conftest.err >&5
16000   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16001   (exit $ac_status); } &&
16002          { ac_try='test -z "$ac_c_werror_flag"
16003                          || test ! -s conftest.err'
16004   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16005   (eval $ac_try) 2>&5
16006   ac_status=$?
16007   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16008   (exit $ac_status); }; } &&
16009          { ac_try='test -s conftest$ac_exeext'
16010   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16011   (eval $ac_try) 2>&5
16012   ac_status=$?
16013   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16014   (exit $ac_status); }; }; then
16015   ac_cv_lib_m_frexp=yes
16016 else
16017   echo "$as_me: failed program was:" >&5
16018 sed 's/^/| /' conftest.$ac_ext >&5
16019
16020 ac_cv_lib_m_frexp=no
16021 fi
16022 rm -f conftest.err conftest.$ac_objext \
16023       conftest$ac_exeext conftest.$ac_ext
16024 LIBS=$ac_check_lib_save_LIBS
16025 fi
16026 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexp" >&5
16027 echo "${ECHO_T}$ac_cv_lib_m_frexp" >&6
16028 if test $ac_cv_lib_m_frexp = yes; then
16029
16030 cat >>confdefs.h <<\_ACEOF
16031 #define HAVE_FREXP 1
16032 _ACEOF
16033
16034 fi
16035
16036 echo "$as_me:$LINENO: checking for frexpl in -lm" >&5
16037 echo $ECHO_N "checking for frexpl in -lm... $ECHO_C" >&6
16038 if test "${ac_cv_lib_m_frexpl+set}" = set; then
16039   echo $ECHO_N "(cached) $ECHO_C" >&6
16040 else
16041   ac_check_lib_save_LIBS=$LIBS
16042 LIBS="-lm  $LIBS"
16043 if test x$gcc_no_link = xyes; then
16044   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16045 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16046    { (exit 1); exit 1; }; }
16047 fi
16048 cat >conftest.$ac_ext <<_ACEOF
16049 /* confdefs.h.  */
16050 _ACEOF
16051 cat confdefs.h >>conftest.$ac_ext
16052 cat >>conftest.$ac_ext <<_ACEOF
16053 /* end confdefs.h.  */
16054
16055 /* Override any gcc2 internal prototype to avoid an error.  */
16056 #ifdef __cplusplus
16057 extern "C"
16058 #endif
16059 /* We use char because int might match the return type of a gcc2
16060    builtin and then its argument prototype would still apply.  */
16061 char frexpl ();
16062 int
16063 main ()
16064 {
16065 frexpl ();
16066   ;
16067   return 0;
16068 }
16069 _ACEOF
16070 rm -f conftest.$ac_objext conftest$ac_exeext
16071 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16072   (eval $ac_link) 2>conftest.er1
16073   ac_status=$?
16074   grep -v '^ *+' conftest.er1 >conftest.err
16075   rm -f conftest.er1
16076   cat conftest.err >&5
16077   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16078   (exit $ac_status); } &&
16079          { ac_try='test -z "$ac_c_werror_flag"
16080                          || test ! -s conftest.err'
16081   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16082   (eval $ac_try) 2>&5
16083   ac_status=$?
16084   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16085   (exit $ac_status); }; } &&
16086          { ac_try='test -s conftest$ac_exeext'
16087   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16088   (eval $ac_try) 2>&5
16089   ac_status=$?
16090   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16091   (exit $ac_status); }; }; then
16092   ac_cv_lib_m_frexpl=yes
16093 else
16094   echo "$as_me: failed program was:" >&5
16095 sed 's/^/| /' conftest.$ac_ext >&5
16096
16097 ac_cv_lib_m_frexpl=no
16098 fi
16099 rm -f conftest.err conftest.$ac_objext \
16100       conftest$ac_exeext conftest.$ac_ext
16101 LIBS=$ac_check_lib_save_LIBS
16102 fi
16103 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexpl" >&5
16104 echo "${ECHO_T}$ac_cv_lib_m_frexpl" >&6
16105 if test $ac_cv_lib_m_frexpl = yes; then
16106
16107 cat >>confdefs.h <<\_ACEOF
16108 #define HAVE_FREXPL 1
16109 _ACEOF
16110
16111 fi
16112
16113 echo "$as_me:$LINENO: checking for hypotf in -lm" >&5
16114 echo $ECHO_N "checking for hypotf in -lm... $ECHO_C" >&6
16115 if test "${ac_cv_lib_m_hypotf+set}" = set; then
16116   echo $ECHO_N "(cached) $ECHO_C" >&6
16117 else
16118   ac_check_lib_save_LIBS=$LIBS
16119 LIBS="-lm  $LIBS"
16120 if test x$gcc_no_link = xyes; then
16121   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16122 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16123    { (exit 1); exit 1; }; }
16124 fi
16125 cat >conftest.$ac_ext <<_ACEOF
16126 /* confdefs.h.  */
16127 _ACEOF
16128 cat confdefs.h >>conftest.$ac_ext
16129 cat >>conftest.$ac_ext <<_ACEOF
16130 /* end confdefs.h.  */
16131
16132 /* Override any gcc2 internal prototype to avoid an error.  */
16133 #ifdef __cplusplus
16134 extern "C"
16135 #endif
16136 /* We use char because int might match the return type of a gcc2
16137    builtin and then its argument prototype would still apply.  */
16138 char hypotf ();
16139 int
16140 main ()
16141 {
16142 hypotf ();
16143   ;
16144   return 0;
16145 }
16146 _ACEOF
16147 rm -f conftest.$ac_objext conftest$ac_exeext
16148 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16149   (eval $ac_link) 2>conftest.er1
16150   ac_status=$?
16151   grep -v '^ *+' conftest.er1 >conftest.err
16152   rm -f conftest.er1
16153   cat conftest.err >&5
16154   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16155   (exit $ac_status); } &&
16156          { ac_try='test -z "$ac_c_werror_flag"
16157                          || test ! -s conftest.err'
16158   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16159   (eval $ac_try) 2>&5
16160   ac_status=$?
16161   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16162   (exit $ac_status); }; } &&
16163          { ac_try='test -s conftest$ac_exeext'
16164   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16165   (eval $ac_try) 2>&5
16166   ac_status=$?
16167   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16168   (exit $ac_status); }; }; then
16169   ac_cv_lib_m_hypotf=yes
16170 else
16171   echo "$as_me: failed program was:" >&5
16172 sed 's/^/| /' conftest.$ac_ext >&5
16173
16174 ac_cv_lib_m_hypotf=no
16175 fi
16176 rm -f conftest.err conftest.$ac_objext \
16177       conftest$ac_exeext conftest.$ac_ext
16178 LIBS=$ac_check_lib_save_LIBS
16179 fi
16180 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypotf" >&5
16181 echo "${ECHO_T}$ac_cv_lib_m_hypotf" >&6
16182 if test $ac_cv_lib_m_hypotf = yes; then
16183
16184 cat >>confdefs.h <<\_ACEOF
16185 #define HAVE_HYPOTF 1
16186 _ACEOF
16187
16188 fi
16189
16190 echo "$as_me:$LINENO: checking for hypot in -lm" >&5
16191 echo $ECHO_N "checking for hypot in -lm... $ECHO_C" >&6
16192 if test "${ac_cv_lib_m_hypot+set}" = set; then
16193   echo $ECHO_N "(cached) $ECHO_C" >&6
16194 else
16195   ac_check_lib_save_LIBS=$LIBS
16196 LIBS="-lm  $LIBS"
16197 if test x$gcc_no_link = xyes; then
16198   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16199 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16200    { (exit 1); exit 1; }; }
16201 fi
16202 cat >conftest.$ac_ext <<_ACEOF
16203 /* confdefs.h.  */
16204 _ACEOF
16205 cat confdefs.h >>conftest.$ac_ext
16206 cat >>conftest.$ac_ext <<_ACEOF
16207 /* end confdefs.h.  */
16208
16209 /* Override any gcc2 internal prototype to avoid an error.  */
16210 #ifdef __cplusplus
16211 extern "C"
16212 #endif
16213 /* We use char because int might match the return type of a gcc2
16214    builtin and then its argument prototype would still apply.  */
16215 char hypot ();
16216 int
16217 main ()
16218 {
16219 hypot ();
16220   ;
16221   return 0;
16222 }
16223 _ACEOF
16224 rm -f conftest.$ac_objext conftest$ac_exeext
16225 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16226   (eval $ac_link) 2>conftest.er1
16227   ac_status=$?
16228   grep -v '^ *+' conftest.er1 >conftest.err
16229   rm -f conftest.er1
16230   cat conftest.err >&5
16231   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16232   (exit $ac_status); } &&
16233          { ac_try='test -z "$ac_c_werror_flag"
16234                          || test ! -s conftest.err'
16235   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16236   (eval $ac_try) 2>&5
16237   ac_status=$?
16238   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16239   (exit $ac_status); }; } &&
16240          { ac_try='test -s conftest$ac_exeext'
16241   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16242   (eval $ac_try) 2>&5
16243   ac_status=$?
16244   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16245   (exit $ac_status); }; }; then
16246   ac_cv_lib_m_hypot=yes
16247 else
16248   echo "$as_me: failed program was:" >&5
16249 sed 's/^/| /' conftest.$ac_ext >&5
16250
16251 ac_cv_lib_m_hypot=no
16252 fi
16253 rm -f conftest.err conftest.$ac_objext \
16254       conftest$ac_exeext conftest.$ac_ext
16255 LIBS=$ac_check_lib_save_LIBS
16256 fi
16257 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypot" >&5
16258 echo "${ECHO_T}$ac_cv_lib_m_hypot" >&6
16259 if test $ac_cv_lib_m_hypot = yes; then
16260
16261 cat >>confdefs.h <<\_ACEOF
16262 #define HAVE_HYPOT 1
16263 _ACEOF
16264
16265 fi
16266
16267 echo "$as_me:$LINENO: checking for hypotl in -lm" >&5
16268 echo $ECHO_N "checking for hypotl in -lm... $ECHO_C" >&6
16269 if test "${ac_cv_lib_m_hypotl+set}" = set; then
16270   echo $ECHO_N "(cached) $ECHO_C" >&6
16271 else
16272   ac_check_lib_save_LIBS=$LIBS
16273 LIBS="-lm  $LIBS"
16274 if test x$gcc_no_link = xyes; then
16275   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16276 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16277    { (exit 1); exit 1; }; }
16278 fi
16279 cat >conftest.$ac_ext <<_ACEOF
16280 /* confdefs.h.  */
16281 _ACEOF
16282 cat confdefs.h >>conftest.$ac_ext
16283 cat >>conftest.$ac_ext <<_ACEOF
16284 /* end confdefs.h.  */
16285
16286 /* Override any gcc2 internal prototype to avoid an error.  */
16287 #ifdef __cplusplus
16288 extern "C"
16289 #endif
16290 /* We use char because int might match the return type of a gcc2
16291    builtin and then its argument prototype would still apply.  */
16292 char hypotl ();
16293 int
16294 main ()
16295 {
16296 hypotl ();
16297   ;
16298   return 0;
16299 }
16300 _ACEOF
16301 rm -f conftest.$ac_objext conftest$ac_exeext
16302 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16303   (eval $ac_link) 2>conftest.er1
16304   ac_status=$?
16305   grep -v '^ *+' conftest.er1 >conftest.err
16306   rm -f conftest.er1
16307   cat conftest.err >&5
16308   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16309   (exit $ac_status); } &&
16310          { ac_try='test -z "$ac_c_werror_flag"
16311                          || test ! -s conftest.err'
16312   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16313   (eval $ac_try) 2>&5
16314   ac_status=$?
16315   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16316   (exit $ac_status); }; } &&
16317          { ac_try='test -s conftest$ac_exeext'
16318   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16319   (eval $ac_try) 2>&5
16320   ac_status=$?
16321   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16322   (exit $ac_status); }; }; then
16323   ac_cv_lib_m_hypotl=yes
16324 else
16325   echo "$as_me: failed program was:" >&5
16326 sed 's/^/| /' conftest.$ac_ext >&5
16327
16328 ac_cv_lib_m_hypotl=no
16329 fi
16330 rm -f conftest.err conftest.$ac_objext \
16331       conftest$ac_exeext conftest.$ac_ext
16332 LIBS=$ac_check_lib_save_LIBS
16333 fi
16334 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypotl" >&5
16335 echo "${ECHO_T}$ac_cv_lib_m_hypotl" >&6
16336 if test $ac_cv_lib_m_hypotl = yes; then
16337
16338 cat >>confdefs.h <<\_ACEOF
16339 #define HAVE_HYPOTL 1
16340 _ACEOF
16341
16342 fi
16343
16344 echo "$as_me:$LINENO: checking for ldexpf in -lm" >&5
16345 echo $ECHO_N "checking for ldexpf in -lm... $ECHO_C" >&6
16346 if test "${ac_cv_lib_m_ldexpf+set}" = set; then
16347   echo $ECHO_N "(cached) $ECHO_C" >&6
16348 else
16349   ac_check_lib_save_LIBS=$LIBS
16350 LIBS="-lm  $LIBS"
16351 if test x$gcc_no_link = xyes; then
16352   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16353 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16354    { (exit 1); exit 1; }; }
16355 fi
16356 cat >conftest.$ac_ext <<_ACEOF
16357 /* confdefs.h.  */
16358 _ACEOF
16359 cat confdefs.h >>conftest.$ac_ext
16360 cat >>conftest.$ac_ext <<_ACEOF
16361 /* end confdefs.h.  */
16362
16363 /* Override any gcc2 internal prototype to avoid an error.  */
16364 #ifdef __cplusplus
16365 extern "C"
16366 #endif
16367 /* We use char because int might match the return type of a gcc2
16368    builtin and then its argument prototype would still apply.  */
16369 char ldexpf ();
16370 int
16371 main ()
16372 {
16373 ldexpf ();
16374   ;
16375   return 0;
16376 }
16377 _ACEOF
16378 rm -f conftest.$ac_objext conftest$ac_exeext
16379 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16380   (eval $ac_link) 2>conftest.er1
16381   ac_status=$?
16382   grep -v '^ *+' conftest.er1 >conftest.err
16383   rm -f conftest.er1
16384   cat conftest.err >&5
16385   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16386   (exit $ac_status); } &&
16387          { ac_try='test -z "$ac_c_werror_flag"
16388                          || test ! -s conftest.err'
16389   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16390   (eval $ac_try) 2>&5
16391   ac_status=$?
16392   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16393   (exit $ac_status); }; } &&
16394          { ac_try='test -s conftest$ac_exeext'
16395   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16396   (eval $ac_try) 2>&5
16397   ac_status=$?
16398   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16399   (exit $ac_status); }; }; then
16400   ac_cv_lib_m_ldexpf=yes
16401 else
16402   echo "$as_me: failed program was:" >&5
16403 sed 's/^/| /' conftest.$ac_ext >&5
16404
16405 ac_cv_lib_m_ldexpf=no
16406 fi
16407 rm -f conftest.err conftest.$ac_objext \
16408       conftest$ac_exeext conftest.$ac_ext
16409 LIBS=$ac_check_lib_save_LIBS
16410 fi
16411 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ldexpf" >&5
16412 echo "${ECHO_T}$ac_cv_lib_m_ldexpf" >&6
16413 if test $ac_cv_lib_m_ldexpf = yes; then
16414
16415 cat >>confdefs.h <<\_ACEOF
16416 #define HAVE_LDEXPF 1
16417 _ACEOF
16418
16419 fi
16420
16421 echo "$as_me:$LINENO: checking for ldexp in -lm" >&5
16422 echo $ECHO_N "checking for ldexp in -lm... $ECHO_C" >&6
16423 if test "${ac_cv_lib_m_ldexp+set}" = set; then
16424   echo $ECHO_N "(cached) $ECHO_C" >&6
16425 else
16426   ac_check_lib_save_LIBS=$LIBS
16427 LIBS="-lm  $LIBS"
16428 if test x$gcc_no_link = xyes; then
16429   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16430 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16431    { (exit 1); exit 1; }; }
16432 fi
16433 cat >conftest.$ac_ext <<_ACEOF
16434 /* confdefs.h.  */
16435 _ACEOF
16436 cat confdefs.h >>conftest.$ac_ext
16437 cat >>conftest.$ac_ext <<_ACEOF
16438 /* end confdefs.h.  */
16439
16440 /* Override any gcc2 internal prototype to avoid an error.  */
16441 #ifdef __cplusplus
16442 extern "C"
16443 #endif
16444 /* We use char because int might match the return type of a gcc2
16445    builtin and then its argument prototype would still apply.  */
16446 char ldexp ();
16447 int
16448 main ()
16449 {
16450 ldexp ();
16451   ;
16452   return 0;
16453 }
16454 _ACEOF
16455 rm -f conftest.$ac_objext conftest$ac_exeext
16456 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16457   (eval $ac_link) 2>conftest.er1
16458   ac_status=$?
16459   grep -v '^ *+' conftest.er1 >conftest.err
16460   rm -f conftest.er1
16461   cat conftest.err >&5
16462   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16463   (exit $ac_status); } &&
16464          { ac_try='test -z "$ac_c_werror_flag"
16465                          || test ! -s conftest.err'
16466   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16467   (eval $ac_try) 2>&5
16468   ac_status=$?
16469   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16470   (exit $ac_status); }; } &&
16471          { ac_try='test -s conftest$ac_exeext'
16472   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16473   (eval $ac_try) 2>&5
16474   ac_status=$?
16475   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16476   (exit $ac_status); }; }; then
16477   ac_cv_lib_m_ldexp=yes
16478 else
16479   echo "$as_me: failed program was:" >&5
16480 sed 's/^/| /' conftest.$ac_ext >&5
16481
16482 ac_cv_lib_m_ldexp=no
16483 fi
16484 rm -f conftest.err conftest.$ac_objext \
16485       conftest$ac_exeext conftest.$ac_ext
16486 LIBS=$ac_check_lib_save_LIBS
16487 fi
16488 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ldexp" >&5
16489 echo "${ECHO_T}$ac_cv_lib_m_ldexp" >&6
16490 if test $ac_cv_lib_m_ldexp = yes; then
16491
16492 cat >>confdefs.h <<\_ACEOF
16493 #define HAVE_LDEXP 1
16494 _ACEOF
16495
16496 fi
16497
16498 echo "$as_me:$LINENO: checking for ldexpl in -lm" >&5
16499 echo $ECHO_N "checking for ldexpl in -lm... $ECHO_C" >&6
16500 if test "${ac_cv_lib_m_ldexpl+set}" = set; then
16501   echo $ECHO_N "(cached) $ECHO_C" >&6
16502 else
16503   ac_check_lib_save_LIBS=$LIBS
16504 LIBS="-lm  $LIBS"
16505 if test x$gcc_no_link = xyes; then
16506   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16507 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16508    { (exit 1); exit 1; }; }
16509 fi
16510 cat >conftest.$ac_ext <<_ACEOF
16511 /* confdefs.h.  */
16512 _ACEOF
16513 cat confdefs.h >>conftest.$ac_ext
16514 cat >>conftest.$ac_ext <<_ACEOF
16515 /* end confdefs.h.  */
16516
16517 /* Override any gcc2 internal prototype to avoid an error.  */
16518 #ifdef __cplusplus
16519 extern "C"
16520 #endif
16521 /* We use char because int might match the return type of a gcc2
16522    builtin and then its argument prototype would still apply.  */
16523 char ldexpl ();
16524 int
16525 main ()
16526 {
16527 ldexpl ();
16528   ;
16529   return 0;
16530 }
16531 _ACEOF
16532 rm -f conftest.$ac_objext conftest$ac_exeext
16533 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16534   (eval $ac_link) 2>conftest.er1
16535   ac_status=$?
16536   grep -v '^ *+' conftest.er1 >conftest.err
16537   rm -f conftest.er1
16538   cat conftest.err >&5
16539   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16540   (exit $ac_status); } &&
16541          { ac_try='test -z "$ac_c_werror_flag"
16542                          || test ! -s conftest.err'
16543   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16544   (eval $ac_try) 2>&5
16545   ac_status=$?
16546   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16547   (exit $ac_status); }; } &&
16548          { ac_try='test -s conftest$ac_exeext'
16549   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16550   (eval $ac_try) 2>&5
16551   ac_status=$?
16552   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16553   (exit $ac_status); }; }; then
16554   ac_cv_lib_m_ldexpl=yes
16555 else
16556   echo "$as_me: failed program was:" >&5
16557 sed 's/^/| /' conftest.$ac_ext >&5
16558
16559 ac_cv_lib_m_ldexpl=no
16560 fi
16561 rm -f conftest.err conftest.$ac_objext \
16562       conftest$ac_exeext conftest.$ac_ext
16563 LIBS=$ac_check_lib_save_LIBS
16564 fi
16565 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ldexpl" >&5
16566 echo "${ECHO_T}$ac_cv_lib_m_ldexpl" >&6
16567 if test $ac_cv_lib_m_ldexpl = yes; then
16568
16569 cat >>confdefs.h <<\_ACEOF
16570 #define HAVE_LDEXPL 1
16571 _ACEOF
16572
16573 fi
16574
16575 echo "$as_me:$LINENO: checking for logf in -lm" >&5
16576 echo $ECHO_N "checking for logf in -lm... $ECHO_C" >&6
16577 if test "${ac_cv_lib_m_logf+set}" = set; then
16578   echo $ECHO_N "(cached) $ECHO_C" >&6
16579 else
16580   ac_check_lib_save_LIBS=$LIBS
16581 LIBS="-lm  $LIBS"
16582 if test x$gcc_no_link = xyes; then
16583   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16584 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16585    { (exit 1); exit 1; }; }
16586 fi
16587 cat >conftest.$ac_ext <<_ACEOF
16588 /* confdefs.h.  */
16589 _ACEOF
16590 cat confdefs.h >>conftest.$ac_ext
16591 cat >>conftest.$ac_ext <<_ACEOF
16592 /* end confdefs.h.  */
16593
16594 /* Override any gcc2 internal prototype to avoid an error.  */
16595 #ifdef __cplusplus
16596 extern "C"
16597 #endif
16598 /* We use char because int might match the return type of a gcc2
16599    builtin and then its argument prototype would still apply.  */
16600 char logf ();
16601 int
16602 main ()
16603 {
16604 logf ();
16605   ;
16606   return 0;
16607 }
16608 _ACEOF
16609 rm -f conftest.$ac_objext conftest$ac_exeext
16610 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16611   (eval $ac_link) 2>conftest.er1
16612   ac_status=$?
16613   grep -v '^ *+' conftest.er1 >conftest.err
16614   rm -f conftest.er1
16615   cat conftest.err >&5
16616   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16617   (exit $ac_status); } &&
16618          { ac_try='test -z "$ac_c_werror_flag"
16619                          || test ! -s conftest.err'
16620   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16621   (eval $ac_try) 2>&5
16622   ac_status=$?
16623   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16624   (exit $ac_status); }; } &&
16625          { ac_try='test -s conftest$ac_exeext'
16626   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16627   (eval $ac_try) 2>&5
16628   ac_status=$?
16629   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16630   (exit $ac_status); }; }; then
16631   ac_cv_lib_m_logf=yes
16632 else
16633   echo "$as_me: failed program was:" >&5
16634 sed 's/^/| /' conftest.$ac_ext >&5
16635
16636 ac_cv_lib_m_logf=no
16637 fi
16638 rm -f conftest.err conftest.$ac_objext \
16639       conftest$ac_exeext conftest.$ac_ext
16640 LIBS=$ac_check_lib_save_LIBS
16641 fi
16642 echo "$as_me:$LINENO: result: $ac_cv_lib_m_logf" >&5
16643 echo "${ECHO_T}$ac_cv_lib_m_logf" >&6
16644 if test $ac_cv_lib_m_logf = yes; then
16645
16646 cat >>confdefs.h <<\_ACEOF
16647 #define HAVE_LOGF 1
16648 _ACEOF
16649
16650 fi
16651
16652 echo "$as_me:$LINENO: checking for log in -lm" >&5
16653 echo $ECHO_N "checking for log in -lm... $ECHO_C" >&6
16654 if test "${ac_cv_lib_m_log+set}" = set; then
16655   echo $ECHO_N "(cached) $ECHO_C" >&6
16656 else
16657   ac_check_lib_save_LIBS=$LIBS
16658 LIBS="-lm  $LIBS"
16659 if test x$gcc_no_link = xyes; then
16660   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16661 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16662    { (exit 1); exit 1; }; }
16663 fi
16664 cat >conftest.$ac_ext <<_ACEOF
16665 /* confdefs.h.  */
16666 _ACEOF
16667 cat confdefs.h >>conftest.$ac_ext
16668 cat >>conftest.$ac_ext <<_ACEOF
16669 /* end confdefs.h.  */
16670
16671 /* Override any gcc2 internal prototype to avoid an error.  */
16672 #ifdef __cplusplus
16673 extern "C"
16674 #endif
16675 /* We use char because int might match the return type of a gcc2
16676    builtin and then its argument prototype would still apply.  */
16677 char log ();
16678 int
16679 main ()
16680 {
16681 log ();
16682   ;
16683   return 0;
16684 }
16685 _ACEOF
16686 rm -f conftest.$ac_objext conftest$ac_exeext
16687 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16688   (eval $ac_link) 2>conftest.er1
16689   ac_status=$?
16690   grep -v '^ *+' conftest.er1 >conftest.err
16691   rm -f conftest.er1
16692   cat conftest.err >&5
16693   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16694   (exit $ac_status); } &&
16695          { ac_try='test -z "$ac_c_werror_flag"
16696                          || test ! -s conftest.err'
16697   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16698   (eval $ac_try) 2>&5
16699   ac_status=$?
16700   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16701   (exit $ac_status); }; } &&
16702          { ac_try='test -s conftest$ac_exeext'
16703   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16704   (eval $ac_try) 2>&5
16705   ac_status=$?
16706   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16707   (exit $ac_status); }; }; then
16708   ac_cv_lib_m_log=yes
16709 else
16710   echo "$as_me: failed program was:" >&5
16711 sed 's/^/| /' conftest.$ac_ext >&5
16712
16713 ac_cv_lib_m_log=no
16714 fi
16715 rm -f conftest.err conftest.$ac_objext \
16716       conftest$ac_exeext conftest.$ac_ext
16717 LIBS=$ac_check_lib_save_LIBS
16718 fi
16719 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log" >&5
16720 echo "${ECHO_T}$ac_cv_lib_m_log" >&6
16721 if test $ac_cv_lib_m_log = yes; then
16722
16723 cat >>confdefs.h <<\_ACEOF
16724 #define HAVE_LOG 1
16725 _ACEOF
16726
16727 fi
16728
16729 echo "$as_me:$LINENO: checking for logl in -lm" >&5
16730 echo $ECHO_N "checking for logl in -lm... $ECHO_C" >&6
16731 if test "${ac_cv_lib_m_logl+set}" = set; then
16732   echo $ECHO_N "(cached) $ECHO_C" >&6
16733 else
16734   ac_check_lib_save_LIBS=$LIBS
16735 LIBS="-lm  $LIBS"
16736 if test x$gcc_no_link = xyes; then
16737   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16738 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16739    { (exit 1); exit 1; }; }
16740 fi
16741 cat >conftest.$ac_ext <<_ACEOF
16742 /* confdefs.h.  */
16743 _ACEOF
16744 cat confdefs.h >>conftest.$ac_ext
16745 cat >>conftest.$ac_ext <<_ACEOF
16746 /* end confdefs.h.  */
16747
16748 /* Override any gcc2 internal prototype to avoid an error.  */
16749 #ifdef __cplusplus
16750 extern "C"
16751 #endif
16752 /* We use char because int might match the return type of a gcc2
16753    builtin and then its argument prototype would still apply.  */
16754 char logl ();
16755 int
16756 main ()
16757 {
16758 logl ();
16759   ;
16760   return 0;
16761 }
16762 _ACEOF
16763 rm -f conftest.$ac_objext conftest$ac_exeext
16764 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16765   (eval $ac_link) 2>conftest.er1
16766   ac_status=$?
16767   grep -v '^ *+' conftest.er1 >conftest.err
16768   rm -f conftest.er1
16769   cat conftest.err >&5
16770   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16771   (exit $ac_status); } &&
16772          { ac_try='test -z "$ac_c_werror_flag"
16773                          || test ! -s conftest.err'
16774   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16775   (eval $ac_try) 2>&5
16776   ac_status=$?
16777   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16778   (exit $ac_status); }; } &&
16779          { ac_try='test -s conftest$ac_exeext'
16780   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16781   (eval $ac_try) 2>&5
16782   ac_status=$?
16783   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16784   (exit $ac_status); }; }; then
16785   ac_cv_lib_m_logl=yes
16786 else
16787   echo "$as_me: failed program was:" >&5
16788 sed 's/^/| /' conftest.$ac_ext >&5
16789
16790 ac_cv_lib_m_logl=no
16791 fi
16792 rm -f conftest.err conftest.$ac_objext \
16793       conftest$ac_exeext conftest.$ac_ext
16794 LIBS=$ac_check_lib_save_LIBS
16795 fi
16796 echo "$as_me:$LINENO: result: $ac_cv_lib_m_logl" >&5
16797 echo "${ECHO_T}$ac_cv_lib_m_logl" >&6
16798 if test $ac_cv_lib_m_logl = yes; then
16799
16800 cat >>confdefs.h <<\_ACEOF
16801 #define HAVE_LOGL 1
16802 _ACEOF
16803
16804 fi
16805
16806 echo "$as_me:$LINENO: checking for clogf in -lm" >&5
16807 echo $ECHO_N "checking for clogf in -lm... $ECHO_C" >&6
16808 if test "${ac_cv_lib_m_clogf+set}" = set; then
16809   echo $ECHO_N "(cached) $ECHO_C" >&6
16810 else
16811   ac_check_lib_save_LIBS=$LIBS
16812 LIBS="-lm  $LIBS"
16813 if test x$gcc_no_link = xyes; then
16814   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16815 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16816    { (exit 1); exit 1; }; }
16817 fi
16818 cat >conftest.$ac_ext <<_ACEOF
16819 /* confdefs.h.  */
16820 _ACEOF
16821 cat confdefs.h >>conftest.$ac_ext
16822 cat >>conftest.$ac_ext <<_ACEOF
16823 /* end confdefs.h.  */
16824
16825 /* Override any gcc2 internal prototype to avoid an error.  */
16826 #ifdef __cplusplus
16827 extern "C"
16828 #endif
16829 /* We use char because int might match the return type of a gcc2
16830    builtin and then its argument prototype would still apply.  */
16831 char clogf ();
16832 int
16833 main ()
16834 {
16835 clogf ();
16836   ;
16837   return 0;
16838 }
16839 _ACEOF
16840 rm -f conftest.$ac_objext conftest$ac_exeext
16841 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16842   (eval $ac_link) 2>conftest.er1
16843   ac_status=$?
16844   grep -v '^ *+' conftest.er1 >conftest.err
16845   rm -f conftest.er1
16846   cat conftest.err >&5
16847   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16848   (exit $ac_status); } &&
16849          { ac_try='test -z "$ac_c_werror_flag"
16850                          || test ! -s conftest.err'
16851   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16852   (eval $ac_try) 2>&5
16853   ac_status=$?
16854   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16855   (exit $ac_status); }; } &&
16856          { ac_try='test -s conftest$ac_exeext'
16857   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16858   (eval $ac_try) 2>&5
16859   ac_status=$?
16860   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16861   (exit $ac_status); }; }; then
16862   ac_cv_lib_m_clogf=yes
16863 else
16864   echo "$as_me: failed program was:" >&5
16865 sed 's/^/| /' conftest.$ac_ext >&5
16866
16867 ac_cv_lib_m_clogf=no
16868 fi
16869 rm -f conftest.err conftest.$ac_objext \
16870       conftest$ac_exeext conftest.$ac_ext
16871 LIBS=$ac_check_lib_save_LIBS
16872 fi
16873 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clogf" >&5
16874 echo "${ECHO_T}$ac_cv_lib_m_clogf" >&6
16875 if test $ac_cv_lib_m_clogf = yes; then
16876
16877 cat >>confdefs.h <<\_ACEOF
16878 #define HAVE_CLOGF 1
16879 _ACEOF
16880
16881 fi
16882
16883 echo "$as_me:$LINENO: checking for clog in -lm" >&5
16884 echo $ECHO_N "checking for clog in -lm... $ECHO_C" >&6
16885 if test "${ac_cv_lib_m_clog+set}" = set; then
16886   echo $ECHO_N "(cached) $ECHO_C" >&6
16887 else
16888   ac_check_lib_save_LIBS=$LIBS
16889 LIBS="-lm  $LIBS"
16890 if test x$gcc_no_link = xyes; then
16891   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16892 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16893    { (exit 1); exit 1; }; }
16894 fi
16895 cat >conftest.$ac_ext <<_ACEOF
16896 /* confdefs.h.  */
16897 _ACEOF
16898 cat confdefs.h >>conftest.$ac_ext
16899 cat >>conftest.$ac_ext <<_ACEOF
16900 /* end confdefs.h.  */
16901
16902 /* Override any gcc2 internal prototype to avoid an error.  */
16903 #ifdef __cplusplus
16904 extern "C"
16905 #endif
16906 /* We use char because int might match the return type of a gcc2
16907    builtin and then its argument prototype would still apply.  */
16908 char clog ();
16909 int
16910 main ()
16911 {
16912 clog ();
16913   ;
16914   return 0;
16915 }
16916 _ACEOF
16917 rm -f conftest.$ac_objext conftest$ac_exeext
16918 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16919   (eval $ac_link) 2>conftest.er1
16920   ac_status=$?
16921   grep -v '^ *+' conftest.er1 >conftest.err
16922   rm -f conftest.er1
16923   cat conftest.err >&5
16924   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16925   (exit $ac_status); } &&
16926          { ac_try='test -z "$ac_c_werror_flag"
16927                          || test ! -s conftest.err'
16928   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16929   (eval $ac_try) 2>&5
16930   ac_status=$?
16931   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16932   (exit $ac_status); }; } &&
16933          { ac_try='test -s conftest$ac_exeext'
16934   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16935   (eval $ac_try) 2>&5
16936   ac_status=$?
16937   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16938   (exit $ac_status); }; }; then
16939   ac_cv_lib_m_clog=yes
16940 else
16941   echo "$as_me: failed program was:" >&5
16942 sed 's/^/| /' conftest.$ac_ext >&5
16943
16944 ac_cv_lib_m_clog=no
16945 fi
16946 rm -f conftest.err conftest.$ac_objext \
16947       conftest$ac_exeext conftest.$ac_ext
16948 LIBS=$ac_check_lib_save_LIBS
16949 fi
16950 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog" >&5
16951 echo "${ECHO_T}$ac_cv_lib_m_clog" >&6
16952 if test $ac_cv_lib_m_clog = yes; then
16953
16954 cat >>confdefs.h <<\_ACEOF
16955 #define HAVE_CLOG 1
16956 _ACEOF
16957
16958 fi
16959
16960 echo "$as_me:$LINENO: checking for clogl in -lm" >&5
16961 echo $ECHO_N "checking for clogl in -lm... $ECHO_C" >&6
16962 if test "${ac_cv_lib_m_clogl+set}" = set; then
16963   echo $ECHO_N "(cached) $ECHO_C" >&6
16964 else
16965   ac_check_lib_save_LIBS=$LIBS
16966 LIBS="-lm  $LIBS"
16967 if test x$gcc_no_link = xyes; then
16968   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16969 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16970    { (exit 1); exit 1; }; }
16971 fi
16972 cat >conftest.$ac_ext <<_ACEOF
16973 /* confdefs.h.  */
16974 _ACEOF
16975 cat confdefs.h >>conftest.$ac_ext
16976 cat >>conftest.$ac_ext <<_ACEOF
16977 /* end confdefs.h.  */
16978
16979 /* Override any gcc2 internal prototype to avoid an error.  */
16980 #ifdef __cplusplus
16981 extern "C"
16982 #endif
16983 /* We use char because int might match the return type of a gcc2
16984    builtin and then its argument prototype would still apply.  */
16985 char clogl ();
16986 int
16987 main ()
16988 {
16989 clogl ();
16990   ;
16991   return 0;
16992 }
16993 _ACEOF
16994 rm -f conftest.$ac_objext conftest$ac_exeext
16995 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16996   (eval $ac_link) 2>conftest.er1
16997   ac_status=$?
16998   grep -v '^ *+' conftest.er1 >conftest.err
16999   rm -f conftest.er1
17000   cat conftest.err >&5
17001   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17002   (exit $ac_status); } &&
17003          { ac_try='test -z "$ac_c_werror_flag"
17004                          || test ! -s conftest.err'
17005   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17006   (eval $ac_try) 2>&5
17007   ac_status=$?
17008   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17009   (exit $ac_status); }; } &&
17010          { ac_try='test -s conftest$ac_exeext'
17011   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17012   (eval $ac_try) 2>&5
17013   ac_status=$?
17014   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17015   (exit $ac_status); }; }; then
17016   ac_cv_lib_m_clogl=yes
17017 else
17018   echo "$as_me: failed program was:" >&5
17019 sed 's/^/| /' conftest.$ac_ext >&5
17020
17021 ac_cv_lib_m_clogl=no
17022 fi
17023 rm -f conftest.err conftest.$ac_objext \
17024       conftest$ac_exeext conftest.$ac_ext
17025 LIBS=$ac_check_lib_save_LIBS
17026 fi
17027 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clogl" >&5
17028 echo "${ECHO_T}$ac_cv_lib_m_clogl" >&6
17029 if test $ac_cv_lib_m_clogl = yes; then
17030
17031 cat >>confdefs.h <<\_ACEOF
17032 #define HAVE_CLOGL 1
17033 _ACEOF
17034
17035 fi
17036
17037 echo "$as_me:$LINENO: checking for log10f in -lm" >&5
17038 echo $ECHO_N "checking for log10f in -lm... $ECHO_C" >&6
17039 if test "${ac_cv_lib_m_log10f+set}" = set; then
17040   echo $ECHO_N "(cached) $ECHO_C" >&6
17041 else
17042   ac_check_lib_save_LIBS=$LIBS
17043 LIBS="-lm  $LIBS"
17044 if test x$gcc_no_link = xyes; then
17045   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17046 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17047    { (exit 1); exit 1; }; }
17048 fi
17049 cat >conftest.$ac_ext <<_ACEOF
17050 /* confdefs.h.  */
17051 _ACEOF
17052 cat confdefs.h >>conftest.$ac_ext
17053 cat >>conftest.$ac_ext <<_ACEOF
17054 /* end confdefs.h.  */
17055
17056 /* Override any gcc2 internal prototype to avoid an error.  */
17057 #ifdef __cplusplus
17058 extern "C"
17059 #endif
17060 /* We use char because int might match the return type of a gcc2
17061    builtin and then its argument prototype would still apply.  */
17062 char log10f ();
17063 int
17064 main ()
17065 {
17066 log10f ();
17067   ;
17068   return 0;
17069 }
17070 _ACEOF
17071 rm -f conftest.$ac_objext conftest$ac_exeext
17072 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17073   (eval $ac_link) 2>conftest.er1
17074   ac_status=$?
17075   grep -v '^ *+' conftest.er1 >conftest.err
17076   rm -f conftest.er1
17077   cat conftest.err >&5
17078   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17079   (exit $ac_status); } &&
17080          { ac_try='test -z "$ac_c_werror_flag"
17081                          || test ! -s conftest.err'
17082   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17083   (eval $ac_try) 2>&5
17084   ac_status=$?
17085   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17086   (exit $ac_status); }; } &&
17087          { ac_try='test -s conftest$ac_exeext'
17088   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17089   (eval $ac_try) 2>&5
17090   ac_status=$?
17091   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17092   (exit $ac_status); }; }; then
17093   ac_cv_lib_m_log10f=yes
17094 else
17095   echo "$as_me: failed program was:" >&5
17096 sed 's/^/| /' conftest.$ac_ext >&5
17097
17098 ac_cv_lib_m_log10f=no
17099 fi
17100 rm -f conftest.err conftest.$ac_objext \
17101       conftest$ac_exeext conftest.$ac_ext
17102 LIBS=$ac_check_lib_save_LIBS
17103 fi
17104 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10f" >&5
17105 echo "${ECHO_T}$ac_cv_lib_m_log10f" >&6
17106 if test $ac_cv_lib_m_log10f = yes; then
17107
17108 cat >>confdefs.h <<\_ACEOF
17109 #define HAVE_LOG10F 1
17110 _ACEOF
17111
17112 fi
17113
17114 echo "$as_me:$LINENO: checking for log10 in -lm" >&5
17115 echo $ECHO_N "checking for log10 in -lm... $ECHO_C" >&6
17116 if test "${ac_cv_lib_m_log10+set}" = set; then
17117   echo $ECHO_N "(cached) $ECHO_C" >&6
17118 else
17119   ac_check_lib_save_LIBS=$LIBS
17120 LIBS="-lm  $LIBS"
17121 if test x$gcc_no_link = xyes; then
17122   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17123 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17124    { (exit 1); exit 1; }; }
17125 fi
17126 cat >conftest.$ac_ext <<_ACEOF
17127 /* confdefs.h.  */
17128 _ACEOF
17129 cat confdefs.h >>conftest.$ac_ext
17130 cat >>conftest.$ac_ext <<_ACEOF
17131 /* end confdefs.h.  */
17132
17133 /* Override any gcc2 internal prototype to avoid an error.  */
17134 #ifdef __cplusplus
17135 extern "C"
17136 #endif
17137 /* We use char because int might match the return type of a gcc2
17138    builtin and then its argument prototype would still apply.  */
17139 char log10 ();
17140 int
17141 main ()
17142 {
17143 log10 ();
17144   ;
17145   return 0;
17146 }
17147 _ACEOF
17148 rm -f conftest.$ac_objext conftest$ac_exeext
17149 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17150   (eval $ac_link) 2>conftest.er1
17151   ac_status=$?
17152   grep -v '^ *+' conftest.er1 >conftest.err
17153   rm -f conftest.er1
17154   cat conftest.err >&5
17155   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17156   (exit $ac_status); } &&
17157          { ac_try='test -z "$ac_c_werror_flag"
17158                          || test ! -s conftest.err'
17159   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17160   (eval $ac_try) 2>&5
17161   ac_status=$?
17162   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17163   (exit $ac_status); }; } &&
17164          { ac_try='test -s conftest$ac_exeext'
17165   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17166   (eval $ac_try) 2>&5
17167   ac_status=$?
17168   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17169   (exit $ac_status); }; }; then
17170   ac_cv_lib_m_log10=yes
17171 else
17172   echo "$as_me: failed program was:" >&5
17173 sed 's/^/| /' conftest.$ac_ext >&5
17174
17175 ac_cv_lib_m_log10=no
17176 fi
17177 rm -f conftest.err conftest.$ac_objext \
17178       conftest$ac_exeext conftest.$ac_ext
17179 LIBS=$ac_check_lib_save_LIBS
17180 fi
17181 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10" >&5
17182 echo "${ECHO_T}$ac_cv_lib_m_log10" >&6
17183 if test $ac_cv_lib_m_log10 = yes; then
17184
17185 cat >>confdefs.h <<\_ACEOF
17186 #define HAVE_LOG10 1
17187 _ACEOF
17188
17189 fi
17190
17191 echo "$as_me:$LINENO: checking for log10l in -lm" >&5
17192 echo $ECHO_N "checking for log10l in -lm... $ECHO_C" >&6
17193 if test "${ac_cv_lib_m_log10l+set}" = set; then
17194   echo $ECHO_N "(cached) $ECHO_C" >&6
17195 else
17196   ac_check_lib_save_LIBS=$LIBS
17197 LIBS="-lm  $LIBS"
17198 if test x$gcc_no_link = xyes; then
17199   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17200 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17201    { (exit 1); exit 1; }; }
17202 fi
17203 cat >conftest.$ac_ext <<_ACEOF
17204 /* confdefs.h.  */
17205 _ACEOF
17206 cat confdefs.h >>conftest.$ac_ext
17207 cat >>conftest.$ac_ext <<_ACEOF
17208 /* end confdefs.h.  */
17209
17210 /* Override any gcc2 internal prototype to avoid an error.  */
17211 #ifdef __cplusplus
17212 extern "C"
17213 #endif
17214 /* We use char because int might match the return type of a gcc2
17215    builtin and then its argument prototype would still apply.  */
17216 char log10l ();
17217 int
17218 main ()
17219 {
17220 log10l ();
17221   ;
17222   return 0;
17223 }
17224 _ACEOF
17225 rm -f conftest.$ac_objext conftest$ac_exeext
17226 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17227   (eval $ac_link) 2>conftest.er1
17228   ac_status=$?
17229   grep -v '^ *+' conftest.er1 >conftest.err
17230   rm -f conftest.er1
17231   cat conftest.err >&5
17232   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17233   (exit $ac_status); } &&
17234          { ac_try='test -z "$ac_c_werror_flag"
17235                          || test ! -s conftest.err'
17236   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17237   (eval $ac_try) 2>&5
17238   ac_status=$?
17239   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17240   (exit $ac_status); }; } &&
17241          { ac_try='test -s conftest$ac_exeext'
17242   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17243   (eval $ac_try) 2>&5
17244   ac_status=$?
17245   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17246   (exit $ac_status); }; }; then
17247   ac_cv_lib_m_log10l=yes
17248 else
17249   echo "$as_me: failed program was:" >&5
17250 sed 's/^/| /' conftest.$ac_ext >&5
17251
17252 ac_cv_lib_m_log10l=no
17253 fi
17254 rm -f conftest.err conftest.$ac_objext \
17255       conftest$ac_exeext conftest.$ac_ext
17256 LIBS=$ac_check_lib_save_LIBS
17257 fi
17258 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10l" >&5
17259 echo "${ECHO_T}$ac_cv_lib_m_log10l" >&6
17260 if test $ac_cv_lib_m_log10l = yes; then
17261
17262 cat >>confdefs.h <<\_ACEOF
17263 #define HAVE_LOG10L 1
17264 _ACEOF
17265
17266 fi
17267
17268 echo "$as_me:$LINENO: checking for clog10f in -lm" >&5
17269 echo $ECHO_N "checking for clog10f in -lm... $ECHO_C" >&6
17270 if test "${ac_cv_lib_m_clog10f+set}" = set; then
17271   echo $ECHO_N "(cached) $ECHO_C" >&6
17272 else
17273   ac_check_lib_save_LIBS=$LIBS
17274 LIBS="-lm  $LIBS"
17275 if test x$gcc_no_link = xyes; then
17276   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17277 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17278    { (exit 1); exit 1; }; }
17279 fi
17280 cat >conftest.$ac_ext <<_ACEOF
17281 /* confdefs.h.  */
17282 _ACEOF
17283 cat confdefs.h >>conftest.$ac_ext
17284 cat >>conftest.$ac_ext <<_ACEOF
17285 /* end confdefs.h.  */
17286
17287 /* Override any gcc2 internal prototype to avoid an error.  */
17288 #ifdef __cplusplus
17289 extern "C"
17290 #endif
17291 /* We use char because int might match the return type of a gcc2
17292    builtin and then its argument prototype would still apply.  */
17293 char clog10f ();
17294 int
17295 main ()
17296 {
17297 clog10f ();
17298   ;
17299   return 0;
17300 }
17301 _ACEOF
17302 rm -f conftest.$ac_objext conftest$ac_exeext
17303 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17304   (eval $ac_link) 2>conftest.er1
17305   ac_status=$?
17306   grep -v '^ *+' conftest.er1 >conftest.err
17307   rm -f conftest.er1
17308   cat conftest.err >&5
17309   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17310   (exit $ac_status); } &&
17311          { ac_try='test -z "$ac_c_werror_flag"
17312                          || test ! -s conftest.err'
17313   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17314   (eval $ac_try) 2>&5
17315   ac_status=$?
17316   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17317   (exit $ac_status); }; } &&
17318          { ac_try='test -s conftest$ac_exeext'
17319   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17320   (eval $ac_try) 2>&5
17321   ac_status=$?
17322   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17323   (exit $ac_status); }; }; then
17324   ac_cv_lib_m_clog10f=yes
17325 else
17326   echo "$as_me: failed program was:" >&5
17327 sed 's/^/| /' conftest.$ac_ext >&5
17328
17329 ac_cv_lib_m_clog10f=no
17330 fi
17331 rm -f conftest.err conftest.$ac_objext \
17332       conftest$ac_exeext conftest.$ac_ext
17333 LIBS=$ac_check_lib_save_LIBS
17334 fi
17335 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10f" >&5
17336 echo "${ECHO_T}$ac_cv_lib_m_clog10f" >&6
17337 if test $ac_cv_lib_m_clog10f = yes; then
17338
17339 cat >>confdefs.h <<\_ACEOF
17340 #define HAVE_CLOG10F 1
17341 _ACEOF
17342
17343 fi
17344
17345 echo "$as_me:$LINENO: checking for clog10 in -lm" >&5
17346 echo $ECHO_N "checking for clog10 in -lm... $ECHO_C" >&6
17347 if test "${ac_cv_lib_m_clog10+set}" = set; then
17348   echo $ECHO_N "(cached) $ECHO_C" >&6
17349 else
17350   ac_check_lib_save_LIBS=$LIBS
17351 LIBS="-lm  $LIBS"
17352 if test x$gcc_no_link = xyes; then
17353   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17354 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17355    { (exit 1); exit 1; }; }
17356 fi
17357 cat >conftest.$ac_ext <<_ACEOF
17358 /* confdefs.h.  */
17359 _ACEOF
17360 cat confdefs.h >>conftest.$ac_ext
17361 cat >>conftest.$ac_ext <<_ACEOF
17362 /* end confdefs.h.  */
17363
17364 /* Override any gcc2 internal prototype to avoid an error.  */
17365 #ifdef __cplusplus
17366 extern "C"
17367 #endif
17368 /* We use char because int might match the return type of a gcc2
17369    builtin and then its argument prototype would still apply.  */
17370 char clog10 ();
17371 int
17372 main ()
17373 {
17374 clog10 ();
17375   ;
17376   return 0;
17377 }
17378 _ACEOF
17379 rm -f conftest.$ac_objext conftest$ac_exeext
17380 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17381   (eval $ac_link) 2>conftest.er1
17382   ac_status=$?
17383   grep -v '^ *+' conftest.er1 >conftest.err
17384   rm -f conftest.er1
17385   cat conftest.err >&5
17386   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17387   (exit $ac_status); } &&
17388          { ac_try='test -z "$ac_c_werror_flag"
17389                          || test ! -s conftest.err'
17390   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17391   (eval $ac_try) 2>&5
17392   ac_status=$?
17393   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17394   (exit $ac_status); }; } &&
17395          { ac_try='test -s conftest$ac_exeext'
17396   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17397   (eval $ac_try) 2>&5
17398   ac_status=$?
17399   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17400   (exit $ac_status); }; }; then
17401   ac_cv_lib_m_clog10=yes
17402 else
17403   echo "$as_me: failed program was:" >&5
17404 sed 's/^/| /' conftest.$ac_ext >&5
17405
17406 ac_cv_lib_m_clog10=no
17407 fi
17408 rm -f conftest.err conftest.$ac_objext \
17409       conftest$ac_exeext conftest.$ac_ext
17410 LIBS=$ac_check_lib_save_LIBS
17411 fi
17412 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10" >&5
17413 echo "${ECHO_T}$ac_cv_lib_m_clog10" >&6
17414 if test $ac_cv_lib_m_clog10 = yes; then
17415
17416 cat >>confdefs.h <<\_ACEOF
17417 #define HAVE_CLOG10 1
17418 _ACEOF
17419
17420 fi
17421
17422 echo "$as_me:$LINENO: checking for clog10l in -lm" >&5
17423 echo $ECHO_N "checking for clog10l in -lm... $ECHO_C" >&6
17424 if test "${ac_cv_lib_m_clog10l+set}" = set; then
17425   echo $ECHO_N "(cached) $ECHO_C" >&6
17426 else
17427   ac_check_lib_save_LIBS=$LIBS
17428 LIBS="-lm  $LIBS"
17429 if test x$gcc_no_link = xyes; then
17430   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17431 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17432    { (exit 1); exit 1; }; }
17433 fi
17434 cat >conftest.$ac_ext <<_ACEOF
17435 /* confdefs.h.  */
17436 _ACEOF
17437 cat confdefs.h >>conftest.$ac_ext
17438 cat >>conftest.$ac_ext <<_ACEOF
17439 /* end confdefs.h.  */
17440
17441 /* Override any gcc2 internal prototype to avoid an error.  */
17442 #ifdef __cplusplus
17443 extern "C"
17444 #endif
17445 /* We use char because int might match the return type of a gcc2
17446    builtin and then its argument prototype would still apply.  */
17447 char clog10l ();
17448 int
17449 main ()
17450 {
17451 clog10l ();
17452   ;
17453   return 0;
17454 }
17455 _ACEOF
17456 rm -f conftest.$ac_objext conftest$ac_exeext
17457 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17458   (eval $ac_link) 2>conftest.er1
17459   ac_status=$?
17460   grep -v '^ *+' conftest.er1 >conftest.err
17461   rm -f conftest.er1
17462   cat conftest.err >&5
17463   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17464   (exit $ac_status); } &&
17465          { ac_try='test -z "$ac_c_werror_flag"
17466                          || test ! -s conftest.err'
17467   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17468   (eval $ac_try) 2>&5
17469   ac_status=$?
17470   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17471   (exit $ac_status); }; } &&
17472          { ac_try='test -s conftest$ac_exeext'
17473   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17474   (eval $ac_try) 2>&5
17475   ac_status=$?
17476   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17477   (exit $ac_status); }; }; then
17478   ac_cv_lib_m_clog10l=yes
17479 else
17480   echo "$as_me: failed program was:" >&5
17481 sed 's/^/| /' conftest.$ac_ext >&5
17482
17483 ac_cv_lib_m_clog10l=no
17484 fi
17485 rm -f conftest.err conftest.$ac_objext \
17486       conftest$ac_exeext conftest.$ac_ext
17487 LIBS=$ac_check_lib_save_LIBS
17488 fi
17489 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10l" >&5
17490 echo "${ECHO_T}$ac_cv_lib_m_clog10l" >&6
17491 if test $ac_cv_lib_m_clog10l = yes; then
17492
17493 cat >>confdefs.h <<\_ACEOF
17494 #define HAVE_CLOG10L 1
17495 _ACEOF
17496
17497 fi
17498
17499 echo "$as_me:$LINENO: checking for nextafterf in -lm" >&5
17500 echo $ECHO_N "checking for nextafterf in -lm... $ECHO_C" >&6
17501 if test "${ac_cv_lib_m_nextafterf+set}" = set; then
17502   echo $ECHO_N "(cached) $ECHO_C" >&6
17503 else
17504   ac_check_lib_save_LIBS=$LIBS
17505 LIBS="-lm  $LIBS"
17506 if test x$gcc_no_link = xyes; then
17507   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17508 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17509    { (exit 1); exit 1; }; }
17510 fi
17511 cat >conftest.$ac_ext <<_ACEOF
17512 /* confdefs.h.  */
17513 _ACEOF
17514 cat confdefs.h >>conftest.$ac_ext
17515 cat >>conftest.$ac_ext <<_ACEOF
17516 /* end confdefs.h.  */
17517
17518 /* Override any gcc2 internal prototype to avoid an error.  */
17519 #ifdef __cplusplus
17520 extern "C"
17521 #endif
17522 /* We use char because int might match the return type of a gcc2
17523    builtin and then its argument prototype would still apply.  */
17524 char nextafterf ();
17525 int
17526 main ()
17527 {
17528 nextafterf ();
17529   ;
17530   return 0;
17531 }
17532 _ACEOF
17533 rm -f conftest.$ac_objext conftest$ac_exeext
17534 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17535   (eval $ac_link) 2>conftest.er1
17536   ac_status=$?
17537   grep -v '^ *+' conftest.er1 >conftest.err
17538   rm -f conftest.er1
17539   cat conftest.err >&5
17540   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17541   (exit $ac_status); } &&
17542          { ac_try='test -z "$ac_c_werror_flag"
17543                          || test ! -s conftest.err'
17544   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17545   (eval $ac_try) 2>&5
17546   ac_status=$?
17547   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17548   (exit $ac_status); }; } &&
17549          { ac_try='test -s conftest$ac_exeext'
17550   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17551   (eval $ac_try) 2>&5
17552   ac_status=$?
17553   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17554   (exit $ac_status); }; }; then
17555   ac_cv_lib_m_nextafterf=yes
17556 else
17557   echo "$as_me: failed program was:" >&5
17558 sed 's/^/| /' conftest.$ac_ext >&5
17559
17560 ac_cv_lib_m_nextafterf=no
17561 fi
17562 rm -f conftest.err conftest.$ac_objext \
17563       conftest$ac_exeext conftest.$ac_ext
17564 LIBS=$ac_check_lib_save_LIBS
17565 fi
17566 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafterf" >&5
17567 echo "${ECHO_T}$ac_cv_lib_m_nextafterf" >&6
17568 if test $ac_cv_lib_m_nextafterf = yes; then
17569
17570 cat >>confdefs.h <<\_ACEOF
17571 #define HAVE_NEXTAFTERF 1
17572 _ACEOF
17573
17574 fi
17575
17576 echo "$as_me:$LINENO: checking for nextafter in -lm" >&5
17577 echo $ECHO_N "checking for nextafter in -lm... $ECHO_C" >&6
17578 if test "${ac_cv_lib_m_nextafter+set}" = set; then
17579   echo $ECHO_N "(cached) $ECHO_C" >&6
17580 else
17581   ac_check_lib_save_LIBS=$LIBS
17582 LIBS="-lm  $LIBS"
17583 if test x$gcc_no_link = xyes; then
17584   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17585 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17586    { (exit 1); exit 1; }; }
17587 fi
17588 cat >conftest.$ac_ext <<_ACEOF
17589 /* confdefs.h.  */
17590 _ACEOF
17591 cat confdefs.h >>conftest.$ac_ext
17592 cat >>conftest.$ac_ext <<_ACEOF
17593 /* end confdefs.h.  */
17594
17595 /* Override any gcc2 internal prototype to avoid an error.  */
17596 #ifdef __cplusplus
17597 extern "C"
17598 #endif
17599 /* We use char because int might match the return type of a gcc2
17600    builtin and then its argument prototype would still apply.  */
17601 char nextafter ();
17602 int
17603 main ()
17604 {
17605 nextafter ();
17606   ;
17607   return 0;
17608 }
17609 _ACEOF
17610 rm -f conftest.$ac_objext conftest$ac_exeext
17611 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17612   (eval $ac_link) 2>conftest.er1
17613   ac_status=$?
17614   grep -v '^ *+' conftest.er1 >conftest.err
17615   rm -f conftest.er1
17616   cat conftest.err >&5
17617   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17618   (exit $ac_status); } &&
17619          { ac_try='test -z "$ac_c_werror_flag"
17620                          || test ! -s conftest.err'
17621   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17622   (eval $ac_try) 2>&5
17623   ac_status=$?
17624   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17625   (exit $ac_status); }; } &&
17626          { ac_try='test -s conftest$ac_exeext'
17627   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17628   (eval $ac_try) 2>&5
17629   ac_status=$?
17630   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17631   (exit $ac_status); }; }; then
17632   ac_cv_lib_m_nextafter=yes
17633 else
17634   echo "$as_me: failed program was:" >&5
17635 sed 's/^/| /' conftest.$ac_ext >&5
17636
17637 ac_cv_lib_m_nextafter=no
17638 fi
17639 rm -f conftest.err conftest.$ac_objext \
17640       conftest$ac_exeext conftest.$ac_ext
17641 LIBS=$ac_check_lib_save_LIBS
17642 fi
17643 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafter" >&5
17644 echo "${ECHO_T}$ac_cv_lib_m_nextafter" >&6
17645 if test $ac_cv_lib_m_nextafter = yes; then
17646
17647 cat >>confdefs.h <<\_ACEOF
17648 #define HAVE_NEXTAFTER 1
17649 _ACEOF
17650
17651 fi
17652
17653 echo "$as_me:$LINENO: checking for nextafterl in -lm" >&5
17654 echo $ECHO_N "checking for nextafterl in -lm... $ECHO_C" >&6
17655 if test "${ac_cv_lib_m_nextafterl+set}" = set; then
17656   echo $ECHO_N "(cached) $ECHO_C" >&6
17657 else
17658   ac_check_lib_save_LIBS=$LIBS
17659 LIBS="-lm  $LIBS"
17660 if test x$gcc_no_link = xyes; then
17661   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17662 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17663    { (exit 1); exit 1; }; }
17664 fi
17665 cat >conftest.$ac_ext <<_ACEOF
17666 /* confdefs.h.  */
17667 _ACEOF
17668 cat confdefs.h >>conftest.$ac_ext
17669 cat >>conftest.$ac_ext <<_ACEOF
17670 /* end confdefs.h.  */
17671
17672 /* Override any gcc2 internal prototype to avoid an error.  */
17673 #ifdef __cplusplus
17674 extern "C"
17675 #endif
17676 /* We use char because int might match the return type of a gcc2
17677    builtin and then its argument prototype would still apply.  */
17678 char nextafterl ();
17679 int
17680 main ()
17681 {
17682 nextafterl ();
17683   ;
17684   return 0;
17685 }
17686 _ACEOF
17687 rm -f conftest.$ac_objext conftest$ac_exeext
17688 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17689   (eval $ac_link) 2>conftest.er1
17690   ac_status=$?
17691   grep -v '^ *+' conftest.er1 >conftest.err
17692   rm -f conftest.er1
17693   cat conftest.err >&5
17694   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17695   (exit $ac_status); } &&
17696          { ac_try='test -z "$ac_c_werror_flag"
17697                          || test ! -s conftest.err'
17698   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17699   (eval $ac_try) 2>&5
17700   ac_status=$?
17701   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17702   (exit $ac_status); }; } &&
17703          { ac_try='test -s conftest$ac_exeext'
17704   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17705   (eval $ac_try) 2>&5
17706   ac_status=$?
17707   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17708   (exit $ac_status); }; }; then
17709   ac_cv_lib_m_nextafterl=yes
17710 else
17711   echo "$as_me: failed program was:" >&5
17712 sed 's/^/| /' conftest.$ac_ext >&5
17713
17714 ac_cv_lib_m_nextafterl=no
17715 fi
17716 rm -f conftest.err conftest.$ac_objext \
17717       conftest$ac_exeext conftest.$ac_ext
17718 LIBS=$ac_check_lib_save_LIBS
17719 fi
17720 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafterl" >&5
17721 echo "${ECHO_T}$ac_cv_lib_m_nextafterl" >&6
17722 if test $ac_cv_lib_m_nextafterl = yes; then
17723
17724 cat >>confdefs.h <<\_ACEOF
17725 #define HAVE_NEXTAFTERL 1
17726 _ACEOF
17727
17728 fi
17729
17730 echo "$as_me:$LINENO: checking for powf in -lm" >&5
17731 echo $ECHO_N "checking for powf in -lm... $ECHO_C" >&6
17732 if test "${ac_cv_lib_m_powf+set}" = set; then
17733   echo $ECHO_N "(cached) $ECHO_C" >&6
17734 else
17735   ac_check_lib_save_LIBS=$LIBS
17736 LIBS="-lm  $LIBS"
17737 if test x$gcc_no_link = xyes; then
17738   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17739 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17740    { (exit 1); exit 1; }; }
17741 fi
17742 cat >conftest.$ac_ext <<_ACEOF
17743 /* confdefs.h.  */
17744 _ACEOF
17745 cat confdefs.h >>conftest.$ac_ext
17746 cat >>conftest.$ac_ext <<_ACEOF
17747 /* end confdefs.h.  */
17748
17749 /* Override any gcc2 internal prototype to avoid an error.  */
17750 #ifdef __cplusplus
17751 extern "C"
17752 #endif
17753 /* We use char because int might match the return type of a gcc2
17754    builtin and then its argument prototype would still apply.  */
17755 char powf ();
17756 int
17757 main ()
17758 {
17759 powf ();
17760   ;
17761   return 0;
17762 }
17763 _ACEOF
17764 rm -f conftest.$ac_objext conftest$ac_exeext
17765 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17766   (eval $ac_link) 2>conftest.er1
17767   ac_status=$?
17768   grep -v '^ *+' conftest.er1 >conftest.err
17769   rm -f conftest.er1
17770   cat conftest.err >&5
17771   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17772   (exit $ac_status); } &&
17773          { ac_try='test -z "$ac_c_werror_flag"
17774                          || test ! -s conftest.err'
17775   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17776   (eval $ac_try) 2>&5
17777   ac_status=$?
17778   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17779   (exit $ac_status); }; } &&
17780          { ac_try='test -s conftest$ac_exeext'
17781   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17782   (eval $ac_try) 2>&5
17783   ac_status=$?
17784   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17785   (exit $ac_status); }; }; then
17786   ac_cv_lib_m_powf=yes
17787 else
17788   echo "$as_me: failed program was:" >&5
17789 sed 's/^/| /' conftest.$ac_ext >&5
17790
17791 ac_cv_lib_m_powf=no
17792 fi
17793 rm -f conftest.err conftest.$ac_objext \
17794       conftest$ac_exeext conftest.$ac_ext
17795 LIBS=$ac_check_lib_save_LIBS
17796 fi
17797 echo "$as_me:$LINENO: result: $ac_cv_lib_m_powf" >&5
17798 echo "${ECHO_T}$ac_cv_lib_m_powf" >&6
17799 if test $ac_cv_lib_m_powf = yes; then
17800
17801 cat >>confdefs.h <<\_ACEOF
17802 #define HAVE_POWF 1
17803 _ACEOF
17804
17805 fi
17806
17807 echo "$as_me:$LINENO: checking for pow in -lm" >&5
17808 echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
17809 if test "${ac_cv_lib_m_pow+set}" = set; then
17810   echo $ECHO_N "(cached) $ECHO_C" >&6
17811 else
17812   ac_check_lib_save_LIBS=$LIBS
17813 LIBS="-lm  $LIBS"
17814 if test x$gcc_no_link = xyes; then
17815   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17816 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17817    { (exit 1); exit 1; }; }
17818 fi
17819 cat >conftest.$ac_ext <<_ACEOF
17820 /* confdefs.h.  */
17821 _ACEOF
17822 cat confdefs.h >>conftest.$ac_ext
17823 cat >>conftest.$ac_ext <<_ACEOF
17824 /* end confdefs.h.  */
17825
17826 /* Override any gcc2 internal prototype to avoid an error.  */
17827 #ifdef __cplusplus
17828 extern "C"
17829 #endif
17830 /* We use char because int might match the return type of a gcc2
17831    builtin and then its argument prototype would still apply.  */
17832 char pow ();
17833 int
17834 main ()
17835 {
17836 pow ();
17837   ;
17838   return 0;
17839 }
17840 _ACEOF
17841 rm -f conftest.$ac_objext conftest$ac_exeext
17842 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17843   (eval $ac_link) 2>conftest.er1
17844   ac_status=$?
17845   grep -v '^ *+' conftest.er1 >conftest.err
17846   rm -f conftest.er1
17847   cat conftest.err >&5
17848   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17849   (exit $ac_status); } &&
17850          { ac_try='test -z "$ac_c_werror_flag"
17851                          || test ! -s conftest.err'
17852   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17853   (eval $ac_try) 2>&5
17854   ac_status=$?
17855   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17856   (exit $ac_status); }; } &&
17857          { ac_try='test -s conftest$ac_exeext'
17858   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17859   (eval $ac_try) 2>&5
17860   ac_status=$?
17861   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17862   (exit $ac_status); }; }; then
17863   ac_cv_lib_m_pow=yes
17864 else
17865   echo "$as_me: failed program was:" >&5
17866 sed 's/^/| /' conftest.$ac_ext >&5
17867
17868 ac_cv_lib_m_pow=no
17869 fi
17870 rm -f conftest.err conftest.$ac_objext \
17871       conftest$ac_exeext conftest.$ac_ext
17872 LIBS=$ac_check_lib_save_LIBS
17873 fi
17874 echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
17875 echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
17876 if test $ac_cv_lib_m_pow = yes; then
17877
17878 cat >>confdefs.h <<\_ACEOF
17879 #define HAVE_POW 1
17880 _ACEOF
17881
17882 fi
17883
17884 echo "$as_me:$LINENO: checking for powl in -lm" >&5
17885 echo $ECHO_N "checking for powl in -lm... $ECHO_C" >&6
17886 if test "${ac_cv_lib_m_powl+set}" = set; then
17887   echo $ECHO_N "(cached) $ECHO_C" >&6
17888 else
17889   ac_check_lib_save_LIBS=$LIBS
17890 LIBS="-lm  $LIBS"
17891 if test x$gcc_no_link = xyes; then
17892   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17893 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17894    { (exit 1); exit 1; }; }
17895 fi
17896 cat >conftest.$ac_ext <<_ACEOF
17897 /* confdefs.h.  */
17898 _ACEOF
17899 cat confdefs.h >>conftest.$ac_ext
17900 cat >>conftest.$ac_ext <<_ACEOF
17901 /* end confdefs.h.  */
17902
17903 /* Override any gcc2 internal prototype to avoid an error.  */
17904 #ifdef __cplusplus
17905 extern "C"
17906 #endif
17907 /* We use char because int might match the return type of a gcc2
17908    builtin and then its argument prototype would still apply.  */
17909 char powl ();
17910 int
17911 main ()
17912 {
17913 powl ();
17914   ;
17915   return 0;
17916 }
17917 _ACEOF
17918 rm -f conftest.$ac_objext conftest$ac_exeext
17919 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17920   (eval $ac_link) 2>conftest.er1
17921   ac_status=$?
17922   grep -v '^ *+' conftest.er1 >conftest.err
17923   rm -f conftest.er1
17924   cat conftest.err >&5
17925   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17926   (exit $ac_status); } &&
17927          { ac_try='test -z "$ac_c_werror_flag"
17928                          || test ! -s conftest.err'
17929   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17930   (eval $ac_try) 2>&5
17931   ac_status=$?
17932   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17933   (exit $ac_status); }; } &&
17934          { ac_try='test -s conftest$ac_exeext'
17935   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17936   (eval $ac_try) 2>&5
17937   ac_status=$?
17938   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17939   (exit $ac_status); }; }; then
17940   ac_cv_lib_m_powl=yes
17941 else
17942   echo "$as_me: failed program was:" >&5
17943 sed 's/^/| /' conftest.$ac_ext >&5
17944
17945 ac_cv_lib_m_powl=no
17946 fi
17947 rm -f conftest.err conftest.$ac_objext \
17948       conftest$ac_exeext conftest.$ac_ext
17949 LIBS=$ac_check_lib_save_LIBS
17950 fi
17951 echo "$as_me:$LINENO: result: $ac_cv_lib_m_powl" >&5
17952 echo "${ECHO_T}$ac_cv_lib_m_powl" >&6
17953 if test $ac_cv_lib_m_powl = yes; then
17954
17955 cat >>confdefs.h <<\_ACEOF
17956 #define HAVE_POWL 1
17957 _ACEOF
17958
17959 fi
17960
17961 echo "$as_me:$LINENO: checking for cpowf in -lm" >&5
17962 echo $ECHO_N "checking for cpowf in -lm... $ECHO_C" >&6
17963 if test "${ac_cv_lib_m_cpowf+set}" = set; then
17964   echo $ECHO_N "(cached) $ECHO_C" >&6
17965 else
17966   ac_check_lib_save_LIBS=$LIBS
17967 LIBS="-lm  $LIBS"
17968 if test x$gcc_no_link = xyes; then
17969   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17970 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17971    { (exit 1); exit 1; }; }
17972 fi
17973 cat >conftest.$ac_ext <<_ACEOF
17974 /* confdefs.h.  */
17975 _ACEOF
17976 cat confdefs.h >>conftest.$ac_ext
17977 cat >>conftest.$ac_ext <<_ACEOF
17978 /* end confdefs.h.  */
17979
17980 /* Override any gcc2 internal prototype to avoid an error.  */
17981 #ifdef __cplusplus
17982 extern "C"
17983 #endif
17984 /* We use char because int might match the return type of a gcc2
17985    builtin and then its argument prototype would still apply.  */
17986 char cpowf ();
17987 int
17988 main ()
17989 {
17990 cpowf ();
17991   ;
17992   return 0;
17993 }
17994 _ACEOF
17995 rm -f conftest.$ac_objext conftest$ac_exeext
17996 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17997   (eval $ac_link) 2>conftest.er1
17998   ac_status=$?
17999   grep -v '^ *+' conftest.er1 >conftest.err
18000   rm -f conftest.er1
18001   cat conftest.err >&5
18002   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18003   (exit $ac_status); } &&
18004          { ac_try='test -z "$ac_c_werror_flag"
18005                          || test ! -s conftest.err'
18006   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18007   (eval $ac_try) 2>&5
18008   ac_status=$?
18009   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18010   (exit $ac_status); }; } &&
18011          { ac_try='test -s conftest$ac_exeext'
18012   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18013   (eval $ac_try) 2>&5
18014   ac_status=$?
18015   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18016   (exit $ac_status); }; }; then
18017   ac_cv_lib_m_cpowf=yes
18018 else
18019   echo "$as_me: failed program was:" >&5
18020 sed 's/^/| /' conftest.$ac_ext >&5
18021
18022 ac_cv_lib_m_cpowf=no
18023 fi
18024 rm -f conftest.err conftest.$ac_objext \
18025       conftest$ac_exeext conftest.$ac_ext
18026 LIBS=$ac_check_lib_save_LIBS
18027 fi
18028 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpowf" >&5
18029 echo "${ECHO_T}$ac_cv_lib_m_cpowf" >&6
18030 if test $ac_cv_lib_m_cpowf = yes; then
18031
18032 cat >>confdefs.h <<\_ACEOF
18033 #define HAVE_CPOWF 1
18034 _ACEOF
18035
18036 fi
18037
18038 echo "$as_me:$LINENO: checking for cpow in -lm" >&5
18039 echo $ECHO_N "checking for cpow in -lm... $ECHO_C" >&6
18040 if test "${ac_cv_lib_m_cpow+set}" = set; then
18041   echo $ECHO_N "(cached) $ECHO_C" >&6
18042 else
18043   ac_check_lib_save_LIBS=$LIBS
18044 LIBS="-lm  $LIBS"
18045 if test x$gcc_no_link = xyes; then
18046   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18047 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18048    { (exit 1); exit 1; }; }
18049 fi
18050 cat >conftest.$ac_ext <<_ACEOF
18051 /* confdefs.h.  */
18052 _ACEOF
18053 cat confdefs.h >>conftest.$ac_ext
18054 cat >>conftest.$ac_ext <<_ACEOF
18055 /* end confdefs.h.  */
18056
18057 /* Override any gcc2 internal prototype to avoid an error.  */
18058 #ifdef __cplusplus
18059 extern "C"
18060 #endif
18061 /* We use char because int might match the return type of a gcc2
18062    builtin and then its argument prototype would still apply.  */
18063 char cpow ();
18064 int
18065 main ()
18066 {
18067 cpow ();
18068   ;
18069   return 0;
18070 }
18071 _ACEOF
18072 rm -f conftest.$ac_objext conftest$ac_exeext
18073 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18074   (eval $ac_link) 2>conftest.er1
18075   ac_status=$?
18076   grep -v '^ *+' conftest.er1 >conftest.err
18077   rm -f conftest.er1
18078   cat conftest.err >&5
18079   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18080   (exit $ac_status); } &&
18081          { ac_try='test -z "$ac_c_werror_flag"
18082                          || test ! -s conftest.err'
18083   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18084   (eval $ac_try) 2>&5
18085   ac_status=$?
18086   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18087   (exit $ac_status); }; } &&
18088          { ac_try='test -s conftest$ac_exeext'
18089   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18090   (eval $ac_try) 2>&5
18091   ac_status=$?
18092   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18093   (exit $ac_status); }; }; then
18094   ac_cv_lib_m_cpow=yes
18095 else
18096   echo "$as_me: failed program was:" >&5
18097 sed 's/^/| /' conftest.$ac_ext >&5
18098
18099 ac_cv_lib_m_cpow=no
18100 fi
18101 rm -f conftest.err conftest.$ac_objext \
18102       conftest$ac_exeext conftest.$ac_ext
18103 LIBS=$ac_check_lib_save_LIBS
18104 fi
18105 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpow" >&5
18106 echo "${ECHO_T}$ac_cv_lib_m_cpow" >&6
18107 if test $ac_cv_lib_m_cpow = yes; then
18108
18109 cat >>confdefs.h <<\_ACEOF
18110 #define HAVE_CPOW 1
18111 _ACEOF
18112
18113 fi
18114
18115 echo "$as_me:$LINENO: checking for cpowl in -lm" >&5
18116 echo $ECHO_N "checking for cpowl in -lm... $ECHO_C" >&6
18117 if test "${ac_cv_lib_m_cpowl+set}" = set; then
18118   echo $ECHO_N "(cached) $ECHO_C" >&6
18119 else
18120   ac_check_lib_save_LIBS=$LIBS
18121 LIBS="-lm  $LIBS"
18122 if test x$gcc_no_link = xyes; then
18123   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18124 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18125    { (exit 1); exit 1; }; }
18126 fi
18127 cat >conftest.$ac_ext <<_ACEOF
18128 /* confdefs.h.  */
18129 _ACEOF
18130 cat confdefs.h >>conftest.$ac_ext
18131 cat >>conftest.$ac_ext <<_ACEOF
18132 /* end confdefs.h.  */
18133
18134 /* Override any gcc2 internal prototype to avoid an error.  */
18135 #ifdef __cplusplus
18136 extern "C"
18137 #endif
18138 /* We use char because int might match the return type of a gcc2
18139    builtin and then its argument prototype would still apply.  */
18140 char cpowl ();
18141 int
18142 main ()
18143 {
18144 cpowl ();
18145   ;
18146   return 0;
18147 }
18148 _ACEOF
18149 rm -f conftest.$ac_objext conftest$ac_exeext
18150 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18151   (eval $ac_link) 2>conftest.er1
18152   ac_status=$?
18153   grep -v '^ *+' conftest.er1 >conftest.err
18154   rm -f conftest.er1
18155   cat conftest.err >&5
18156   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18157   (exit $ac_status); } &&
18158          { ac_try='test -z "$ac_c_werror_flag"
18159                          || test ! -s conftest.err'
18160   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18161   (eval $ac_try) 2>&5
18162   ac_status=$?
18163   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18164   (exit $ac_status); }; } &&
18165          { ac_try='test -s conftest$ac_exeext'
18166   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18167   (eval $ac_try) 2>&5
18168   ac_status=$?
18169   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18170   (exit $ac_status); }; }; then
18171   ac_cv_lib_m_cpowl=yes
18172 else
18173   echo "$as_me: failed program was:" >&5
18174 sed 's/^/| /' conftest.$ac_ext >&5
18175
18176 ac_cv_lib_m_cpowl=no
18177 fi
18178 rm -f conftest.err conftest.$ac_objext \
18179       conftest$ac_exeext conftest.$ac_ext
18180 LIBS=$ac_check_lib_save_LIBS
18181 fi
18182 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpowl" >&5
18183 echo "${ECHO_T}$ac_cv_lib_m_cpowl" >&6
18184 if test $ac_cv_lib_m_cpowl = yes; then
18185
18186 cat >>confdefs.h <<\_ACEOF
18187 #define HAVE_CPOWL 1
18188 _ACEOF
18189
18190 fi
18191
18192 echo "$as_me:$LINENO: checking for roundf in -lm" >&5
18193 echo $ECHO_N "checking for roundf in -lm... $ECHO_C" >&6
18194 if test "${ac_cv_lib_m_roundf+set}" = set; then
18195   echo $ECHO_N "(cached) $ECHO_C" >&6
18196 else
18197   ac_check_lib_save_LIBS=$LIBS
18198 LIBS="-lm  $LIBS"
18199 if test x$gcc_no_link = xyes; then
18200   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18201 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18202    { (exit 1); exit 1; }; }
18203 fi
18204 cat >conftest.$ac_ext <<_ACEOF
18205 /* confdefs.h.  */
18206 _ACEOF
18207 cat confdefs.h >>conftest.$ac_ext
18208 cat >>conftest.$ac_ext <<_ACEOF
18209 /* end confdefs.h.  */
18210
18211 /* Override any gcc2 internal prototype to avoid an error.  */
18212 #ifdef __cplusplus
18213 extern "C"
18214 #endif
18215 /* We use char because int might match the return type of a gcc2
18216    builtin and then its argument prototype would still apply.  */
18217 char roundf ();
18218 int
18219 main ()
18220 {
18221 roundf ();
18222   ;
18223   return 0;
18224 }
18225 _ACEOF
18226 rm -f conftest.$ac_objext conftest$ac_exeext
18227 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18228   (eval $ac_link) 2>conftest.er1
18229   ac_status=$?
18230   grep -v '^ *+' conftest.er1 >conftest.err
18231   rm -f conftest.er1
18232   cat conftest.err >&5
18233   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18234   (exit $ac_status); } &&
18235          { ac_try='test -z "$ac_c_werror_flag"
18236                          || test ! -s conftest.err'
18237   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18238   (eval $ac_try) 2>&5
18239   ac_status=$?
18240   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18241   (exit $ac_status); }; } &&
18242          { ac_try='test -s conftest$ac_exeext'
18243   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18244   (eval $ac_try) 2>&5
18245   ac_status=$?
18246   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18247   (exit $ac_status); }; }; then
18248   ac_cv_lib_m_roundf=yes
18249 else
18250   echo "$as_me: failed program was:" >&5
18251 sed 's/^/| /' conftest.$ac_ext >&5
18252
18253 ac_cv_lib_m_roundf=no
18254 fi
18255 rm -f conftest.err conftest.$ac_objext \
18256       conftest$ac_exeext conftest.$ac_ext
18257 LIBS=$ac_check_lib_save_LIBS
18258 fi
18259 echo "$as_me:$LINENO: result: $ac_cv_lib_m_roundf" >&5
18260 echo "${ECHO_T}$ac_cv_lib_m_roundf" >&6
18261 if test $ac_cv_lib_m_roundf = yes; then
18262
18263 cat >>confdefs.h <<\_ACEOF
18264 #define HAVE_ROUNDF 1
18265 _ACEOF
18266
18267 fi
18268
18269 echo "$as_me:$LINENO: checking for round in -lm" >&5
18270 echo $ECHO_N "checking for round in -lm... $ECHO_C" >&6
18271 if test "${ac_cv_lib_m_round+set}" = set; then
18272   echo $ECHO_N "(cached) $ECHO_C" >&6
18273 else
18274   ac_check_lib_save_LIBS=$LIBS
18275 LIBS="-lm  $LIBS"
18276 if test x$gcc_no_link = xyes; then
18277   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18278 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18279    { (exit 1); exit 1; }; }
18280 fi
18281 cat >conftest.$ac_ext <<_ACEOF
18282 /* confdefs.h.  */
18283 _ACEOF
18284 cat confdefs.h >>conftest.$ac_ext
18285 cat >>conftest.$ac_ext <<_ACEOF
18286 /* end confdefs.h.  */
18287
18288 /* Override any gcc2 internal prototype to avoid an error.  */
18289 #ifdef __cplusplus
18290 extern "C"
18291 #endif
18292 /* We use char because int might match the return type of a gcc2
18293    builtin and then its argument prototype would still apply.  */
18294 char round ();
18295 int
18296 main ()
18297 {
18298 round ();
18299   ;
18300   return 0;
18301 }
18302 _ACEOF
18303 rm -f conftest.$ac_objext conftest$ac_exeext
18304 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18305   (eval $ac_link) 2>conftest.er1
18306   ac_status=$?
18307   grep -v '^ *+' conftest.er1 >conftest.err
18308   rm -f conftest.er1
18309   cat conftest.err >&5
18310   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18311   (exit $ac_status); } &&
18312          { ac_try='test -z "$ac_c_werror_flag"
18313                          || test ! -s conftest.err'
18314   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18315   (eval $ac_try) 2>&5
18316   ac_status=$?
18317   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18318   (exit $ac_status); }; } &&
18319          { ac_try='test -s conftest$ac_exeext'
18320   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18321   (eval $ac_try) 2>&5
18322   ac_status=$?
18323   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18324   (exit $ac_status); }; }; then
18325   ac_cv_lib_m_round=yes
18326 else
18327   echo "$as_me: failed program was:" >&5
18328 sed 's/^/| /' conftest.$ac_ext >&5
18329
18330 ac_cv_lib_m_round=no
18331 fi
18332 rm -f conftest.err conftest.$ac_objext \
18333       conftest$ac_exeext conftest.$ac_ext
18334 LIBS=$ac_check_lib_save_LIBS
18335 fi
18336 echo "$as_me:$LINENO: result: $ac_cv_lib_m_round" >&5
18337 echo "${ECHO_T}$ac_cv_lib_m_round" >&6
18338 if test $ac_cv_lib_m_round = yes; then
18339
18340 cat >>confdefs.h <<\_ACEOF
18341 #define HAVE_ROUND 1
18342 _ACEOF
18343
18344 fi
18345
18346 echo "$as_me:$LINENO: checking for roundl in -lm" >&5
18347 echo $ECHO_N "checking for roundl in -lm... $ECHO_C" >&6
18348 if test "${ac_cv_lib_m_roundl+set}" = set; then
18349   echo $ECHO_N "(cached) $ECHO_C" >&6
18350 else
18351   ac_check_lib_save_LIBS=$LIBS
18352 LIBS="-lm  $LIBS"
18353 if test x$gcc_no_link = xyes; then
18354   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18355 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18356    { (exit 1); exit 1; }; }
18357 fi
18358 cat >conftest.$ac_ext <<_ACEOF
18359 /* confdefs.h.  */
18360 _ACEOF
18361 cat confdefs.h >>conftest.$ac_ext
18362 cat >>conftest.$ac_ext <<_ACEOF
18363 /* end confdefs.h.  */
18364
18365 /* Override any gcc2 internal prototype to avoid an error.  */
18366 #ifdef __cplusplus
18367 extern "C"
18368 #endif
18369 /* We use char because int might match the return type of a gcc2
18370    builtin and then its argument prototype would still apply.  */
18371 char roundl ();
18372 int
18373 main ()
18374 {
18375 roundl ();
18376   ;
18377   return 0;
18378 }
18379 _ACEOF
18380 rm -f conftest.$ac_objext conftest$ac_exeext
18381 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18382   (eval $ac_link) 2>conftest.er1
18383   ac_status=$?
18384   grep -v '^ *+' conftest.er1 >conftest.err
18385   rm -f conftest.er1
18386   cat conftest.err >&5
18387   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18388   (exit $ac_status); } &&
18389          { ac_try='test -z "$ac_c_werror_flag"
18390                          || test ! -s conftest.err'
18391   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18392   (eval $ac_try) 2>&5
18393   ac_status=$?
18394   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18395   (exit $ac_status); }; } &&
18396          { ac_try='test -s conftest$ac_exeext'
18397   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18398   (eval $ac_try) 2>&5
18399   ac_status=$?
18400   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18401   (exit $ac_status); }; }; then
18402   ac_cv_lib_m_roundl=yes
18403 else
18404   echo "$as_me: failed program was:" >&5
18405 sed 's/^/| /' conftest.$ac_ext >&5
18406
18407 ac_cv_lib_m_roundl=no
18408 fi
18409 rm -f conftest.err conftest.$ac_objext \
18410       conftest$ac_exeext conftest.$ac_ext
18411 LIBS=$ac_check_lib_save_LIBS
18412 fi
18413 echo "$as_me:$LINENO: result: $ac_cv_lib_m_roundl" >&5
18414 echo "${ECHO_T}$ac_cv_lib_m_roundl" >&6
18415 if test $ac_cv_lib_m_roundl = yes; then
18416
18417 cat >>confdefs.h <<\_ACEOF
18418 #define HAVE_ROUNDL 1
18419 _ACEOF
18420
18421 fi
18422
18423 echo "$as_me:$LINENO: checking for scalbnf in -lm" >&5
18424 echo $ECHO_N "checking for scalbnf in -lm... $ECHO_C" >&6
18425 if test "${ac_cv_lib_m_scalbnf+set}" = set; then
18426   echo $ECHO_N "(cached) $ECHO_C" >&6
18427 else
18428   ac_check_lib_save_LIBS=$LIBS
18429 LIBS="-lm  $LIBS"
18430 if test x$gcc_no_link = xyes; then
18431   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18432 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18433    { (exit 1); exit 1; }; }
18434 fi
18435 cat >conftest.$ac_ext <<_ACEOF
18436 /* confdefs.h.  */
18437 _ACEOF
18438 cat confdefs.h >>conftest.$ac_ext
18439 cat >>conftest.$ac_ext <<_ACEOF
18440 /* end confdefs.h.  */
18441
18442 /* Override any gcc2 internal prototype to avoid an error.  */
18443 #ifdef __cplusplus
18444 extern "C"
18445 #endif
18446 /* We use char because int might match the return type of a gcc2
18447    builtin and then its argument prototype would still apply.  */
18448 char scalbnf ();
18449 int
18450 main ()
18451 {
18452 scalbnf ();
18453   ;
18454   return 0;
18455 }
18456 _ACEOF
18457 rm -f conftest.$ac_objext conftest$ac_exeext
18458 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18459   (eval $ac_link) 2>conftest.er1
18460   ac_status=$?
18461   grep -v '^ *+' conftest.er1 >conftest.err
18462   rm -f conftest.er1
18463   cat conftest.err >&5
18464   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18465   (exit $ac_status); } &&
18466          { ac_try='test -z "$ac_c_werror_flag"
18467                          || test ! -s conftest.err'
18468   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18469   (eval $ac_try) 2>&5
18470   ac_status=$?
18471   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18472   (exit $ac_status); }; } &&
18473          { ac_try='test -s conftest$ac_exeext'
18474   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18475   (eval $ac_try) 2>&5
18476   ac_status=$?
18477   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18478   (exit $ac_status); }; }; then
18479   ac_cv_lib_m_scalbnf=yes
18480 else
18481   echo "$as_me: failed program was:" >&5
18482 sed 's/^/| /' conftest.$ac_ext >&5
18483
18484 ac_cv_lib_m_scalbnf=no
18485 fi
18486 rm -f conftest.err conftest.$ac_objext \
18487       conftest$ac_exeext conftest.$ac_ext
18488 LIBS=$ac_check_lib_save_LIBS
18489 fi
18490 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbnf" >&5
18491 echo "${ECHO_T}$ac_cv_lib_m_scalbnf" >&6
18492 if test $ac_cv_lib_m_scalbnf = yes; then
18493
18494 cat >>confdefs.h <<\_ACEOF
18495 #define HAVE_SCALBNF 1
18496 _ACEOF
18497
18498 fi
18499
18500 echo "$as_me:$LINENO: checking for scalbn in -lm" >&5
18501 echo $ECHO_N "checking for scalbn in -lm... $ECHO_C" >&6
18502 if test "${ac_cv_lib_m_scalbn+set}" = set; then
18503   echo $ECHO_N "(cached) $ECHO_C" >&6
18504 else
18505   ac_check_lib_save_LIBS=$LIBS
18506 LIBS="-lm  $LIBS"
18507 if test x$gcc_no_link = xyes; then
18508   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18509 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18510    { (exit 1); exit 1; }; }
18511 fi
18512 cat >conftest.$ac_ext <<_ACEOF
18513 /* confdefs.h.  */
18514 _ACEOF
18515 cat confdefs.h >>conftest.$ac_ext
18516 cat >>conftest.$ac_ext <<_ACEOF
18517 /* end confdefs.h.  */
18518
18519 /* Override any gcc2 internal prototype to avoid an error.  */
18520 #ifdef __cplusplus
18521 extern "C"
18522 #endif
18523 /* We use char because int might match the return type of a gcc2
18524    builtin and then its argument prototype would still apply.  */
18525 char scalbn ();
18526 int
18527 main ()
18528 {
18529 scalbn ();
18530   ;
18531   return 0;
18532 }
18533 _ACEOF
18534 rm -f conftest.$ac_objext conftest$ac_exeext
18535 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18536   (eval $ac_link) 2>conftest.er1
18537   ac_status=$?
18538   grep -v '^ *+' conftest.er1 >conftest.err
18539   rm -f conftest.er1
18540   cat conftest.err >&5
18541   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18542   (exit $ac_status); } &&
18543          { ac_try='test -z "$ac_c_werror_flag"
18544                          || test ! -s conftest.err'
18545   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18546   (eval $ac_try) 2>&5
18547   ac_status=$?
18548   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18549   (exit $ac_status); }; } &&
18550          { ac_try='test -s conftest$ac_exeext'
18551   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18552   (eval $ac_try) 2>&5
18553   ac_status=$?
18554   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18555   (exit $ac_status); }; }; then
18556   ac_cv_lib_m_scalbn=yes
18557 else
18558   echo "$as_me: failed program was:" >&5
18559 sed 's/^/| /' conftest.$ac_ext >&5
18560
18561 ac_cv_lib_m_scalbn=no
18562 fi
18563 rm -f conftest.err conftest.$ac_objext \
18564       conftest$ac_exeext conftest.$ac_ext
18565 LIBS=$ac_check_lib_save_LIBS
18566 fi
18567 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbn" >&5
18568 echo "${ECHO_T}$ac_cv_lib_m_scalbn" >&6
18569 if test $ac_cv_lib_m_scalbn = yes; then
18570
18571 cat >>confdefs.h <<\_ACEOF
18572 #define HAVE_SCALBN 1
18573 _ACEOF
18574
18575 fi
18576
18577 echo "$as_me:$LINENO: checking for scalbnl in -lm" >&5
18578 echo $ECHO_N "checking for scalbnl in -lm... $ECHO_C" >&6
18579 if test "${ac_cv_lib_m_scalbnl+set}" = set; then
18580   echo $ECHO_N "(cached) $ECHO_C" >&6
18581 else
18582   ac_check_lib_save_LIBS=$LIBS
18583 LIBS="-lm  $LIBS"
18584 if test x$gcc_no_link = xyes; then
18585   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18586 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18587    { (exit 1); exit 1; }; }
18588 fi
18589 cat >conftest.$ac_ext <<_ACEOF
18590 /* confdefs.h.  */
18591 _ACEOF
18592 cat confdefs.h >>conftest.$ac_ext
18593 cat >>conftest.$ac_ext <<_ACEOF
18594 /* end confdefs.h.  */
18595
18596 /* Override any gcc2 internal prototype to avoid an error.  */
18597 #ifdef __cplusplus
18598 extern "C"
18599 #endif
18600 /* We use char because int might match the return type of a gcc2
18601    builtin and then its argument prototype would still apply.  */
18602 char scalbnl ();
18603 int
18604 main ()
18605 {
18606 scalbnl ();
18607   ;
18608   return 0;
18609 }
18610 _ACEOF
18611 rm -f conftest.$ac_objext conftest$ac_exeext
18612 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18613   (eval $ac_link) 2>conftest.er1
18614   ac_status=$?
18615   grep -v '^ *+' conftest.er1 >conftest.err
18616   rm -f conftest.er1
18617   cat conftest.err >&5
18618   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18619   (exit $ac_status); } &&
18620          { ac_try='test -z "$ac_c_werror_flag"
18621                          || test ! -s conftest.err'
18622   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18623   (eval $ac_try) 2>&5
18624   ac_status=$?
18625   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18626   (exit $ac_status); }; } &&
18627          { ac_try='test -s conftest$ac_exeext'
18628   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18629   (eval $ac_try) 2>&5
18630   ac_status=$?
18631   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18632   (exit $ac_status); }; }; then
18633   ac_cv_lib_m_scalbnl=yes
18634 else
18635   echo "$as_me: failed program was:" >&5
18636 sed 's/^/| /' conftest.$ac_ext >&5
18637
18638 ac_cv_lib_m_scalbnl=no
18639 fi
18640 rm -f conftest.err conftest.$ac_objext \
18641       conftest$ac_exeext conftest.$ac_ext
18642 LIBS=$ac_check_lib_save_LIBS
18643 fi
18644 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbnl" >&5
18645 echo "${ECHO_T}$ac_cv_lib_m_scalbnl" >&6
18646 if test $ac_cv_lib_m_scalbnl = yes; then
18647
18648 cat >>confdefs.h <<\_ACEOF
18649 #define HAVE_SCALBNL 1
18650 _ACEOF
18651
18652 fi
18653
18654 echo "$as_me:$LINENO: checking for sinf in -lm" >&5
18655 echo $ECHO_N "checking for sinf in -lm... $ECHO_C" >&6
18656 if test "${ac_cv_lib_m_sinf+set}" = set; then
18657   echo $ECHO_N "(cached) $ECHO_C" >&6
18658 else
18659   ac_check_lib_save_LIBS=$LIBS
18660 LIBS="-lm  $LIBS"
18661 if test x$gcc_no_link = xyes; then
18662   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18663 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18664    { (exit 1); exit 1; }; }
18665 fi
18666 cat >conftest.$ac_ext <<_ACEOF
18667 /* confdefs.h.  */
18668 _ACEOF
18669 cat confdefs.h >>conftest.$ac_ext
18670 cat >>conftest.$ac_ext <<_ACEOF
18671 /* end confdefs.h.  */
18672
18673 /* Override any gcc2 internal prototype to avoid an error.  */
18674 #ifdef __cplusplus
18675 extern "C"
18676 #endif
18677 /* We use char because int might match the return type of a gcc2
18678    builtin and then its argument prototype would still apply.  */
18679 char sinf ();
18680 int
18681 main ()
18682 {
18683 sinf ();
18684   ;
18685   return 0;
18686 }
18687 _ACEOF
18688 rm -f conftest.$ac_objext conftest$ac_exeext
18689 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18690   (eval $ac_link) 2>conftest.er1
18691   ac_status=$?
18692   grep -v '^ *+' conftest.er1 >conftest.err
18693   rm -f conftest.er1
18694   cat conftest.err >&5
18695   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18696   (exit $ac_status); } &&
18697          { ac_try='test -z "$ac_c_werror_flag"
18698                          || test ! -s conftest.err'
18699   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18700   (eval $ac_try) 2>&5
18701   ac_status=$?
18702   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18703   (exit $ac_status); }; } &&
18704          { ac_try='test -s conftest$ac_exeext'
18705   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18706   (eval $ac_try) 2>&5
18707   ac_status=$?
18708   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18709   (exit $ac_status); }; }; then
18710   ac_cv_lib_m_sinf=yes
18711 else
18712   echo "$as_me: failed program was:" >&5
18713 sed 's/^/| /' conftest.$ac_ext >&5
18714
18715 ac_cv_lib_m_sinf=no
18716 fi
18717 rm -f conftest.err conftest.$ac_objext \
18718       conftest$ac_exeext conftest.$ac_ext
18719 LIBS=$ac_check_lib_save_LIBS
18720 fi
18721 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinf" >&5
18722 echo "${ECHO_T}$ac_cv_lib_m_sinf" >&6
18723 if test $ac_cv_lib_m_sinf = yes; then
18724
18725 cat >>confdefs.h <<\_ACEOF
18726 #define HAVE_SINF 1
18727 _ACEOF
18728
18729 fi
18730
18731 echo "$as_me:$LINENO: checking for sin in -lm" >&5
18732 echo $ECHO_N "checking for sin in -lm... $ECHO_C" >&6
18733 if test "${ac_cv_lib_m_sin+set}" = set; then
18734   echo $ECHO_N "(cached) $ECHO_C" >&6
18735 else
18736   ac_check_lib_save_LIBS=$LIBS
18737 LIBS="-lm  $LIBS"
18738 if test x$gcc_no_link = xyes; then
18739   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18740 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18741    { (exit 1); exit 1; }; }
18742 fi
18743 cat >conftest.$ac_ext <<_ACEOF
18744 /* confdefs.h.  */
18745 _ACEOF
18746 cat confdefs.h >>conftest.$ac_ext
18747 cat >>conftest.$ac_ext <<_ACEOF
18748 /* end confdefs.h.  */
18749
18750 /* Override any gcc2 internal prototype to avoid an error.  */
18751 #ifdef __cplusplus
18752 extern "C"
18753 #endif
18754 /* We use char because int might match the return type of a gcc2
18755    builtin and then its argument prototype would still apply.  */
18756 char sin ();
18757 int
18758 main ()
18759 {
18760 sin ();
18761   ;
18762   return 0;
18763 }
18764 _ACEOF
18765 rm -f conftest.$ac_objext conftest$ac_exeext
18766 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18767   (eval $ac_link) 2>conftest.er1
18768   ac_status=$?
18769   grep -v '^ *+' conftest.er1 >conftest.err
18770   rm -f conftest.er1
18771   cat conftest.err >&5
18772   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18773   (exit $ac_status); } &&
18774          { ac_try='test -z "$ac_c_werror_flag"
18775                          || test ! -s conftest.err'
18776   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18777   (eval $ac_try) 2>&5
18778   ac_status=$?
18779   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18780   (exit $ac_status); }; } &&
18781          { ac_try='test -s conftest$ac_exeext'
18782   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18783   (eval $ac_try) 2>&5
18784   ac_status=$?
18785   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18786   (exit $ac_status); }; }; then
18787   ac_cv_lib_m_sin=yes
18788 else
18789   echo "$as_me: failed program was:" >&5
18790 sed 's/^/| /' conftest.$ac_ext >&5
18791
18792 ac_cv_lib_m_sin=no
18793 fi
18794 rm -f conftest.err conftest.$ac_objext \
18795       conftest$ac_exeext conftest.$ac_ext
18796 LIBS=$ac_check_lib_save_LIBS
18797 fi
18798 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sin" >&5
18799 echo "${ECHO_T}$ac_cv_lib_m_sin" >&6
18800 if test $ac_cv_lib_m_sin = yes; then
18801
18802 cat >>confdefs.h <<\_ACEOF
18803 #define HAVE_SIN 1
18804 _ACEOF
18805
18806 fi
18807
18808 echo "$as_me:$LINENO: checking for sinl in -lm" >&5
18809 echo $ECHO_N "checking for sinl in -lm... $ECHO_C" >&6
18810 if test "${ac_cv_lib_m_sinl+set}" = set; then
18811   echo $ECHO_N "(cached) $ECHO_C" >&6
18812 else
18813   ac_check_lib_save_LIBS=$LIBS
18814 LIBS="-lm  $LIBS"
18815 if test x$gcc_no_link = xyes; then
18816   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18817 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18818    { (exit 1); exit 1; }; }
18819 fi
18820 cat >conftest.$ac_ext <<_ACEOF
18821 /* confdefs.h.  */
18822 _ACEOF
18823 cat confdefs.h >>conftest.$ac_ext
18824 cat >>conftest.$ac_ext <<_ACEOF
18825 /* end confdefs.h.  */
18826
18827 /* Override any gcc2 internal prototype to avoid an error.  */
18828 #ifdef __cplusplus
18829 extern "C"
18830 #endif
18831 /* We use char because int might match the return type of a gcc2
18832    builtin and then its argument prototype would still apply.  */
18833 char sinl ();
18834 int
18835 main ()
18836 {
18837 sinl ();
18838   ;
18839   return 0;
18840 }
18841 _ACEOF
18842 rm -f conftest.$ac_objext conftest$ac_exeext
18843 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18844   (eval $ac_link) 2>conftest.er1
18845   ac_status=$?
18846   grep -v '^ *+' conftest.er1 >conftest.err
18847   rm -f conftest.er1
18848   cat conftest.err >&5
18849   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18850   (exit $ac_status); } &&
18851          { ac_try='test -z "$ac_c_werror_flag"
18852                          || test ! -s conftest.err'
18853   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18854   (eval $ac_try) 2>&5
18855   ac_status=$?
18856   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18857   (exit $ac_status); }; } &&
18858          { ac_try='test -s conftest$ac_exeext'
18859   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18860   (eval $ac_try) 2>&5
18861   ac_status=$?
18862   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18863   (exit $ac_status); }; }; then
18864   ac_cv_lib_m_sinl=yes
18865 else
18866   echo "$as_me: failed program was:" >&5
18867 sed 's/^/| /' conftest.$ac_ext >&5
18868
18869 ac_cv_lib_m_sinl=no
18870 fi
18871 rm -f conftest.err conftest.$ac_objext \
18872       conftest$ac_exeext conftest.$ac_ext
18873 LIBS=$ac_check_lib_save_LIBS
18874 fi
18875 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinl" >&5
18876 echo "${ECHO_T}$ac_cv_lib_m_sinl" >&6
18877 if test $ac_cv_lib_m_sinl = yes; then
18878
18879 cat >>confdefs.h <<\_ACEOF
18880 #define HAVE_SINL 1
18881 _ACEOF
18882
18883 fi
18884
18885 echo "$as_me:$LINENO: checking for csinf in -lm" >&5
18886 echo $ECHO_N "checking for csinf in -lm... $ECHO_C" >&6
18887 if test "${ac_cv_lib_m_csinf+set}" = set; then
18888   echo $ECHO_N "(cached) $ECHO_C" >&6
18889 else
18890   ac_check_lib_save_LIBS=$LIBS
18891 LIBS="-lm  $LIBS"
18892 if test x$gcc_no_link = xyes; then
18893   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18894 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18895    { (exit 1); exit 1; }; }
18896 fi
18897 cat >conftest.$ac_ext <<_ACEOF
18898 /* confdefs.h.  */
18899 _ACEOF
18900 cat confdefs.h >>conftest.$ac_ext
18901 cat >>conftest.$ac_ext <<_ACEOF
18902 /* end confdefs.h.  */
18903
18904 /* Override any gcc2 internal prototype to avoid an error.  */
18905 #ifdef __cplusplus
18906 extern "C"
18907 #endif
18908 /* We use char because int might match the return type of a gcc2
18909    builtin and then its argument prototype would still apply.  */
18910 char csinf ();
18911 int
18912 main ()
18913 {
18914 csinf ();
18915   ;
18916   return 0;
18917 }
18918 _ACEOF
18919 rm -f conftest.$ac_objext conftest$ac_exeext
18920 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18921   (eval $ac_link) 2>conftest.er1
18922   ac_status=$?
18923   grep -v '^ *+' conftest.er1 >conftest.err
18924   rm -f conftest.er1
18925   cat conftest.err >&5
18926   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18927   (exit $ac_status); } &&
18928          { ac_try='test -z "$ac_c_werror_flag"
18929                          || test ! -s conftest.err'
18930   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18931   (eval $ac_try) 2>&5
18932   ac_status=$?
18933   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18934   (exit $ac_status); }; } &&
18935          { ac_try='test -s conftest$ac_exeext'
18936   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18937   (eval $ac_try) 2>&5
18938   ac_status=$?
18939   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18940   (exit $ac_status); }; }; then
18941   ac_cv_lib_m_csinf=yes
18942 else
18943   echo "$as_me: failed program was:" >&5
18944 sed 's/^/| /' conftest.$ac_ext >&5
18945
18946 ac_cv_lib_m_csinf=no
18947 fi
18948 rm -f conftest.err conftest.$ac_objext \
18949       conftest$ac_exeext conftest.$ac_ext
18950 LIBS=$ac_check_lib_save_LIBS
18951 fi
18952 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinf" >&5
18953 echo "${ECHO_T}$ac_cv_lib_m_csinf" >&6
18954 if test $ac_cv_lib_m_csinf = yes; then
18955
18956 cat >>confdefs.h <<\_ACEOF
18957 #define HAVE_CSINF 1
18958 _ACEOF
18959
18960 fi
18961
18962 echo "$as_me:$LINENO: checking for csin in -lm" >&5
18963 echo $ECHO_N "checking for csin in -lm... $ECHO_C" >&6
18964 if test "${ac_cv_lib_m_csin+set}" = set; then
18965   echo $ECHO_N "(cached) $ECHO_C" >&6
18966 else
18967   ac_check_lib_save_LIBS=$LIBS
18968 LIBS="-lm  $LIBS"
18969 if test x$gcc_no_link = xyes; then
18970   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18971 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18972    { (exit 1); exit 1; }; }
18973 fi
18974 cat >conftest.$ac_ext <<_ACEOF
18975 /* confdefs.h.  */
18976 _ACEOF
18977 cat confdefs.h >>conftest.$ac_ext
18978 cat >>conftest.$ac_ext <<_ACEOF
18979 /* end confdefs.h.  */
18980
18981 /* Override any gcc2 internal prototype to avoid an error.  */
18982 #ifdef __cplusplus
18983 extern "C"
18984 #endif
18985 /* We use char because int might match the return type of a gcc2
18986    builtin and then its argument prototype would still apply.  */
18987 char csin ();
18988 int
18989 main ()
18990 {
18991 csin ();
18992   ;
18993   return 0;
18994 }
18995 _ACEOF
18996 rm -f conftest.$ac_objext conftest$ac_exeext
18997 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18998   (eval $ac_link) 2>conftest.er1
18999   ac_status=$?
19000   grep -v '^ *+' conftest.er1 >conftest.err
19001   rm -f conftest.er1
19002   cat conftest.err >&5
19003   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19004   (exit $ac_status); } &&
19005          { ac_try='test -z "$ac_c_werror_flag"
19006                          || test ! -s conftest.err'
19007   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19008   (eval $ac_try) 2>&5
19009   ac_status=$?
19010   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19011   (exit $ac_status); }; } &&
19012          { ac_try='test -s conftest$ac_exeext'
19013   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19014   (eval $ac_try) 2>&5
19015   ac_status=$?
19016   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19017   (exit $ac_status); }; }; then
19018   ac_cv_lib_m_csin=yes
19019 else
19020   echo "$as_me: failed program was:" >&5
19021 sed 's/^/| /' conftest.$ac_ext >&5
19022
19023 ac_cv_lib_m_csin=no
19024 fi
19025 rm -f conftest.err conftest.$ac_objext \
19026       conftest$ac_exeext conftest.$ac_ext
19027 LIBS=$ac_check_lib_save_LIBS
19028 fi
19029 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csin" >&5
19030 echo "${ECHO_T}$ac_cv_lib_m_csin" >&6
19031 if test $ac_cv_lib_m_csin = yes; then
19032
19033 cat >>confdefs.h <<\_ACEOF
19034 #define HAVE_CSIN 1
19035 _ACEOF
19036
19037 fi
19038
19039 echo "$as_me:$LINENO: checking for csinl in -lm" >&5
19040 echo $ECHO_N "checking for csinl in -lm... $ECHO_C" >&6
19041 if test "${ac_cv_lib_m_csinl+set}" = set; then
19042   echo $ECHO_N "(cached) $ECHO_C" >&6
19043 else
19044   ac_check_lib_save_LIBS=$LIBS
19045 LIBS="-lm  $LIBS"
19046 if test x$gcc_no_link = xyes; then
19047   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19048 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19049    { (exit 1); exit 1; }; }
19050 fi
19051 cat >conftest.$ac_ext <<_ACEOF
19052 /* confdefs.h.  */
19053 _ACEOF
19054 cat confdefs.h >>conftest.$ac_ext
19055 cat >>conftest.$ac_ext <<_ACEOF
19056 /* end confdefs.h.  */
19057
19058 /* Override any gcc2 internal prototype to avoid an error.  */
19059 #ifdef __cplusplus
19060 extern "C"
19061 #endif
19062 /* We use char because int might match the return type of a gcc2
19063    builtin and then its argument prototype would still apply.  */
19064 char csinl ();
19065 int
19066 main ()
19067 {
19068 csinl ();
19069   ;
19070   return 0;
19071 }
19072 _ACEOF
19073 rm -f conftest.$ac_objext conftest$ac_exeext
19074 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19075   (eval $ac_link) 2>conftest.er1
19076   ac_status=$?
19077   grep -v '^ *+' conftest.er1 >conftest.err
19078   rm -f conftest.er1
19079   cat conftest.err >&5
19080   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19081   (exit $ac_status); } &&
19082          { ac_try='test -z "$ac_c_werror_flag"
19083                          || test ! -s conftest.err'
19084   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19085   (eval $ac_try) 2>&5
19086   ac_status=$?
19087   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19088   (exit $ac_status); }; } &&
19089          { ac_try='test -s conftest$ac_exeext'
19090   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19091   (eval $ac_try) 2>&5
19092   ac_status=$?
19093   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19094   (exit $ac_status); }; }; then
19095   ac_cv_lib_m_csinl=yes
19096 else
19097   echo "$as_me: failed program was:" >&5
19098 sed 's/^/| /' conftest.$ac_ext >&5
19099
19100 ac_cv_lib_m_csinl=no
19101 fi
19102 rm -f conftest.err conftest.$ac_objext \
19103       conftest$ac_exeext conftest.$ac_ext
19104 LIBS=$ac_check_lib_save_LIBS
19105 fi
19106 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinl" >&5
19107 echo "${ECHO_T}$ac_cv_lib_m_csinl" >&6
19108 if test $ac_cv_lib_m_csinl = yes; then
19109
19110 cat >>confdefs.h <<\_ACEOF
19111 #define HAVE_CSINL 1
19112 _ACEOF
19113
19114 fi
19115
19116 echo "$as_me:$LINENO: checking for sinhf in -lm" >&5
19117 echo $ECHO_N "checking for sinhf in -lm... $ECHO_C" >&6
19118 if test "${ac_cv_lib_m_sinhf+set}" = set; then
19119   echo $ECHO_N "(cached) $ECHO_C" >&6
19120 else
19121   ac_check_lib_save_LIBS=$LIBS
19122 LIBS="-lm  $LIBS"
19123 if test x$gcc_no_link = xyes; then
19124   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19125 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19126    { (exit 1); exit 1; }; }
19127 fi
19128 cat >conftest.$ac_ext <<_ACEOF
19129 /* confdefs.h.  */
19130 _ACEOF
19131 cat confdefs.h >>conftest.$ac_ext
19132 cat >>conftest.$ac_ext <<_ACEOF
19133 /* end confdefs.h.  */
19134
19135 /* Override any gcc2 internal prototype to avoid an error.  */
19136 #ifdef __cplusplus
19137 extern "C"
19138 #endif
19139 /* We use char because int might match the return type of a gcc2
19140    builtin and then its argument prototype would still apply.  */
19141 char sinhf ();
19142 int
19143 main ()
19144 {
19145 sinhf ();
19146   ;
19147   return 0;
19148 }
19149 _ACEOF
19150 rm -f conftest.$ac_objext conftest$ac_exeext
19151 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19152   (eval $ac_link) 2>conftest.er1
19153   ac_status=$?
19154   grep -v '^ *+' conftest.er1 >conftest.err
19155   rm -f conftest.er1
19156   cat conftest.err >&5
19157   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19158   (exit $ac_status); } &&
19159          { ac_try='test -z "$ac_c_werror_flag"
19160                          || test ! -s conftest.err'
19161   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19162   (eval $ac_try) 2>&5
19163   ac_status=$?
19164   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19165   (exit $ac_status); }; } &&
19166          { ac_try='test -s conftest$ac_exeext'
19167   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19168   (eval $ac_try) 2>&5
19169   ac_status=$?
19170   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19171   (exit $ac_status); }; }; then
19172   ac_cv_lib_m_sinhf=yes
19173 else
19174   echo "$as_me: failed program was:" >&5
19175 sed 's/^/| /' conftest.$ac_ext >&5
19176
19177 ac_cv_lib_m_sinhf=no
19178 fi
19179 rm -f conftest.err conftest.$ac_objext \
19180       conftest$ac_exeext conftest.$ac_ext
19181 LIBS=$ac_check_lib_save_LIBS
19182 fi
19183 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinhf" >&5
19184 echo "${ECHO_T}$ac_cv_lib_m_sinhf" >&6
19185 if test $ac_cv_lib_m_sinhf = yes; then
19186
19187 cat >>confdefs.h <<\_ACEOF
19188 #define HAVE_SINHF 1
19189 _ACEOF
19190
19191 fi
19192
19193 echo "$as_me:$LINENO: checking for sinh in -lm" >&5
19194 echo $ECHO_N "checking for sinh in -lm... $ECHO_C" >&6
19195 if test "${ac_cv_lib_m_sinh+set}" = set; then
19196   echo $ECHO_N "(cached) $ECHO_C" >&6
19197 else
19198   ac_check_lib_save_LIBS=$LIBS
19199 LIBS="-lm  $LIBS"
19200 if test x$gcc_no_link = xyes; then
19201   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19202 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19203    { (exit 1); exit 1; }; }
19204 fi
19205 cat >conftest.$ac_ext <<_ACEOF
19206 /* confdefs.h.  */
19207 _ACEOF
19208 cat confdefs.h >>conftest.$ac_ext
19209 cat >>conftest.$ac_ext <<_ACEOF
19210 /* end confdefs.h.  */
19211
19212 /* Override any gcc2 internal prototype to avoid an error.  */
19213 #ifdef __cplusplus
19214 extern "C"
19215 #endif
19216 /* We use char because int might match the return type of a gcc2
19217    builtin and then its argument prototype would still apply.  */
19218 char sinh ();
19219 int
19220 main ()
19221 {
19222 sinh ();
19223   ;
19224   return 0;
19225 }
19226 _ACEOF
19227 rm -f conftest.$ac_objext conftest$ac_exeext
19228 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19229   (eval $ac_link) 2>conftest.er1
19230   ac_status=$?
19231   grep -v '^ *+' conftest.er1 >conftest.err
19232   rm -f conftest.er1
19233   cat conftest.err >&5
19234   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19235   (exit $ac_status); } &&
19236          { ac_try='test -z "$ac_c_werror_flag"
19237                          || test ! -s conftest.err'
19238   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19239   (eval $ac_try) 2>&5
19240   ac_status=$?
19241   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19242   (exit $ac_status); }; } &&
19243          { ac_try='test -s conftest$ac_exeext'
19244   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19245   (eval $ac_try) 2>&5
19246   ac_status=$?
19247   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19248   (exit $ac_status); }; }; then
19249   ac_cv_lib_m_sinh=yes
19250 else
19251   echo "$as_me: failed program was:" >&5
19252 sed 's/^/| /' conftest.$ac_ext >&5
19253
19254 ac_cv_lib_m_sinh=no
19255 fi
19256 rm -f conftest.err conftest.$ac_objext \
19257       conftest$ac_exeext conftest.$ac_ext
19258 LIBS=$ac_check_lib_save_LIBS
19259 fi
19260 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinh" >&5
19261 echo "${ECHO_T}$ac_cv_lib_m_sinh" >&6
19262 if test $ac_cv_lib_m_sinh = yes; then
19263
19264 cat >>confdefs.h <<\_ACEOF
19265 #define HAVE_SINH 1
19266 _ACEOF
19267
19268 fi
19269
19270 echo "$as_me:$LINENO: checking for sinhl in -lm" >&5
19271 echo $ECHO_N "checking for sinhl in -lm... $ECHO_C" >&6
19272 if test "${ac_cv_lib_m_sinhl+set}" = set; then
19273   echo $ECHO_N "(cached) $ECHO_C" >&6
19274 else
19275   ac_check_lib_save_LIBS=$LIBS
19276 LIBS="-lm  $LIBS"
19277 if test x$gcc_no_link = xyes; then
19278   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19279 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19280    { (exit 1); exit 1; }; }
19281 fi
19282 cat >conftest.$ac_ext <<_ACEOF
19283 /* confdefs.h.  */
19284 _ACEOF
19285 cat confdefs.h >>conftest.$ac_ext
19286 cat >>conftest.$ac_ext <<_ACEOF
19287 /* end confdefs.h.  */
19288
19289 /* Override any gcc2 internal prototype to avoid an error.  */
19290 #ifdef __cplusplus
19291 extern "C"
19292 #endif
19293 /* We use char because int might match the return type of a gcc2
19294    builtin and then its argument prototype would still apply.  */
19295 char sinhl ();
19296 int
19297 main ()
19298 {
19299 sinhl ();
19300   ;
19301   return 0;
19302 }
19303 _ACEOF
19304 rm -f conftest.$ac_objext conftest$ac_exeext
19305 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19306   (eval $ac_link) 2>conftest.er1
19307   ac_status=$?
19308   grep -v '^ *+' conftest.er1 >conftest.err
19309   rm -f conftest.er1
19310   cat conftest.err >&5
19311   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19312   (exit $ac_status); } &&
19313          { ac_try='test -z "$ac_c_werror_flag"
19314                          || test ! -s conftest.err'
19315   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19316   (eval $ac_try) 2>&5
19317   ac_status=$?
19318   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19319   (exit $ac_status); }; } &&
19320          { ac_try='test -s conftest$ac_exeext'
19321   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19322   (eval $ac_try) 2>&5
19323   ac_status=$?
19324   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19325   (exit $ac_status); }; }; then
19326   ac_cv_lib_m_sinhl=yes
19327 else
19328   echo "$as_me: failed program was:" >&5
19329 sed 's/^/| /' conftest.$ac_ext >&5
19330
19331 ac_cv_lib_m_sinhl=no
19332 fi
19333 rm -f conftest.err conftest.$ac_objext \
19334       conftest$ac_exeext conftest.$ac_ext
19335 LIBS=$ac_check_lib_save_LIBS
19336 fi
19337 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinhl" >&5
19338 echo "${ECHO_T}$ac_cv_lib_m_sinhl" >&6
19339 if test $ac_cv_lib_m_sinhl = yes; then
19340
19341 cat >>confdefs.h <<\_ACEOF
19342 #define HAVE_SINHL 1
19343 _ACEOF
19344
19345 fi
19346
19347 echo "$as_me:$LINENO: checking for csinhf in -lm" >&5
19348 echo $ECHO_N "checking for csinhf in -lm... $ECHO_C" >&6
19349 if test "${ac_cv_lib_m_csinhf+set}" = set; then
19350   echo $ECHO_N "(cached) $ECHO_C" >&6
19351 else
19352   ac_check_lib_save_LIBS=$LIBS
19353 LIBS="-lm  $LIBS"
19354 if test x$gcc_no_link = xyes; then
19355   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19356 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19357    { (exit 1); exit 1; }; }
19358 fi
19359 cat >conftest.$ac_ext <<_ACEOF
19360 /* confdefs.h.  */
19361 _ACEOF
19362 cat confdefs.h >>conftest.$ac_ext
19363 cat >>conftest.$ac_ext <<_ACEOF
19364 /* end confdefs.h.  */
19365
19366 /* Override any gcc2 internal prototype to avoid an error.  */
19367 #ifdef __cplusplus
19368 extern "C"
19369 #endif
19370 /* We use char because int might match the return type of a gcc2
19371    builtin and then its argument prototype would still apply.  */
19372 char csinhf ();
19373 int
19374 main ()
19375 {
19376 csinhf ();
19377   ;
19378   return 0;
19379 }
19380 _ACEOF
19381 rm -f conftest.$ac_objext conftest$ac_exeext
19382 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19383   (eval $ac_link) 2>conftest.er1
19384   ac_status=$?
19385   grep -v '^ *+' conftest.er1 >conftest.err
19386   rm -f conftest.er1
19387   cat conftest.err >&5
19388   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19389   (exit $ac_status); } &&
19390          { ac_try='test -z "$ac_c_werror_flag"
19391                          || test ! -s conftest.err'
19392   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19393   (eval $ac_try) 2>&5
19394   ac_status=$?
19395   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19396   (exit $ac_status); }; } &&
19397          { ac_try='test -s conftest$ac_exeext'
19398   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19399   (eval $ac_try) 2>&5
19400   ac_status=$?
19401   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19402   (exit $ac_status); }; }; then
19403   ac_cv_lib_m_csinhf=yes
19404 else
19405   echo "$as_me: failed program was:" >&5
19406 sed 's/^/| /' conftest.$ac_ext >&5
19407
19408 ac_cv_lib_m_csinhf=no
19409 fi
19410 rm -f conftest.err conftest.$ac_objext \
19411       conftest$ac_exeext conftest.$ac_ext
19412 LIBS=$ac_check_lib_save_LIBS
19413 fi
19414 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinhf" >&5
19415 echo "${ECHO_T}$ac_cv_lib_m_csinhf" >&6
19416 if test $ac_cv_lib_m_csinhf = yes; then
19417
19418 cat >>confdefs.h <<\_ACEOF
19419 #define HAVE_CSINHF 1
19420 _ACEOF
19421
19422 fi
19423
19424 echo "$as_me:$LINENO: checking for csinh in -lm" >&5
19425 echo $ECHO_N "checking for csinh in -lm... $ECHO_C" >&6
19426 if test "${ac_cv_lib_m_csinh+set}" = set; then
19427   echo $ECHO_N "(cached) $ECHO_C" >&6
19428 else
19429   ac_check_lib_save_LIBS=$LIBS
19430 LIBS="-lm  $LIBS"
19431 if test x$gcc_no_link = xyes; then
19432   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19433 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19434    { (exit 1); exit 1; }; }
19435 fi
19436 cat >conftest.$ac_ext <<_ACEOF
19437 /* confdefs.h.  */
19438 _ACEOF
19439 cat confdefs.h >>conftest.$ac_ext
19440 cat >>conftest.$ac_ext <<_ACEOF
19441 /* end confdefs.h.  */
19442
19443 /* Override any gcc2 internal prototype to avoid an error.  */
19444 #ifdef __cplusplus
19445 extern "C"
19446 #endif
19447 /* We use char because int might match the return type of a gcc2
19448    builtin and then its argument prototype would still apply.  */
19449 char csinh ();
19450 int
19451 main ()
19452 {
19453 csinh ();
19454   ;
19455   return 0;
19456 }
19457 _ACEOF
19458 rm -f conftest.$ac_objext conftest$ac_exeext
19459 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19460   (eval $ac_link) 2>conftest.er1
19461   ac_status=$?
19462   grep -v '^ *+' conftest.er1 >conftest.err
19463   rm -f conftest.er1
19464   cat conftest.err >&5
19465   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19466   (exit $ac_status); } &&
19467          { ac_try='test -z "$ac_c_werror_flag"
19468                          || test ! -s conftest.err'
19469   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19470   (eval $ac_try) 2>&5
19471   ac_status=$?
19472   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19473   (exit $ac_status); }; } &&
19474          { ac_try='test -s conftest$ac_exeext'
19475   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19476   (eval $ac_try) 2>&5
19477   ac_status=$?
19478   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19479   (exit $ac_status); }; }; then
19480   ac_cv_lib_m_csinh=yes
19481 else
19482   echo "$as_me: failed program was:" >&5
19483 sed 's/^/| /' conftest.$ac_ext >&5
19484
19485 ac_cv_lib_m_csinh=no
19486 fi
19487 rm -f conftest.err conftest.$ac_objext \
19488       conftest$ac_exeext conftest.$ac_ext
19489 LIBS=$ac_check_lib_save_LIBS
19490 fi
19491 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinh" >&5
19492 echo "${ECHO_T}$ac_cv_lib_m_csinh" >&6
19493 if test $ac_cv_lib_m_csinh = yes; then
19494
19495 cat >>confdefs.h <<\_ACEOF
19496 #define HAVE_CSINH 1
19497 _ACEOF
19498
19499 fi
19500
19501 echo "$as_me:$LINENO: checking for csinhl in -lm" >&5
19502 echo $ECHO_N "checking for csinhl in -lm... $ECHO_C" >&6
19503 if test "${ac_cv_lib_m_csinhl+set}" = set; then
19504   echo $ECHO_N "(cached) $ECHO_C" >&6
19505 else
19506   ac_check_lib_save_LIBS=$LIBS
19507 LIBS="-lm  $LIBS"
19508 if test x$gcc_no_link = xyes; then
19509   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19510 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19511    { (exit 1); exit 1; }; }
19512 fi
19513 cat >conftest.$ac_ext <<_ACEOF
19514 /* confdefs.h.  */
19515 _ACEOF
19516 cat confdefs.h >>conftest.$ac_ext
19517 cat >>conftest.$ac_ext <<_ACEOF
19518 /* end confdefs.h.  */
19519
19520 /* Override any gcc2 internal prototype to avoid an error.  */
19521 #ifdef __cplusplus
19522 extern "C"
19523 #endif
19524 /* We use char because int might match the return type of a gcc2
19525    builtin and then its argument prototype would still apply.  */
19526 char csinhl ();
19527 int
19528 main ()
19529 {
19530 csinhl ();
19531   ;
19532   return 0;
19533 }
19534 _ACEOF
19535 rm -f conftest.$ac_objext conftest$ac_exeext
19536 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19537   (eval $ac_link) 2>conftest.er1
19538   ac_status=$?
19539   grep -v '^ *+' conftest.er1 >conftest.err
19540   rm -f conftest.er1
19541   cat conftest.err >&5
19542   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19543   (exit $ac_status); } &&
19544          { ac_try='test -z "$ac_c_werror_flag"
19545                          || test ! -s conftest.err'
19546   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19547   (eval $ac_try) 2>&5
19548   ac_status=$?
19549   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19550   (exit $ac_status); }; } &&
19551          { ac_try='test -s conftest$ac_exeext'
19552   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19553   (eval $ac_try) 2>&5
19554   ac_status=$?
19555   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19556   (exit $ac_status); }; }; then
19557   ac_cv_lib_m_csinhl=yes
19558 else
19559   echo "$as_me: failed program was:" >&5
19560 sed 's/^/| /' conftest.$ac_ext >&5
19561
19562 ac_cv_lib_m_csinhl=no
19563 fi
19564 rm -f conftest.err conftest.$ac_objext \
19565       conftest$ac_exeext conftest.$ac_ext
19566 LIBS=$ac_check_lib_save_LIBS
19567 fi
19568 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinhl" >&5
19569 echo "${ECHO_T}$ac_cv_lib_m_csinhl" >&6
19570 if test $ac_cv_lib_m_csinhl = yes; then
19571
19572 cat >>confdefs.h <<\_ACEOF
19573 #define HAVE_CSINHL 1
19574 _ACEOF
19575
19576 fi
19577
19578 echo "$as_me:$LINENO: checking for sqrtf in -lm" >&5
19579 echo $ECHO_N "checking for sqrtf in -lm... $ECHO_C" >&6
19580 if test "${ac_cv_lib_m_sqrtf+set}" = set; then
19581   echo $ECHO_N "(cached) $ECHO_C" >&6
19582 else
19583   ac_check_lib_save_LIBS=$LIBS
19584 LIBS="-lm  $LIBS"
19585 if test x$gcc_no_link = xyes; then
19586   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19587 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19588    { (exit 1); exit 1; }; }
19589 fi
19590 cat >conftest.$ac_ext <<_ACEOF
19591 /* confdefs.h.  */
19592 _ACEOF
19593 cat confdefs.h >>conftest.$ac_ext
19594 cat >>conftest.$ac_ext <<_ACEOF
19595 /* end confdefs.h.  */
19596
19597 /* Override any gcc2 internal prototype to avoid an error.  */
19598 #ifdef __cplusplus
19599 extern "C"
19600 #endif
19601 /* We use char because int might match the return type of a gcc2
19602    builtin and then its argument prototype would still apply.  */
19603 char sqrtf ();
19604 int
19605 main ()
19606 {
19607 sqrtf ();
19608   ;
19609   return 0;
19610 }
19611 _ACEOF
19612 rm -f conftest.$ac_objext conftest$ac_exeext
19613 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19614   (eval $ac_link) 2>conftest.er1
19615   ac_status=$?
19616   grep -v '^ *+' conftest.er1 >conftest.err
19617   rm -f conftest.er1
19618   cat conftest.err >&5
19619   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19620   (exit $ac_status); } &&
19621          { ac_try='test -z "$ac_c_werror_flag"
19622                          || test ! -s conftest.err'
19623   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19624   (eval $ac_try) 2>&5
19625   ac_status=$?
19626   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19627   (exit $ac_status); }; } &&
19628          { ac_try='test -s conftest$ac_exeext'
19629   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19630   (eval $ac_try) 2>&5
19631   ac_status=$?
19632   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19633   (exit $ac_status); }; }; then
19634   ac_cv_lib_m_sqrtf=yes
19635 else
19636   echo "$as_me: failed program was:" >&5
19637 sed 's/^/| /' conftest.$ac_ext >&5
19638
19639 ac_cv_lib_m_sqrtf=no
19640 fi
19641 rm -f conftest.err conftest.$ac_objext \
19642       conftest$ac_exeext conftest.$ac_ext
19643 LIBS=$ac_check_lib_save_LIBS
19644 fi
19645 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrtf" >&5
19646 echo "${ECHO_T}$ac_cv_lib_m_sqrtf" >&6
19647 if test $ac_cv_lib_m_sqrtf = yes; then
19648
19649 cat >>confdefs.h <<\_ACEOF
19650 #define HAVE_SQRTF 1
19651 _ACEOF
19652
19653 fi
19654
19655 echo "$as_me:$LINENO: checking for sqrt in -lm" >&5
19656 echo $ECHO_N "checking for sqrt in -lm... $ECHO_C" >&6
19657 if test "${ac_cv_lib_m_sqrt+set}" = set; then
19658   echo $ECHO_N "(cached) $ECHO_C" >&6
19659 else
19660   ac_check_lib_save_LIBS=$LIBS
19661 LIBS="-lm  $LIBS"
19662 if test x$gcc_no_link = xyes; then
19663   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19664 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19665    { (exit 1); exit 1; }; }
19666 fi
19667 cat >conftest.$ac_ext <<_ACEOF
19668 /* confdefs.h.  */
19669 _ACEOF
19670 cat confdefs.h >>conftest.$ac_ext
19671 cat >>conftest.$ac_ext <<_ACEOF
19672 /* end confdefs.h.  */
19673
19674 /* Override any gcc2 internal prototype to avoid an error.  */
19675 #ifdef __cplusplus
19676 extern "C"
19677 #endif
19678 /* We use char because int might match the return type of a gcc2
19679    builtin and then its argument prototype would still apply.  */
19680 char sqrt ();
19681 int
19682 main ()
19683 {
19684 sqrt ();
19685   ;
19686   return 0;
19687 }
19688 _ACEOF
19689 rm -f conftest.$ac_objext conftest$ac_exeext
19690 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19691   (eval $ac_link) 2>conftest.er1
19692   ac_status=$?
19693   grep -v '^ *+' conftest.er1 >conftest.err
19694   rm -f conftest.er1
19695   cat conftest.err >&5
19696   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19697   (exit $ac_status); } &&
19698          { ac_try='test -z "$ac_c_werror_flag"
19699                          || test ! -s conftest.err'
19700   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19701   (eval $ac_try) 2>&5
19702   ac_status=$?
19703   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19704   (exit $ac_status); }; } &&
19705          { ac_try='test -s conftest$ac_exeext'
19706   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19707   (eval $ac_try) 2>&5
19708   ac_status=$?
19709   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19710   (exit $ac_status); }; }; then
19711   ac_cv_lib_m_sqrt=yes
19712 else
19713   echo "$as_me: failed program was:" >&5
19714 sed 's/^/| /' conftest.$ac_ext >&5
19715
19716 ac_cv_lib_m_sqrt=no
19717 fi
19718 rm -f conftest.err conftest.$ac_objext \
19719       conftest$ac_exeext conftest.$ac_ext
19720 LIBS=$ac_check_lib_save_LIBS
19721 fi
19722 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrt" >&5
19723 echo "${ECHO_T}$ac_cv_lib_m_sqrt" >&6
19724 if test $ac_cv_lib_m_sqrt = yes; then
19725
19726 cat >>confdefs.h <<\_ACEOF
19727 #define HAVE_SQRT 1
19728 _ACEOF
19729
19730 fi
19731
19732 echo "$as_me:$LINENO: checking for sqrtl in -lm" >&5
19733 echo $ECHO_N "checking for sqrtl in -lm... $ECHO_C" >&6
19734 if test "${ac_cv_lib_m_sqrtl+set}" = set; then
19735   echo $ECHO_N "(cached) $ECHO_C" >&6
19736 else
19737   ac_check_lib_save_LIBS=$LIBS
19738 LIBS="-lm  $LIBS"
19739 if test x$gcc_no_link = xyes; then
19740   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19741 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19742    { (exit 1); exit 1; }; }
19743 fi
19744 cat >conftest.$ac_ext <<_ACEOF
19745 /* confdefs.h.  */
19746 _ACEOF
19747 cat confdefs.h >>conftest.$ac_ext
19748 cat >>conftest.$ac_ext <<_ACEOF
19749 /* end confdefs.h.  */
19750
19751 /* Override any gcc2 internal prototype to avoid an error.  */
19752 #ifdef __cplusplus
19753 extern "C"
19754 #endif
19755 /* We use char because int might match the return type of a gcc2
19756    builtin and then its argument prototype would still apply.  */
19757 char sqrtl ();
19758 int
19759 main ()
19760 {
19761 sqrtl ();
19762   ;
19763   return 0;
19764 }
19765 _ACEOF
19766 rm -f conftest.$ac_objext conftest$ac_exeext
19767 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19768   (eval $ac_link) 2>conftest.er1
19769   ac_status=$?
19770   grep -v '^ *+' conftest.er1 >conftest.err
19771   rm -f conftest.er1
19772   cat conftest.err >&5
19773   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19774   (exit $ac_status); } &&
19775          { ac_try='test -z "$ac_c_werror_flag"
19776                          || test ! -s conftest.err'
19777   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19778   (eval $ac_try) 2>&5
19779   ac_status=$?
19780   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19781   (exit $ac_status); }; } &&
19782          { ac_try='test -s conftest$ac_exeext'
19783   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19784   (eval $ac_try) 2>&5
19785   ac_status=$?
19786   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19787   (exit $ac_status); }; }; then
19788   ac_cv_lib_m_sqrtl=yes
19789 else
19790   echo "$as_me: failed program was:" >&5
19791 sed 's/^/| /' conftest.$ac_ext >&5
19792
19793 ac_cv_lib_m_sqrtl=no
19794 fi
19795 rm -f conftest.err conftest.$ac_objext \
19796       conftest$ac_exeext conftest.$ac_ext
19797 LIBS=$ac_check_lib_save_LIBS
19798 fi
19799 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrtl" >&5
19800 echo "${ECHO_T}$ac_cv_lib_m_sqrtl" >&6
19801 if test $ac_cv_lib_m_sqrtl = yes; then
19802
19803 cat >>confdefs.h <<\_ACEOF
19804 #define HAVE_SQRTL 1
19805 _ACEOF
19806
19807 fi
19808
19809 echo "$as_me:$LINENO: checking for csqrtf in -lm" >&5
19810 echo $ECHO_N "checking for csqrtf in -lm... $ECHO_C" >&6
19811 if test "${ac_cv_lib_m_csqrtf+set}" = set; then
19812   echo $ECHO_N "(cached) $ECHO_C" >&6
19813 else
19814   ac_check_lib_save_LIBS=$LIBS
19815 LIBS="-lm  $LIBS"
19816 if test x$gcc_no_link = xyes; then
19817   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19818 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19819    { (exit 1); exit 1; }; }
19820 fi
19821 cat >conftest.$ac_ext <<_ACEOF
19822 /* confdefs.h.  */
19823 _ACEOF
19824 cat confdefs.h >>conftest.$ac_ext
19825 cat >>conftest.$ac_ext <<_ACEOF
19826 /* end confdefs.h.  */
19827
19828 /* Override any gcc2 internal prototype to avoid an error.  */
19829 #ifdef __cplusplus
19830 extern "C"
19831 #endif
19832 /* We use char because int might match the return type of a gcc2
19833    builtin and then its argument prototype would still apply.  */
19834 char csqrtf ();
19835 int
19836 main ()
19837 {
19838 csqrtf ();
19839   ;
19840   return 0;
19841 }
19842 _ACEOF
19843 rm -f conftest.$ac_objext conftest$ac_exeext
19844 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19845   (eval $ac_link) 2>conftest.er1
19846   ac_status=$?
19847   grep -v '^ *+' conftest.er1 >conftest.err
19848   rm -f conftest.er1
19849   cat conftest.err >&5
19850   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19851   (exit $ac_status); } &&
19852          { ac_try='test -z "$ac_c_werror_flag"
19853                          || test ! -s conftest.err'
19854   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19855   (eval $ac_try) 2>&5
19856   ac_status=$?
19857   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19858   (exit $ac_status); }; } &&
19859          { ac_try='test -s conftest$ac_exeext'
19860   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19861   (eval $ac_try) 2>&5
19862   ac_status=$?
19863   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19864   (exit $ac_status); }; }; then
19865   ac_cv_lib_m_csqrtf=yes
19866 else
19867   echo "$as_me: failed program was:" >&5
19868 sed 's/^/| /' conftest.$ac_ext >&5
19869
19870 ac_cv_lib_m_csqrtf=no
19871 fi
19872 rm -f conftest.err conftest.$ac_objext \
19873       conftest$ac_exeext conftest.$ac_ext
19874 LIBS=$ac_check_lib_save_LIBS
19875 fi
19876 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrtf" >&5
19877 echo "${ECHO_T}$ac_cv_lib_m_csqrtf" >&6
19878 if test $ac_cv_lib_m_csqrtf = yes; then
19879
19880 cat >>confdefs.h <<\_ACEOF
19881 #define HAVE_CSQRTF 1
19882 _ACEOF
19883
19884 fi
19885
19886 echo "$as_me:$LINENO: checking for csqrt in -lm" >&5
19887 echo $ECHO_N "checking for csqrt in -lm... $ECHO_C" >&6
19888 if test "${ac_cv_lib_m_csqrt+set}" = set; then
19889   echo $ECHO_N "(cached) $ECHO_C" >&6
19890 else
19891   ac_check_lib_save_LIBS=$LIBS
19892 LIBS="-lm  $LIBS"
19893 if test x$gcc_no_link = xyes; then
19894   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19895 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19896    { (exit 1); exit 1; }; }
19897 fi
19898 cat >conftest.$ac_ext <<_ACEOF
19899 /* confdefs.h.  */
19900 _ACEOF
19901 cat confdefs.h >>conftest.$ac_ext
19902 cat >>conftest.$ac_ext <<_ACEOF
19903 /* end confdefs.h.  */
19904
19905 /* Override any gcc2 internal prototype to avoid an error.  */
19906 #ifdef __cplusplus
19907 extern "C"
19908 #endif
19909 /* We use char because int might match the return type of a gcc2
19910    builtin and then its argument prototype would still apply.  */
19911 char csqrt ();
19912 int
19913 main ()
19914 {
19915 csqrt ();
19916   ;
19917   return 0;
19918 }
19919 _ACEOF
19920 rm -f conftest.$ac_objext conftest$ac_exeext
19921 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19922   (eval $ac_link) 2>conftest.er1
19923   ac_status=$?
19924   grep -v '^ *+' conftest.er1 >conftest.err
19925   rm -f conftest.er1
19926   cat conftest.err >&5
19927   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19928   (exit $ac_status); } &&
19929          { ac_try='test -z "$ac_c_werror_flag"
19930                          || test ! -s conftest.err'
19931   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19932   (eval $ac_try) 2>&5
19933   ac_status=$?
19934   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19935   (exit $ac_status); }; } &&
19936          { ac_try='test -s conftest$ac_exeext'
19937   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19938   (eval $ac_try) 2>&5
19939   ac_status=$?
19940   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19941   (exit $ac_status); }; }; then
19942   ac_cv_lib_m_csqrt=yes
19943 else
19944   echo "$as_me: failed program was:" >&5
19945 sed 's/^/| /' conftest.$ac_ext >&5
19946
19947 ac_cv_lib_m_csqrt=no
19948 fi
19949 rm -f conftest.err conftest.$ac_objext \
19950       conftest$ac_exeext conftest.$ac_ext
19951 LIBS=$ac_check_lib_save_LIBS
19952 fi
19953 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrt" >&5
19954 echo "${ECHO_T}$ac_cv_lib_m_csqrt" >&6
19955 if test $ac_cv_lib_m_csqrt = yes; then
19956
19957 cat >>confdefs.h <<\_ACEOF
19958 #define HAVE_CSQRT 1
19959 _ACEOF
19960
19961 fi
19962
19963 echo "$as_me:$LINENO: checking for csqrtl in -lm" >&5
19964 echo $ECHO_N "checking for csqrtl in -lm... $ECHO_C" >&6
19965 if test "${ac_cv_lib_m_csqrtl+set}" = set; then
19966   echo $ECHO_N "(cached) $ECHO_C" >&6
19967 else
19968   ac_check_lib_save_LIBS=$LIBS
19969 LIBS="-lm  $LIBS"
19970 if test x$gcc_no_link = xyes; then
19971   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19972 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19973    { (exit 1); exit 1; }; }
19974 fi
19975 cat >conftest.$ac_ext <<_ACEOF
19976 /* confdefs.h.  */
19977 _ACEOF
19978 cat confdefs.h >>conftest.$ac_ext
19979 cat >>conftest.$ac_ext <<_ACEOF
19980 /* end confdefs.h.  */
19981
19982 /* Override any gcc2 internal prototype to avoid an error.  */
19983 #ifdef __cplusplus
19984 extern "C"
19985 #endif
19986 /* We use char because int might match the return type of a gcc2
19987    builtin and then its argument prototype would still apply.  */
19988 char csqrtl ();
19989 int
19990 main ()
19991 {
19992 csqrtl ();
19993   ;
19994   return 0;
19995 }
19996 _ACEOF
19997 rm -f conftest.$ac_objext conftest$ac_exeext
19998 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19999   (eval $ac_link) 2>conftest.er1
20000   ac_status=$?
20001   grep -v '^ *+' conftest.er1 >conftest.err
20002   rm -f conftest.er1
20003   cat conftest.err >&5
20004   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20005   (exit $ac_status); } &&
20006          { ac_try='test -z "$ac_c_werror_flag"
20007                          || test ! -s conftest.err'
20008   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20009   (eval $ac_try) 2>&5
20010   ac_status=$?
20011   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20012   (exit $ac_status); }; } &&
20013          { ac_try='test -s conftest$ac_exeext'
20014   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20015   (eval $ac_try) 2>&5
20016   ac_status=$?
20017   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20018   (exit $ac_status); }; }; then
20019   ac_cv_lib_m_csqrtl=yes
20020 else
20021   echo "$as_me: failed program was:" >&5
20022 sed 's/^/| /' conftest.$ac_ext >&5
20023
20024 ac_cv_lib_m_csqrtl=no
20025 fi
20026 rm -f conftest.err conftest.$ac_objext \
20027       conftest$ac_exeext conftest.$ac_ext
20028 LIBS=$ac_check_lib_save_LIBS
20029 fi
20030 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrtl" >&5
20031 echo "${ECHO_T}$ac_cv_lib_m_csqrtl" >&6
20032 if test $ac_cv_lib_m_csqrtl = yes; then
20033
20034 cat >>confdefs.h <<\_ACEOF
20035 #define HAVE_CSQRTL 1
20036 _ACEOF
20037
20038 fi
20039
20040 echo "$as_me:$LINENO: checking for tanf in -lm" >&5
20041 echo $ECHO_N "checking for tanf in -lm... $ECHO_C" >&6
20042 if test "${ac_cv_lib_m_tanf+set}" = set; then
20043   echo $ECHO_N "(cached) $ECHO_C" >&6
20044 else
20045   ac_check_lib_save_LIBS=$LIBS
20046 LIBS="-lm  $LIBS"
20047 if test x$gcc_no_link = xyes; then
20048   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20049 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20050    { (exit 1); exit 1; }; }
20051 fi
20052 cat >conftest.$ac_ext <<_ACEOF
20053 /* confdefs.h.  */
20054 _ACEOF
20055 cat confdefs.h >>conftest.$ac_ext
20056 cat >>conftest.$ac_ext <<_ACEOF
20057 /* end confdefs.h.  */
20058
20059 /* Override any gcc2 internal prototype to avoid an error.  */
20060 #ifdef __cplusplus
20061 extern "C"
20062 #endif
20063 /* We use char because int might match the return type of a gcc2
20064    builtin and then its argument prototype would still apply.  */
20065 char tanf ();
20066 int
20067 main ()
20068 {
20069 tanf ();
20070   ;
20071   return 0;
20072 }
20073 _ACEOF
20074 rm -f conftest.$ac_objext conftest$ac_exeext
20075 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20076   (eval $ac_link) 2>conftest.er1
20077   ac_status=$?
20078   grep -v '^ *+' conftest.er1 >conftest.err
20079   rm -f conftest.er1
20080   cat conftest.err >&5
20081   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20082   (exit $ac_status); } &&
20083          { ac_try='test -z "$ac_c_werror_flag"
20084                          || test ! -s conftest.err'
20085   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20086   (eval $ac_try) 2>&5
20087   ac_status=$?
20088   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20089   (exit $ac_status); }; } &&
20090          { ac_try='test -s conftest$ac_exeext'
20091   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20092   (eval $ac_try) 2>&5
20093   ac_status=$?
20094   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20095   (exit $ac_status); }; }; then
20096   ac_cv_lib_m_tanf=yes
20097 else
20098   echo "$as_me: failed program was:" >&5
20099 sed 's/^/| /' conftest.$ac_ext >&5
20100
20101 ac_cv_lib_m_tanf=no
20102 fi
20103 rm -f conftest.err conftest.$ac_objext \
20104       conftest$ac_exeext conftest.$ac_ext
20105 LIBS=$ac_check_lib_save_LIBS
20106 fi
20107 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanf" >&5
20108 echo "${ECHO_T}$ac_cv_lib_m_tanf" >&6
20109 if test $ac_cv_lib_m_tanf = yes; then
20110
20111 cat >>confdefs.h <<\_ACEOF
20112 #define HAVE_TANF 1
20113 _ACEOF
20114
20115 fi
20116
20117 echo "$as_me:$LINENO: checking for tan in -lm" >&5
20118 echo $ECHO_N "checking for tan in -lm... $ECHO_C" >&6
20119 if test "${ac_cv_lib_m_tan+set}" = set; then
20120   echo $ECHO_N "(cached) $ECHO_C" >&6
20121 else
20122   ac_check_lib_save_LIBS=$LIBS
20123 LIBS="-lm  $LIBS"
20124 if test x$gcc_no_link = xyes; then
20125   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20126 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20127    { (exit 1); exit 1; }; }
20128 fi
20129 cat >conftest.$ac_ext <<_ACEOF
20130 /* confdefs.h.  */
20131 _ACEOF
20132 cat confdefs.h >>conftest.$ac_ext
20133 cat >>conftest.$ac_ext <<_ACEOF
20134 /* end confdefs.h.  */
20135
20136 /* Override any gcc2 internal prototype to avoid an error.  */
20137 #ifdef __cplusplus
20138 extern "C"
20139 #endif
20140 /* We use char because int might match the return type of a gcc2
20141    builtin and then its argument prototype would still apply.  */
20142 char tan ();
20143 int
20144 main ()
20145 {
20146 tan ();
20147   ;
20148   return 0;
20149 }
20150 _ACEOF
20151 rm -f conftest.$ac_objext conftest$ac_exeext
20152 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20153   (eval $ac_link) 2>conftest.er1
20154   ac_status=$?
20155   grep -v '^ *+' conftest.er1 >conftest.err
20156   rm -f conftest.er1
20157   cat conftest.err >&5
20158   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20159   (exit $ac_status); } &&
20160          { ac_try='test -z "$ac_c_werror_flag"
20161                          || test ! -s conftest.err'
20162   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20163   (eval $ac_try) 2>&5
20164   ac_status=$?
20165   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20166   (exit $ac_status); }; } &&
20167          { ac_try='test -s conftest$ac_exeext'
20168   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20169   (eval $ac_try) 2>&5
20170   ac_status=$?
20171   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20172   (exit $ac_status); }; }; then
20173   ac_cv_lib_m_tan=yes
20174 else
20175   echo "$as_me: failed program was:" >&5
20176 sed 's/^/| /' conftest.$ac_ext >&5
20177
20178 ac_cv_lib_m_tan=no
20179 fi
20180 rm -f conftest.err conftest.$ac_objext \
20181       conftest$ac_exeext conftest.$ac_ext
20182 LIBS=$ac_check_lib_save_LIBS
20183 fi
20184 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tan" >&5
20185 echo "${ECHO_T}$ac_cv_lib_m_tan" >&6
20186 if test $ac_cv_lib_m_tan = yes; then
20187
20188 cat >>confdefs.h <<\_ACEOF
20189 #define HAVE_TAN 1
20190 _ACEOF
20191
20192 fi
20193
20194 echo "$as_me:$LINENO: checking for tanl in -lm" >&5
20195 echo $ECHO_N "checking for tanl in -lm... $ECHO_C" >&6
20196 if test "${ac_cv_lib_m_tanl+set}" = set; then
20197   echo $ECHO_N "(cached) $ECHO_C" >&6
20198 else
20199   ac_check_lib_save_LIBS=$LIBS
20200 LIBS="-lm  $LIBS"
20201 if test x$gcc_no_link = xyes; then
20202   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20203 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20204    { (exit 1); exit 1; }; }
20205 fi
20206 cat >conftest.$ac_ext <<_ACEOF
20207 /* confdefs.h.  */
20208 _ACEOF
20209 cat confdefs.h >>conftest.$ac_ext
20210 cat >>conftest.$ac_ext <<_ACEOF
20211 /* end confdefs.h.  */
20212
20213 /* Override any gcc2 internal prototype to avoid an error.  */
20214 #ifdef __cplusplus
20215 extern "C"
20216 #endif
20217 /* We use char because int might match the return type of a gcc2
20218    builtin and then its argument prototype would still apply.  */
20219 char tanl ();
20220 int
20221 main ()
20222 {
20223 tanl ();
20224   ;
20225   return 0;
20226 }
20227 _ACEOF
20228 rm -f conftest.$ac_objext conftest$ac_exeext
20229 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20230   (eval $ac_link) 2>conftest.er1
20231   ac_status=$?
20232   grep -v '^ *+' conftest.er1 >conftest.err
20233   rm -f conftest.er1
20234   cat conftest.err >&5
20235   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20236   (exit $ac_status); } &&
20237          { ac_try='test -z "$ac_c_werror_flag"
20238                          || test ! -s conftest.err'
20239   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20240   (eval $ac_try) 2>&5
20241   ac_status=$?
20242   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20243   (exit $ac_status); }; } &&
20244          { ac_try='test -s conftest$ac_exeext'
20245   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20246   (eval $ac_try) 2>&5
20247   ac_status=$?
20248   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20249   (exit $ac_status); }; }; then
20250   ac_cv_lib_m_tanl=yes
20251 else
20252   echo "$as_me: failed program was:" >&5
20253 sed 's/^/| /' conftest.$ac_ext >&5
20254
20255 ac_cv_lib_m_tanl=no
20256 fi
20257 rm -f conftest.err conftest.$ac_objext \
20258       conftest$ac_exeext conftest.$ac_ext
20259 LIBS=$ac_check_lib_save_LIBS
20260 fi
20261 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanl" >&5
20262 echo "${ECHO_T}$ac_cv_lib_m_tanl" >&6
20263 if test $ac_cv_lib_m_tanl = yes; then
20264
20265 cat >>confdefs.h <<\_ACEOF
20266 #define HAVE_TANL 1
20267 _ACEOF
20268
20269 fi
20270
20271 echo "$as_me:$LINENO: checking for ctanf in -lm" >&5
20272 echo $ECHO_N "checking for ctanf in -lm... $ECHO_C" >&6
20273 if test "${ac_cv_lib_m_ctanf+set}" = set; then
20274   echo $ECHO_N "(cached) $ECHO_C" >&6
20275 else
20276   ac_check_lib_save_LIBS=$LIBS
20277 LIBS="-lm  $LIBS"
20278 if test x$gcc_no_link = xyes; then
20279   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20280 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20281    { (exit 1); exit 1; }; }
20282 fi
20283 cat >conftest.$ac_ext <<_ACEOF
20284 /* confdefs.h.  */
20285 _ACEOF
20286 cat confdefs.h >>conftest.$ac_ext
20287 cat >>conftest.$ac_ext <<_ACEOF
20288 /* end confdefs.h.  */
20289
20290 /* Override any gcc2 internal prototype to avoid an error.  */
20291 #ifdef __cplusplus
20292 extern "C"
20293 #endif
20294 /* We use char because int might match the return type of a gcc2
20295    builtin and then its argument prototype would still apply.  */
20296 char ctanf ();
20297 int
20298 main ()
20299 {
20300 ctanf ();
20301   ;
20302   return 0;
20303 }
20304 _ACEOF
20305 rm -f conftest.$ac_objext conftest$ac_exeext
20306 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20307   (eval $ac_link) 2>conftest.er1
20308   ac_status=$?
20309   grep -v '^ *+' conftest.er1 >conftest.err
20310   rm -f conftest.er1
20311   cat conftest.err >&5
20312   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20313   (exit $ac_status); } &&
20314          { ac_try='test -z "$ac_c_werror_flag"
20315                          || test ! -s conftest.err'
20316   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20317   (eval $ac_try) 2>&5
20318   ac_status=$?
20319   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20320   (exit $ac_status); }; } &&
20321          { ac_try='test -s conftest$ac_exeext'
20322   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20323   (eval $ac_try) 2>&5
20324   ac_status=$?
20325   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20326   (exit $ac_status); }; }; then
20327   ac_cv_lib_m_ctanf=yes
20328 else
20329   echo "$as_me: failed program was:" >&5
20330 sed 's/^/| /' conftest.$ac_ext >&5
20331
20332 ac_cv_lib_m_ctanf=no
20333 fi
20334 rm -f conftest.err conftest.$ac_objext \
20335       conftest$ac_exeext conftest.$ac_ext
20336 LIBS=$ac_check_lib_save_LIBS
20337 fi
20338 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanf" >&5
20339 echo "${ECHO_T}$ac_cv_lib_m_ctanf" >&6
20340 if test $ac_cv_lib_m_ctanf = yes; then
20341
20342 cat >>confdefs.h <<\_ACEOF
20343 #define HAVE_CTANF 1
20344 _ACEOF
20345
20346 fi
20347
20348 echo "$as_me:$LINENO: checking for ctan in -lm" >&5
20349 echo $ECHO_N "checking for ctan in -lm... $ECHO_C" >&6
20350 if test "${ac_cv_lib_m_ctan+set}" = set; then
20351   echo $ECHO_N "(cached) $ECHO_C" >&6
20352 else
20353   ac_check_lib_save_LIBS=$LIBS
20354 LIBS="-lm  $LIBS"
20355 if test x$gcc_no_link = xyes; then
20356   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20357 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20358    { (exit 1); exit 1; }; }
20359 fi
20360 cat >conftest.$ac_ext <<_ACEOF
20361 /* confdefs.h.  */
20362 _ACEOF
20363 cat confdefs.h >>conftest.$ac_ext
20364 cat >>conftest.$ac_ext <<_ACEOF
20365 /* end confdefs.h.  */
20366
20367 /* Override any gcc2 internal prototype to avoid an error.  */
20368 #ifdef __cplusplus
20369 extern "C"
20370 #endif
20371 /* We use char because int might match the return type of a gcc2
20372    builtin and then its argument prototype would still apply.  */
20373 char ctan ();
20374 int
20375 main ()
20376 {
20377 ctan ();
20378   ;
20379   return 0;
20380 }
20381 _ACEOF
20382 rm -f conftest.$ac_objext conftest$ac_exeext
20383 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20384   (eval $ac_link) 2>conftest.er1
20385   ac_status=$?
20386   grep -v '^ *+' conftest.er1 >conftest.err
20387   rm -f conftest.er1
20388   cat conftest.err >&5
20389   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20390   (exit $ac_status); } &&
20391          { ac_try='test -z "$ac_c_werror_flag"
20392                          || test ! -s conftest.err'
20393   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20394   (eval $ac_try) 2>&5
20395   ac_status=$?
20396   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20397   (exit $ac_status); }; } &&
20398          { ac_try='test -s conftest$ac_exeext'
20399   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20400   (eval $ac_try) 2>&5
20401   ac_status=$?
20402   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20403   (exit $ac_status); }; }; then
20404   ac_cv_lib_m_ctan=yes
20405 else
20406   echo "$as_me: failed program was:" >&5
20407 sed 's/^/| /' conftest.$ac_ext >&5
20408
20409 ac_cv_lib_m_ctan=no
20410 fi
20411 rm -f conftest.err conftest.$ac_objext \
20412       conftest$ac_exeext conftest.$ac_ext
20413 LIBS=$ac_check_lib_save_LIBS
20414 fi
20415 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctan" >&5
20416 echo "${ECHO_T}$ac_cv_lib_m_ctan" >&6
20417 if test $ac_cv_lib_m_ctan = yes; then
20418
20419 cat >>confdefs.h <<\_ACEOF
20420 #define HAVE_CTAN 1
20421 _ACEOF
20422
20423 fi
20424
20425 echo "$as_me:$LINENO: checking for ctanl in -lm" >&5
20426 echo $ECHO_N "checking for ctanl in -lm... $ECHO_C" >&6
20427 if test "${ac_cv_lib_m_ctanl+set}" = set; then
20428   echo $ECHO_N "(cached) $ECHO_C" >&6
20429 else
20430   ac_check_lib_save_LIBS=$LIBS
20431 LIBS="-lm  $LIBS"
20432 if test x$gcc_no_link = xyes; then
20433   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20434 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20435    { (exit 1); exit 1; }; }
20436 fi
20437 cat >conftest.$ac_ext <<_ACEOF
20438 /* confdefs.h.  */
20439 _ACEOF
20440 cat confdefs.h >>conftest.$ac_ext
20441 cat >>conftest.$ac_ext <<_ACEOF
20442 /* end confdefs.h.  */
20443
20444 /* Override any gcc2 internal prototype to avoid an error.  */
20445 #ifdef __cplusplus
20446 extern "C"
20447 #endif
20448 /* We use char because int might match the return type of a gcc2
20449    builtin and then its argument prototype would still apply.  */
20450 char ctanl ();
20451 int
20452 main ()
20453 {
20454 ctanl ();
20455   ;
20456   return 0;
20457 }
20458 _ACEOF
20459 rm -f conftest.$ac_objext conftest$ac_exeext
20460 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20461   (eval $ac_link) 2>conftest.er1
20462   ac_status=$?
20463   grep -v '^ *+' conftest.er1 >conftest.err
20464   rm -f conftest.er1
20465   cat conftest.err >&5
20466   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20467   (exit $ac_status); } &&
20468          { ac_try='test -z "$ac_c_werror_flag"
20469                          || test ! -s conftest.err'
20470   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20471   (eval $ac_try) 2>&5
20472   ac_status=$?
20473   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20474   (exit $ac_status); }; } &&
20475          { ac_try='test -s conftest$ac_exeext'
20476   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20477   (eval $ac_try) 2>&5
20478   ac_status=$?
20479   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20480   (exit $ac_status); }; }; then
20481   ac_cv_lib_m_ctanl=yes
20482 else
20483   echo "$as_me: failed program was:" >&5
20484 sed 's/^/| /' conftest.$ac_ext >&5
20485
20486 ac_cv_lib_m_ctanl=no
20487 fi
20488 rm -f conftest.err conftest.$ac_objext \
20489       conftest$ac_exeext conftest.$ac_ext
20490 LIBS=$ac_check_lib_save_LIBS
20491 fi
20492 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanl" >&5
20493 echo "${ECHO_T}$ac_cv_lib_m_ctanl" >&6
20494 if test $ac_cv_lib_m_ctanl = yes; then
20495
20496 cat >>confdefs.h <<\_ACEOF
20497 #define HAVE_CTANL 1
20498 _ACEOF
20499
20500 fi
20501
20502 echo "$as_me:$LINENO: checking for tanhf in -lm" >&5
20503 echo $ECHO_N "checking for tanhf in -lm... $ECHO_C" >&6
20504 if test "${ac_cv_lib_m_tanhf+set}" = set; then
20505   echo $ECHO_N "(cached) $ECHO_C" >&6
20506 else
20507   ac_check_lib_save_LIBS=$LIBS
20508 LIBS="-lm  $LIBS"
20509 if test x$gcc_no_link = xyes; then
20510   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20511 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20512    { (exit 1); exit 1; }; }
20513 fi
20514 cat >conftest.$ac_ext <<_ACEOF
20515 /* confdefs.h.  */
20516 _ACEOF
20517 cat confdefs.h >>conftest.$ac_ext
20518 cat >>conftest.$ac_ext <<_ACEOF
20519 /* end confdefs.h.  */
20520
20521 /* Override any gcc2 internal prototype to avoid an error.  */
20522 #ifdef __cplusplus
20523 extern "C"
20524 #endif
20525 /* We use char because int might match the return type of a gcc2
20526    builtin and then its argument prototype would still apply.  */
20527 char tanhf ();
20528 int
20529 main ()
20530 {
20531 tanhf ();
20532   ;
20533   return 0;
20534 }
20535 _ACEOF
20536 rm -f conftest.$ac_objext conftest$ac_exeext
20537 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20538   (eval $ac_link) 2>conftest.er1
20539   ac_status=$?
20540   grep -v '^ *+' conftest.er1 >conftest.err
20541   rm -f conftest.er1
20542   cat conftest.err >&5
20543   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20544   (exit $ac_status); } &&
20545          { ac_try='test -z "$ac_c_werror_flag"
20546                          || test ! -s conftest.err'
20547   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20548   (eval $ac_try) 2>&5
20549   ac_status=$?
20550   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20551   (exit $ac_status); }; } &&
20552          { ac_try='test -s conftest$ac_exeext'
20553   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20554   (eval $ac_try) 2>&5
20555   ac_status=$?
20556   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20557   (exit $ac_status); }; }; then
20558   ac_cv_lib_m_tanhf=yes
20559 else
20560   echo "$as_me: failed program was:" >&5
20561 sed 's/^/| /' conftest.$ac_ext >&5
20562
20563 ac_cv_lib_m_tanhf=no
20564 fi
20565 rm -f conftest.err conftest.$ac_objext \
20566       conftest$ac_exeext conftest.$ac_ext
20567 LIBS=$ac_check_lib_save_LIBS
20568 fi
20569 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanhf" >&5
20570 echo "${ECHO_T}$ac_cv_lib_m_tanhf" >&6
20571 if test $ac_cv_lib_m_tanhf = yes; then
20572
20573 cat >>confdefs.h <<\_ACEOF
20574 #define HAVE_TANHF 1
20575 _ACEOF
20576
20577 fi
20578
20579 echo "$as_me:$LINENO: checking for tanh in -lm" >&5
20580 echo $ECHO_N "checking for tanh in -lm... $ECHO_C" >&6
20581 if test "${ac_cv_lib_m_tanh+set}" = set; then
20582   echo $ECHO_N "(cached) $ECHO_C" >&6
20583 else
20584   ac_check_lib_save_LIBS=$LIBS
20585 LIBS="-lm  $LIBS"
20586 if test x$gcc_no_link = xyes; then
20587   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20588 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20589    { (exit 1); exit 1; }; }
20590 fi
20591 cat >conftest.$ac_ext <<_ACEOF
20592 /* confdefs.h.  */
20593 _ACEOF
20594 cat confdefs.h >>conftest.$ac_ext
20595 cat >>conftest.$ac_ext <<_ACEOF
20596 /* end confdefs.h.  */
20597
20598 /* Override any gcc2 internal prototype to avoid an error.  */
20599 #ifdef __cplusplus
20600 extern "C"
20601 #endif
20602 /* We use char because int might match the return type of a gcc2
20603    builtin and then its argument prototype would still apply.  */
20604 char tanh ();
20605 int
20606 main ()
20607 {
20608 tanh ();
20609   ;
20610   return 0;
20611 }
20612 _ACEOF
20613 rm -f conftest.$ac_objext conftest$ac_exeext
20614 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20615   (eval $ac_link) 2>conftest.er1
20616   ac_status=$?
20617   grep -v '^ *+' conftest.er1 >conftest.err
20618   rm -f conftest.er1
20619   cat conftest.err >&5
20620   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20621   (exit $ac_status); } &&
20622          { ac_try='test -z "$ac_c_werror_flag"
20623                          || test ! -s conftest.err'
20624   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20625   (eval $ac_try) 2>&5
20626   ac_status=$?
20627   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20628   (exit $ac_status); }; } &&
20629          { ac_try='test -s conftest$ac_exeext'
20630   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20631   (eval $ac_try) 2>&5
20632   ac_status=$?
20633   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20634   (exit $ac_status); }; }; then
20635   ac_cv_lib_m_tanh=yes
20636 else
20637   echo "$as_me: failed program was:" >&5
20638 sed 's/^/| /' conftest.$ac_ext >&5
20639
20640 ac_cv_lib_m_tanh=no
20641 fi
20642 rm -f conftest.err conftest.$ac_objext \
20643       conftest$ac_exeext conftest.$ac_ext
20644 LIBS=$ac_check_lib_save_LIBS
20645 fi
20646 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanh" >&5
20647 echo "${ECHO_T}$ac_cv_lib_m_tanh" >&6
20648 if test $ac_cv_lib_m_tanh = yes; then
20649
20650 cat >>confdefs.h <<\_ACEOF
20651 #define HAVE_TANH 1
20652 _ACEOF
20653
20654 fi
20655
20656 echo "$as_me:$LINENO: checking for tanhl in -lm" >&5
20657 echo $ECHO_N "checking for tanhl in -lm... $ECHO_C" >&6
20658 if test "${ac_cv_lib_m_tanhl+set}" = set; then
20659   echo $ECHO_N "(cached) $ECHO_C" >&6
20660 else
20661   ac_check_lib_save_LIBS=$LIBS
20662 LIBS="-lm  $LIBS"
20663 if test x$gcc_no_link = xyes; then
20664   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20665 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20666    { (exit 1); exit 1; }; }
20667 fi
20668 cat >conftest.$ac_ext <<_ACEOF
20669 /* confdefs.h.  */
20670 _ACEOF
20671 cat confdefs.h >>conftest.$ac_ext
20672 cat >>conftest.$ac_ext <<_ACEOF
20673 /* end confdefs.h.  */
20674
20675 /* Override any gcc2 internal prototype to avoid an error.  */
20676 #ifdef __cplusplus
20677 extern "C"
20678 #endif
20679 /* We use char because int might match the return type of a gcc2
20680    builtin and then its argument prototype would still apply.  */
20681 char tanhl ();
20682 int
20683 main ()
20684 {
20685 tanhl ();
20686   ;
20687   return 0;
20688 }
20689 _ACEOF
20690 rm -f conftest.$ac_objext conftest$ac_exeext
20691 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20692   (eval $ac_link) 2>conftest.er1
20693   ac_status=$?
20694   grep -v '^ *+' conftest.er1 >conftest.err
20695   rm -f conftest.er1
20696   cat conftest.err >&5
20697   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20698   (exit $ac_status); } &&
20699          { ac_try='test -z "$ac_c_werror_flag"
20700                          || test ! -s conftest.err'
20701   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20702   (eval $ac_try) 2>&5
20703   ac_status=$?
20704   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20705   (exit $ac_status); }; } &&
20706          { ac_try='test -s conftest$ac_exeext'
20707   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20708   (eval $ac_try) 2>&5
20709   ac_status=$?
20710   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20711   (exit $ac_status); }; }; then
20712   ac_cv_lib_m_tanhl=yes
20713 else
20714   echo "$as_me: failed program was:" >&5
20715 sed 's/^/| /' conftest.$ac_ext >&5
20716
20717 ac_cv_lib_m_tanhl=no
20718 fi
20719 rm -f conftest.err conftest.$ac_objext \
20720       conftest$ac_exeext conftest.$ac_ext
20721 LIBS=$ac_check_lib_save_LIBS
20722 fi
20723 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanhl" >&5
20724 echo "${ECHO_T}$ac_cv_lib_m_tanhl" >&6
20725 if test $ac_cv_lib_m_tanhl = yes; then
20726
20727 cat >>confdefs.h <<\_ACEOF
20728 #define HAVE_TANHL 1
20729 _ACEOF
20730
20731 fi
20732
20733 echo "$as_me:$LINENO: checking for ctanhf in -lm" >&5
20734 echo $ECHO_N "checking for ctanhf in -lm... $ECHO_C" >&6
20735 if test "${ac_cv_lib_m_ctanhf+set}" = set; then
20736   echo $ECHO_N "(cached) $ECHO_C" >&6
20737 else
20738   ac_check_lib_save_LIBS=$LIBS
20739 LIBS="-lm  $LIBS"
20740 if test x$gcc_no_link = xyes; then
20741   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20742 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20743    { (exit 1); exit 1; }; }
20744 fi
20745 cat >conftest.$ac_ext <<_ACEOF
20746 /* confdefs.h.  */
20747 _ACEOF
20748 cat confdefs.h >>conftest.$ac_ext
20749 cat >>conftest.$ac_ext <<_ACEOF
20750 /* end confdefs.h.  */
20751
20752 /* Override any gcc2 internal prototype to avoid an error.  */
20753 #ifdef __cplusplus
20754 extern "C"
20755 #endif
20756 /* We use char because int might match the return type of a gcc2
20757    builtin and then its argument prototype would still apply.  */
20758 char ctanhf ();
20759 int
20760 main ()
20761 {
20762 ctanhf ();
20763   ;
20764   return 0;
20765 }
20766 _ACEOF
20767 rm -f conftest.$ac_objext conftest$ac_exeext
20768 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20769   (eval $ac_link) 2>conftest.er1
20770   ac_status=$?
20771   grep -v '^ *+' conftest.er1 >conftest.err
20772   rm -f conftest.er1
20773   cat conftest.err >&5
20774   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20775   (exit $ac_status); } &&
20776          { ac_try='test -z "$ac_c_werror_flag"
20777                          || test ! -s conftest.err'
20778   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20779   (eval $ac_try) 2>&5
20780   ac_status=$?
20781   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20782   (exit $ac_status); }; } &&
20783          { ac_try='test -s conftest$ac_exeext'
20784   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20785   (eval $ac_try) 2>&5
20786   ac_status=$?
20787   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20788   (exit $ac_status); }; }; then
20789   ac_cv_lib_m_ctanhf=yes
20790 else
20791   echo "$as_me: failed program was:" >&5
20792 sed 's/^/| /' conftest.$ac_ext >&5
20793
20794 ac_cv_lib_m_ctanhf=no
20795 fi
20796 rm -f conftest.err conftest.$ac_objext \
20797       conftest$ac_exeext conftest.$ac_ext
20798 LIBS=$ac_check_lib_save_LIBS
20799 fi
20800 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanhf" >&5
20801 echo "${ECHO_T}$ac_cv_lib_m_ctanhf" >&6
20802 if test $ac_cv_lib_m_ctanhf = yes; then
20803
20804 cat >>confdefs.h <<\_ACEOF
20805 #define HAVE_CTANHF 1
20806 _ACEOF
20807
20808 fi
20809
20810 echo "$as_me:$LINENO: checking for ctanh in -lm" >&5
20811 echo $ECHO_N "checking for ctanh in -lm... $ECHO_C" >&6
20812 if test "${ac_cv_lib_m_ctanh+set}" = set; then
20813   echo $ECHO_N "(cached) $ECHO_C" >&6
20814 else
20815   ac_check_lib_save_LIBS=$LIBS
20816 LIBS="-lm  $LIBS"
20817 if test x$gcc_no_link = xyes; then
20818   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20819 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20820    { (exit 1); exit 1; }; }
20821 fi
20822 cat >conftest.$ac_ext <<_ACEOF
20823 /* confdefs.h.  */
20824 _ACEOF
20825 cat confdefs.h >>conftest.$ac_ext
20826 cat >>conftest.$ac_ext <<_ACEOF
20827 /* end confdefs.h.  */
20828
20829 /* Override any gcc2 internal prototype to avoid an error.  */
20830 #ifdef __cplusplus
20831 extern "C"
20832 #endif
20833 /* We use char because int might match the return type of a gcc2
20834    builtin and then its argument prototype would still apply.  */
20835 char ctanh ();
20836 int
20837 main ()
20838 {
20839 ctanh ();
20840   ;
20841   return 0;
20842 }
20843 _ACEOF
20844 rm -f conftest.$ac_objext conftest$ac_exeext
20845 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20846   (eval $ac_link) 2>conftest.er1
20847   ac_status=$?
20848   grep -v '^ *+' conftest.er1 >conftest.err
20849   rm -f conftest.er1
20850   cat conftest.err >&5
20851   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20852   (exit $ac_status); } &&
20853          { ac_try='test -z "$ac_c_werror_flag"
20854                          || test ! -s conftest.err'
20855   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20856   (eval $ac_try) 2>&5
20857   ac_status=$?
20858   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20859   (exit $ac_status); }; } &&
20860          { ac_try='test -s conftest$ac_exeext'
20861   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20862   (eval $ac_try) 2>&5
20863   ac_status=$?
20864   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20865   (exit $ac_status); }; }; then
20866   ac_cv_lib_m_ctanh=yes
20867 else
20868   echo "$as_me: failed program was:" >&5
20869 sed 's/^/| /' conftest.$ac_ext >&5
20870
20871 ac_cv_lib_m_ctanh=no
20872 fi
20873 rm -f conftest.err conftest.$ac_objext \
20874       conftest$ac_exeext conftest.$ac_ext
20875 LIBS=$ac_check_lib_save_LIBS
20876 fi
20877 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanh" >&5
20878 echo "${ECHO_T}$ac_cv_lib_m_ctanh" >&6
20879 if test $ac_cv_lib_m_ctanh = yes; then
20880
20881 cat >>confdefs.h <<\_ACEOF
20882 #define HAVE_CTANH 1
20883 _ACEOF
20884
20885 fi
20886
20887 echo "$as_me:$LINENO: checking for ctanhl in -lm" >&5
20888 echo $ECHO_N "checking for ctanhl in -lm... $ECHO_C" >&6
20889 if test "${ac_cv_lib_m_ctanhl+set}" = set; then
20890   echo $ECHO_N "(cached) $ECHO_C" >&6
20891 else
20892   ac_check_lib_save_LIBS=$LIBS
20893 LIBS="-lm  $LIBS"
20894 if test x$gcc_no_link = xyes; then
20895   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20896 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20897    { (exit 1); exit 1; }; }
20898 fi
20899 cat >conftest.$ac_ext <<_ACEOF
20900 /* confdefs.h.  */
20901 _ACEOF
20902 cat confdefs.h >>conftest.$ac_ext
20903 cat >>conftest.$ac_ext <<_ACEOF
20904 /* end confdefs.h.  */
20905
20906 /* Override any gcc2 internal prototype to avoid an error.  */
20907 #ifdef __cplusplus
20908 extern "C"
20909 #endif
20910 /* We use char because int might match the return type of a gcc2
20911    builtin and then its argument prototype would still apply.  */
20912 char ctanhl ();
20913 int
20914 main ()
20915 {
20916 ctanhl ();
20917   ;
20918   return 0;
20919 }
20920 _ACEOF
20921 rm -f conftest.$ac_objext conftest$ac_exeext
20922 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20923   (eval $ac_link) 2>conftest.er1
20924   ac_status=$?
20925   grep -v '^ *+' conftest.er1 >conftest.err
20926   rm -f conftest.er1
20927   cat conftest.err >&5
20928   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20929   (exit $ac_status); } &&
20930          { ac_try='test -z "$ac_c_werror_flag"
20931                          || test ! -s conftest.err'
20932   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20933   (eval $ac_try) 2>&5
20934   ac_status=$?
20935   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20936   (exit $ac_status); }; } &&
20937          { ac_try='test -s conftest$ac_exeext'
20938   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20939   (eval $ac_try) 2>&5
20940   ac_status=$?
20941   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20942   (exit $ac_status); }; }; then
20943   ac_cv_lib_m_ctanhl=yes
20944 else
20945   echo "$as_me: failed program was:" >&5
20946 sed 's/^/| /' conftest.$ac_ext >&5
20947
20948 ac_cv_lib_m_ctanhl=no
20949 fi
20950 rm -f conftest.err conftest.$ac_objext \
20951       conftest$ac_exeext conftest.$ac_ext
20952 LIBS=$ac_check_lib_save_LIBS
20953 fi
20954 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanhl" >&5
20955 echo "${ECHO_T}$ac_cv_lib_m_ctanhl" >&6
20956 if test $ac_cv_lib_m_ctanhl = yes; then
20957
20958 cat >>confdefs.h <<\_ACEOF
20959 #define HAVE_CTANHL 1
20960 _ACEOF
20961
20962 fi
20963
20964 echo "$as_me:$LINENO: checking for truncf in -lm" >&5
20965 echo $ECHO_N "checking for truncf in -lm... $ECHO_C" >&6
20966 if test "${ac_cv_lib_m_truncf+set}" = set; then
20967   echo $ECHO_N "(cached) $ECHO_C" >&6
20968 else
20969   ac_check_lib_save_LIBS=$LIBS
20970 LIBS="-lm  $LIBS"
20971 if test x$gcc_no_link = xyes; then
20972   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20973 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20974    { (exit 1); exit 1; }; }
20975 fi
20976 cat >conftest.$ac_ext <<_ACEOF
20977 /* confdefs.h.  */
20978 _ACEOF
20979 cat confdefs.h >>conftest.$ac_ext
20980 cat >>conftest.$ac_ext <<_ACEOF
20981 /* end confdefs.h.  */
20982
20983 /* Override any gcc2 internal prototype to avoid an error.  */
20984 #ifdef __cplusplus
20985 extern "C"
20986 #endif
20987 /* We use char because int might match the return type of a gcc2
20988    builtin and then its argument prototype would still apply.  */
20989 char truncf ();
20990 int
20991 main ()
20992 {
20993 truncf ();
20994   ;
20995   return 0;
20996 }
20997 _ACEOF
20998 rm -f conftest.$ac_objext conftest$ac_exeext
20999 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21000   (eval $ac_link) 2>conftest.er1
21001   ac_status=$?
21002   grep -v '^ *+' conftest.er1 >conftest.err
21003   rm -f conftest.er1
21004   cat conftest.err >&5
21005   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21006   (exit $ac_status); } &&
21007          { ac_try='test -z "$ac_c_werror_flag"
21008                          || test ! -s conftest.err'
21009   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21010   (eval $ac_try) 2>&5
21011   ac_status=$?
21012   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21013   (exit $ac_status); }; } &&
21014          { ac_try='test -s conftest$ac_exeext'
21015   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21016   (eval $ac_try) 2>&5
21017   ac_status=$?
21018   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21019   (exit $ac_status); }; }; then
21020   ac_cv_lib_m_truncf=yes
21021 else
21022   echo "$as_me: failed program was:" >&5
21023 sed 's/^/| /' conftest.$ac_ext >&5
21024
21025 ac_cv_lib_m_truncf=no
21026 fi
21027 rm -f conftest.err conftest.$ac_objext \
21028       conftest$ac_exeext conftest.$ac_ext
21029 LIBS=$ac_check_lib_save_LIBS
21030 fi
21031 echo "$as_me:$LINENO: result: $ac_cv_lib_m_truncf" >&5
21032 echo "${ECHO_T}$ac_cv_lib_m_truncf" >&6
21033 if test $ac_cv_lib_m_truncf = yes; then
21034
21035 cat >>confdefs.h <<\_ACEOF
21036 #define HAVE_TRUNCF 1
21037 _ACEOF
21038
21039 fi
21040
21041 echo "$as_me:$LINENO: checking for trunc in -lm" >&5
21042 echo $ECHO_N "checking for trunc in -lm... $ECHO_C" >&6
21043 if test "${ac_cv_lib_m_trunc+set}" = set; then
21044   echo $ECHO_N "(cached) $ECHO_C" >&6
21045 else
21046   ac_check_lib_save_LIBS=$LIBS
21047 LIBS="-lm  $LIBS"
21048 if test x$gcc_no_link = xyes; then
21049   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21050 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21051    { (exit 1); exit 1; }; }
21052 fi
21053 cat >conftest.$ac_ext <<_ACEOF
21054 /* confdefs.h.  */
21055 _ACEOF
21056 cat confdefs.h >>conftest.$ac_ext
21057 cat >>conftest.$ac_ext <<_ACEOF
21058 /* end confdefs.h.  */
21059
21060 /* Override any gcc2 internal prototype to avoid an error.  */
21061 #ifdef __cplusplus
21062 extern "C"
21063 #endif
21064 /* We use char because int might match the return type of a gcc2
21065    builtin and then its argument prototype would still apply.  */
21066 char trunc ();
21067 int
21068 main ()
21069 {
21070 trunc ();
21071   ;
21072   return 0;
21073 }
21074 _ACEOF
21075 rm -f conftest.$ac_objext conftest$ac_exeext
21076 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21077   (eval $ac_link) 2>conftest.er1
21078   ac_status=$?
21079   grep -v '^ *+' conftest.er1 >conftest.err
21080   rm -f conftest.er1
21081   cat conftest.err >&5
21082   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21083   (exit $ac_status); } &&
21084          { ac_try='test -z "$ac_c_werror_flag"
21085                          || test ! -s conftest.err'
21086   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21087   (eval $ac_try) 2>&5
21088   ac_status=$?
21089   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21090   (exit $ac_status); }; } &&
21091          { ac_try='test -s conftest$ac_exeext'
21092   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21093   (eval $ac_try) 2>&5
21094   ac_status=$?
21095   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21096   (exit $ac_status); }; }; then
21097   ac_cv_lib_m_trunc=yes
21098 else
21099   echo "$as_me: failed program was:" >&5
21100 sed 's/^/| /' conftest.$ac_ext >&5
21101
21102 ac_cv_lib_m_trunc=no
21103 fi
21104 rm -f conftest.err conftest.$ac_objext \
21105       conftest$ac_exeext conftest.$ac_ext
21106 LIBS=$ac_check_lib_save_LIBS
21107 fi
21108 echo "$as_me:$LINENO: result: $ac_cv_lib_m_trunc" >&5
21109 echo "${ECHO_T}$ac_cv_lib_m_trunc" >&6
21110 if test $ac_cv_lib_m_trunc = yes; then
21111
21112 cat >>confdefs.h <<\_ACEOF
21113 #define HAVE_TRUNC 1
21114 _ACEOF
21115
21116 fi
21117
21118 echo "$as_me:$LINENO: checking for truncl in -lm" >&5
21119 echo $ECHO_N "checking for truncl in -lm... $ECHO_C" >&6
21120 if test "${ac_cv_lib_m_truncl+set}" = set; then
21121   echo $ECHO_N "(cached) $ECHO_C" >&6
21122 else
21123   ac_check_lib_save_LIBS=$LIBS
21124 LIBS="-lm  $LIBS"
21125 if test x$gcc_no_link = xyes; then
21126   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21127 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21128    { (exit 1); exit 1; }; }
21129 fi
21130 cat >conftest.$ac_ext <<_ACEOF
21131 /* confdefs.h.  */
21132 _ACEOF
21133 cat confdefs.h >>conftest.$ac_ext
21134 cat >>conftest.$ac_ext <<_ACEOF
21135 /* end confdefs.h.  */
21136
21137 /* Override any gcc2 internal prototype to avoid an error.  */
21138 #ifdef __cplusplus
21139 extern "C"
21140 #endif
21141 /* We use char because int might match the return type of a gcc2
21142    builtin and then its argument prototype would still apply.  */
21143 char truncl ();
21144 int
21145 main ()
21146 {
21147 truncl ();
21148   ;
21149   return 0;
21150 }
21151 _ACEOF
21152 rm -f conftest.$ac_objext conftest$ac_exeext
21153 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21154   (eval $ac_link) 2>conftest.er1
21155   ac_status=$?
21156   grep -v '^ *+' conftest.er1 >conftest.err
21157   rm -f conftest.er1
21158   cat conftest.err >&5
21159   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21160   (exit $ac_status); } &&
21161          { ac_try='test -z "$ac_c_werror_flag"
21162                          || test ! -s conftest.err'
21163   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21164   (eval $ac_try) 2>&5
21165   ac_status=$?
21166   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21167   (exit $ac_status); }; } &&
21168          { ac_try='test -s conftest$ac_exeext'
21169   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21170   (eval $ac_try) 2>&5
21171   ac_status=$?
21172   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21173   (exit $ac_status); }; }; then
21174   ac_cv_lib_m_truncl=yes
21175 else
21176   echo "$as_me: failed program was:" >&5
21177 sed 's/^/| /' conftest.$ac_ext >&5
21178
21179 ac_cv_lib_m_truncl=no
21180 fi
21181 rm -f conftest.err conftest.$ac_objext \
21182       conftest$ac_exeext conftest.$ac_ext
21183 LIBS=$ac_check_lib_save_LIBS
21184 fi
21185 echo "$as_me:$LINENO: result: $ac_cv_lib_m_truncl" >&5
21186 echo "${ECHO_T}$ac_cv_lib_m_truncl" >&6
21187 if test $ac_cv_lib_m_truncl = yes; then
21188
21189 cat >>confdefs.h <<\_ACEOF
21190 #define HAVE_TRUNCL 1
21191 _ACEOF
21192
21193 fi
21194
21195 echo "$as_me:$LINENO: checking for erff in -lm" >&5
21196 echo $ECHO_N "checking for erff in -lm... $ECHO_C" >&6
21197 if test "${ac_cv_lib_m_erff+set}" = set; then
21198   echo $ECHO_N "(cached) $ECHO_C" >&6
21199 else
21200   ac_check_lib_save_LIBS=$LIBS
21201 LIBS="-lm  $LIBS"
21202 if test x$gcc_no_link = xyes; then
21203   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21204 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21205    { (exit 1); exit 1; }; }
21206 fi
21207 cat >conftest.$ac_ext <<_ACEOF
21208 /* confdefs.h.  */
21209 _ACEOF
21210 cat confdefs.h >>conftest.$ac_ext
21211 cat >>conftest.$ac_ext <<_ACEOF
21212 /* end confdefs.h.  */
21213
21214 /* Override any gcc2 internal prototype to avoid an error.  */
21215 #ifdef __cplusplus
21216 extern "C"
21217 #endif
21218 /* We use char because int might match the return type of a gcc2
21219    builtin and then its argument prototype would still apply.  */
21220 char erff ();
21221 int
21222 main ()
21223 {
21224 erff ();
21225   ;
21226   return 0;
21227 }
21228 _ACEOF
21229 rm -f conftest.$ac_objext conftest$ac_exeext
21230 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21231   (eval $ac_link) 2>conftest.er1
21232   ac_status=$?
21233   grep -v '^ *+' conftest.er1 >conftest.err
21234   rm -f conftest.er1
21235   cat conftest.err >&5
21236   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21237   (exit $ac_status); } &&
21238          { ac_try='test -z "$ac_c_werror_flag"
21239                          || test ! -s conftest.err'
21240   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21241   (eval $ac_try) 2>&5
21242   ac_status=$?
21243   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21244   (exit $ac_status); }; } &&
21245          { ac_try='test -s conftest$ac_exeext'
21246   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21247   (eval $ac_try) 2>&5
21248   ac_status=$?
21249   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21250   (exit $ac_status); }; }; then
21251   ac_cv_lib_m_erff=yes
21252 else
21253   echo "$as_me: failed program was:" >&5
21254 sed 's/^/| /' conftest.$ac_ext >&5
21255
21256 ac_cv_lib_m_erff=no
21257 fi
21258 rm -f conftest.err conftest.$ac_objext \
21259       conftest$ac_exeext conftest.$ac_ext
21260 LIBS=$ac_check_lib_save_LIBS
21261 fi
21262 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erff" >&5
21263 echo "${ECHO_T}$ac_cv_lib_m_erff" >&6
21264 if test $ac_cv_lib_m_erff = yes; then
21265
21266 cat >>confdefs.h <<\_ACEOF
21267 #define HAVE_ERFF 1
21268 _ACEOF
21269
21270 fi
21271
21272 echo "$as_me:$LINENO: checking for erf in -lm" >&5
21273 echo $ECHO_N "checking for erf in -lm... $ECHO_C" >&6
21274 if test "${ac_cv_lib_m_erf+set}" = set; then
21275   echo $ECHO_N "(cached) $ECHO_C" >&6
21276 else
21277   ac_check_lib_save_LIBS=$LIBS
21278 LIBS="-lm  $LIBS"
21279 if test x$gcc_no_link = xyes; then
21280   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21281 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21282    { (exit 1); exit 1; }; }
21283 fi
21284 cat >conftest.$ac_ext <<_ACEOF
21285 /* confdefs.h.  */
21286 _ACEOF
21287 cat confdefs.h >>conftest.$ac_ext
21288 cat >>conftest.$ac_ext <<_ACEOF
21289 /* end confdefs.h.  */
21290
21291 /* Override any gcc2 internal prototype to avoid an error.  */
21292 #ifdef __cplusplus
21293 extern "C"
21294 #endif
21295 /* We use char because int might match the return type of a gcc2
21296    builtin and then its argument prototype would still apply.  */
21297 char erf ();
21298 int
21299 main ()
21300 {
21301 erf ();
21302   ;
21303   return 0;
21304 }
21305 _ACEOF
21306 rm -f conftest.$ac_objext conftest$ac_exeext
21307 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21308   (eval $ac_link) 2>conftest.er1
21309   ac_status=$?
21310   grep -v '^ *+' conftest.er1 >conftest.err
21311   rm -f conftest.er1
21312   cat conftest.err >&5
21313   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21314   (exit $ac_status); } &&
21315          { ac_try='test -z "$ac_c_werror_flag"
21316                          || test ! -s conftest.err'
21317   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21318   (eval $ac_try) 2>&5
21319   ac_status=$?
21320   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21321   (exit $ac_status); }; } &&
21322          { ac_try='test -s conftest$ac_exeext'
21323   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21324   (eval $ac_try) 2>&5
21325   ac_status=$?
21326   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21327   (exit $ac_status); }; }; then
21328   ac_cv_lib_m_erf=yes
21329 else
21330   echo "$as_me: failed program was:" >&5
21331 sed 's/^/| /' conftest.$ac_ext >&5
21332
21333 ac_cv_lib_m_erf=no
21334 fi
21335 rm -f conftest.err conftest.$ac_objext \
21336       conftest$ac_exeext conftest.$ac_ext
21337 LIBS=$ac_check_lib_save_LIBS
21338 fi
21339 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erf" >&5
21340 echo "${ECHO_T}$ac_cv_lib_m_erf" >&6
21341 if test $ac_cv_lib_m_erf = yes; then
21342
21343 cat >>confdefs.h <<\_ACEOF
21344 #define HAVE_ERF 1
21345 _ACEOF
21346
21347 fi
21348
21349 echo "$as_me:$LINENO: checking for erfl in -lm" >&5
21350 echo $ECHO_N "checking for erfl in -lm... $ECHO_C" >&6
21351 if test "${ac_cv_lib_m_erfl+set}" = set; then
21352   echo $ECHO_N "(cached) $ECHO_C" >&6
21353 else
21354   ac_check_lib_save_LIBS=$LIBS
21355 LIBS="-lm  $LIBS"
21356 if test x$gcc_no_link = xyes; then
21357   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21358 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21359    { (exit 1); exit 1; }; }
21360 fi
21361 cat >conftest.$ac_ext <<_ACEOF
21362 /* confdefs.h.  */
21363 _ACEOF
21364 cat confdefs.h >>conftest.$ac_ext
21365 cat >>conftest.$ac_ext <<_ACEOF
21366 /* end confdefs.h.  */
21367
21368 /* Override any gcc2 internal prototype to avoid an error.  */
21369 #ifdef __cplusplus
21370 extern "C"
21371 #endif
21372 /* We use char because int might match the return type of a gcc2
21373    builtin and then its argument prototype would still apply.  */
21374 char erfl ();
21375 int
21376 main ()
21377 {
21378 erfl ();
21379   ;
21380   return 0;
21381 }
21382 _ACEOF
21383 rm -f conftest.$ac_objext conftest$ac_exeext
21384 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21385   (eval $ac_link) 2>conftest.er1
21386   ac_status=$?
21387   grep -v '^ *+' conftest.er1 >conftest.err
21388   rm -f conftest.er1
21389   cat conftest.err >&5
21390   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21391   (exit $ac_status); } &&
21392          { ac_try='test -z "$ac_c_werror_flag"
21393                          || test ! -s conftest.err'
21394   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21395   (eval $ac_try) 2>&5
21396   ac_status=$?
21397   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21398   (exit $ac_status); }; } &&
21399          { ac_try='test -s conftest$ac_exeext'
21400   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21401   (eval $ac_try) 2>&5
21402   ac_status=$?
21403   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21404   (exit $ac_status); }; }; then
21405   ac_cv_lib_m_erfl=yes
21406 else
21407   echo "$as_me: failed program was:" >&5
21408 sed 's/^/| /' conftest.$ac_ext >&5
21409
21410 ac_cv_lib_m_erfl=no
21411 fi
21412 rm -f conftest.err conftest.$ac_objext \
21413       conftest$ac_exeext conftest.$ac_ext
21414 LIBS=$ac_check_lib_save_LIBS
21415 fi
21416 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfl" >&5
21417 echo "${ECHO_T}$ac_cv_lib_m_erfl" >&6
21418 if test $ac_cv_lib_m_erfl = yes; then
21419
21420 cat >>confdefs.h <<\_ACEOF
21421 #define HAVE_ERFL 1
21422 _ACEOF
21423
21424 fi
21425
21426 echo "$as_me:$LINENO: checking for erfcf in -lm" >&5
21427 echo $ECHO_N "checking for erfcf in -lm... $ECHO_C" >&6
21428 if test "${ac_cv_lib_m_erfcf+set}" = set; then
21429   echo $ECHO_N "(cached) $ECHO_C" >&6
21430 else
21431   ac_check_lib_save_LIBS=$LIBS
21432 LIBS="-lm  $LIBS"
21433 if test x$gcc_no_link = xyes; then
21434   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21435 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21436    { (exit 1); exit 1; }; }
21437 fi
21438 cat >conftest.$ac_ext <<_ACEOF
21439 /* confdefs.h.  */
21440 _ACEOF
21441 cat confdefs.h >>conftest.$ac_ext
21442 cat >>conftest.$ac_ext <<_ACEOF
21443 /* end confdefs.h.  */
21444
21445 /* Override any gcc2 internal prototype to avoid an error.  */
21446 #ifdef __cplusplus
21447 extern "C"
21448 #endif
21449 /* We use char because int might match the return type of a gcc2
21450    builtin and then its argument prototype would still apply.  */
21451 char erfcf ();
21452 int
21453 main ()
21454 {
21455 erfcf ();
21456   ;
21457   return 0;
21458 }
21459 _ACEOF
21460 rm -f conftest.$ac_objext conftest$ac_exeext
21461 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21462   (eval $ac_link) 2>conftest.er1
21463   ac_status=$?
21464   grep -v '^ *+' conftest.er1 >conftest.err
21465   rm -f conftest.er1
21466   cat conftest.err >&5
21467   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21468   (exit $ac_status); } &&
21469          { ac_try='test -z "$ac_c_werror_flag"
21470                          || test ! -s conftest.err'
21471   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21472   (eval $ac_try) 2>&5
21473   ac_status=$?
21474   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21475   (exit $ac_status); }; } &&
21476          { ac_try='test -s conftest$ac_exeext'
21477   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21478   (eval $ac_try) 2>&5
21479   ac_status=$?
21480   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21481   (exit $ac_status); }; }; then
21482   ac_cv_lib_m_erfcf=yes
21483 else
21484   echo "$as_me: failed program was:" >&5
21485 sed 's/^/| /' conftest.$ac_ext >&5
21486
21487 ac_cv_lib_m_erfcf=no
21488 fi
21489 rm -f conftest.err conftest.$ac_objext \
21490       conftest$ac_exeext conftest.$ac_ext
21491 LIBS=$ac_check_lib_save_LIBS
21492 fi
21493 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfcf" >&5
21494 echo "${ECHO_T}$ac_cv_lib_m_erfcf" >&6
21495 if test $ac_cv_lib_m_erfcf = yes; then
21496
21497 cat >>confdefs.h <<\_ACEOF
21498 #define HAVE_ERFCF 1
21499 _ACEOF
21500
21501 fi
21502
21503 echo "$as_me:$LINENO: checking for erfc in -lm" >&5
21504 echo $ECHO_N "checking for erfc in -lm... $ECHO_C" >&6
21505 if test "${ac_cv_lib_m_erfc+set}" = set; then
21506   echo $ECHO_N "(cached) $ECHO_C" >&6
21507 else
21508   ac_check_lib_save_LIBS=$LIBS
21509 LIBS="-lm  $LIBS"
21510 if test x$gcc_no_link = xyes; then
21511   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21512 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21513    { (exit 1); exit 1; }; }
21514 fi
21515 cat >conftest.$ac_ext <<_ACEOF
21516 /* confdefs.h.  */
21517 _ACEOF
21518 cat confdefs.h >>conftest.$ac_ext
21519 cat >>conftest.$ac_ext <<_ACEOF
21520 /* end confdefs.h.  */
21521
21522 /* Override any gcc2 internal prototype to avoid an error.  */
21523 #ifdef __cplusplus
21524 extern "C"
21525 #endif
21526 /* We use char because int might match the return type of a gcc2
21527    builtin and then its argument prototype would still apply.  */
21528 char erfc ();
21529 int
21530 main ()
21531 {
21532 erfc ();
21533   ;
21534   return 0;
21535 }
21536 _ACEOF
21537 rm -f conftest.$ac_objext conftest$ac_exeext
21538 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21539   (eval $ac_link) 2>conftest.er1
21540   ac_status=$?
21541   grep -v '^ *+' conftest.er1 >conftest.err
21542   rm -f conftest.er1
21543   cat conftest.err >&5
21544   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21545   (exit $ac_status); } &&
21546          { ac_try='test -z "$ac_c_werror_flag"
21547                          || test ! -s conftest.err'
21548   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21549   (eval $ac_try) 2>&5
21550   ac_status=$?
21551   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21552   (exit $ac_status); }; } &&
21553          { ac_try='test -s conftest$ac_exeext'
21554   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21555   (eval $ac_try) 2>&5
21556   ac_status=$?
21557   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21558   (exit $ac_status); }; }; then
21559   ac_cv_lib_m_erfc=yes
21560 else
21561   echo "$as_me: failed program was:" >&5
21562 sed 's/^/| /' conftest.$ac_ext >&5
21563
21564 ac_cv_lib_m_erfc=no
21565 fi
21566 rm -f conftest.err conftest.$ac_objext \
21567       conftest$ac_exeext conftest.$ac_ext
21568 LIBS=$ac_check_lib_save_LIBS
21569 fi
21570 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfc" >&5
21571 echo "${ECHO_T}$ac_cv_lib_m_erfc" >&6
21572 if test $ac_cv_lib_m_erfc = yes; then
21573
21574 cat >>confdefs.h <<\_ACEOF
21575 #define HAVE_ERFC 1
21576 _ACEOF
21577
21578 fi
21579
21580 echo "$as_me:$LINENO: checking for erfcl in -lm" >&5
21581 echo $ECHO_N "checking for erfcl in -lm... $ECHO_C" >&6
21582 if test "${ac_cv_lib_m_erfcl+set}" = set; then
21583   echo $ECHO_N "(cached) $ECHO_C" >&6
21584 else
21585   ac_check_lib_save_LIBS=$LIBS
21586 LIBS="-lm  $LIBS"
21587 if test x$gcc_no_link = xyes; then
21588   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21589 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21590    { (exit 1); exit 1; }; }
21591 fi
21592 cat >conftest.$ac_ext <<_ACEOF
21593 /* confdefs.h.  */
21594 _ACEOF
21595 cat confdefs.h >>conftest.$ac_ext
21596 cat >>conftest.$ac_ext <<_ACEOF
21597 /* end confdefs.h.  */
21598
21599 /* Override any gcc2 internal prototype to avoid an error.  */
21600 #ifdef __cplusplus
21601 extern "C"
21602 #endif
21603 /* We use char because int might match the return type of a gcc2
21604    builtin and then its argument prototype would still apply.  */
21605 char erfcl ();
21606 int
21607 main ()
21608 {
21609 erfcl ();
21610   ;
21611   return 0;
21612 }
21613 _ACEOF
21614 rm -f conftest.$ac_objext conftest$ac_exeext
21615 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21616   (eval $ac_link) 2>conftest.er1
21617   ac_status=$?
21618   grep -v '^ *+' conftest.er1 >conftest.err
21619   rm -f conftest.er1
21620   cat conftest.err >&5
21621   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21622   (exit $ac_status); } &&
21623          { ac_try='test -z "$ac_c_werror_flag"
21624                          || test ! -s conftest.err'
21625   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21626   (eval $ac_try) 2>&5
21627   ac_status=$?
21628   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21629   (exit $ac_status); }; } &&
21630          { ac_try='test -s conftest$ac_exeext'
21631   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21632   (eval $ac_try) 2>&5
21633   ac_status=$?
21634   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21635   (exit $ac_status); }; }; then
21636   ac_cv_lib_m_erfcl=yes
21637 else
21638   echo "$as_me: failed program was:" >&5
21639 sed 's/^/| /' conftest.$ac_ext >&5
21640
21641 ac_cv_lib_m_erfcl=no
21642 fi
21643 rm -f conftest.err conftest.$ac_objext \
21644       conftest$ac_exeext conftest.$ac_ext
21645 LIBS=$ac_check_lib_save_LIBS
21646 fi
21647 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfcl" >&5
21648 echo "${ECHO_T}$ac_cv_lib_m_erfcl" >&6
21649 if test $ac_cv_lib_m_erfcl = yes; then
21650
21651 cat >>confdefs.h <<\_ACEOF
21652 #define HAVE_ERFCL 1
21653 _ACEOF
21654
21655 fi
21656
21657 echo "$as_me:$LINENO: checking for j0f in -lm" >&5
21658 echo $ECHO_N "checking for j0f in -lm... $ECHO_C" >&6
21659 if test "${ac_cv_lib_m_j0f+set}" = set; then
21660   echo $ECHO_N "(cached) $ECHO_C" >&6
21661 else
21662   ac_check_lib_save_LIBS=$LIBS
21663 LIBS="-lm  $LIBS"
21664 if test x$gcc_no_link = xyes; then
21665   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21666 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21667    { (exit 1); exit 1; }; }
21668 fi
21669 cat >conftest.$ac_ext <<_ACEOF
21670 /* confdefs.h.  */
21671 _ACEOF
21672 cat confdefs.h >>conftest.$ac_ext
21673 cat >>conftest.$ac_ext <<_ACEOF
21674 /* end confdefs.h.  */
21675
21676 /* Override any gcc2 internal prototype to avoid an error.  */
21677 #ifdef __cplusplus
21678 extern "C"
21679 #endif
21680 /* We use char because int might match the return type of a gcc2
21681    builtin and then its argument prototype would still apply.  */
21682 char j0f ();
21683 int
21684 main ()
21685 {
21686 j0f ();
21687   ;
21688   return 0;
21689 }
21690 _ACEOF
21691 rm -f conftest.$ac_objext conftest$ac_exeext
21692 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21693   (eval $ac_link) 2>conftest.er1
21694   ac_status=$?
21695   grep -v '^ *+' conftest.er1 >conftest.err
21696   rm -f conftest.er1
21697   cat conftest.err >&5
21698   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21699   (exit $ac_status); } &&
21700          { ac_try='test -z "$ac_c_werror_flag"
21701                          || test ! -s conftest.err'
21702   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21703   (eval $ac_try) 2>&5
21704   ac_status=$?
21705   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21706   (exit $ac_status); }; } &&
21707          { ac_try='test -s conftest$ac_exeext'
21708   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21709   (eval $ac_try) 2>&5
21710   ac_status=$?
21711   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21712   (exit $ac_status); }; }; then
21713   ac_cv_lib_m_j0f=yes
21714 else
21715   echo "$as_me: failed program was:" >&5
21716 sed 's/^/| /' conftest.$ac_ext >&5
21717
21718 ac_cv_lib_m_j0f=no
21719 fi
21720 rm -f conftest.err conftest.$ac_objext \
21721       conftest$ac_exeext conftest.$ac_ext
21722 LIBS=$ac_check_lib_save_LIBS
21723 fi
21724 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0f" >&5
21725 echo "${ECHO_T}$ac_cv_lib_m_j0f" >&6
21726 if test $ac_cv_lib_m_j0f = yes; then
21727
21728 cat >>confdefs.h <<\_ACEOF
21729 #define HAVE_J0F 1
21730 _ACEOF
21731
21732 fi
21733
21734 echo "$as_me:$LINENO: checking for j0 in -lm" >&5
21735 echo $ECHO_N "checking for j0 in -lm... $ECHO_C" >&6
21736 if test "${ac_cv_lib_m_j0+set}" = set; then
21737   echo $ECHO_N "(cached) $ECHO_C" >&6
21738 else
21739   ac_check_lib_save_LIBS=$LIBS
21740 LIBS="-lm  $LIBS"
21741 if test x$gcc_no_link = xyes; then
21742   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21743 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21744    { (exit 1); exit 1; }; }
21745 fi
21746 cat >conftest.$ac_ext <<_ACEOF
21747 /* confdefs.h.  */
21748 _ACEOF
21749 cat confdefs.h >>conftest.$ac_ext
21750 cat >>conftest.$ac_ext <<_ACEOF
21751 /* end confdefs.h.  */
21752
21753 /* Override any gcc2 internal prototype to avoid an error.  */
21754 #ifdef __cplusplus
21755 extern "C"
21756 #endif
21757 /* We use char because int might match the return type of a gcc2
21758    builtin and then its argument prototype would still apply.  */
21759 char j0 ();
21760 int
21761 main ()
21762 {
21763 j0 ();
21764   ;
21765   return 0;
21766 }
21767 _ACEOF
21768 rm -f conftest.$ac_objext conftest$ac_exeext
21769 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21770   (eval $ac_link) 2>conftest.er1
21771   ac_status=$?
21772   grep -v '^ *+' conftest.er1 >conftest.err
21773   rm -f conftest.er1
21774   cat conftest.err >&5
21775   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21776   (exit $ac_status); } &&
21777          { ac_try='test -z "$ac_c_werror_flag"
21778                          || test ! -s conftest.err'
21779   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21780   (eval $ac_try) 2>&5
21781   ac_status=$?
21782   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21783   (exit $ac_status); }; } &&
21784          { ac_try='test -s conftest$ac_exeext'
21785   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21786   (eval $ac_try) 2>&5
21787   ac_status=$?
21788   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21789   (exit $ac_status); }; }; then
21790   ac_cv_lib_m_j0=yes
21791 else
21792   echo "$as_me: failed program was:" >&5
21793 sed 's/^/| /' conftest.$ac_ext >&5
21794
21795 ac_cv_lib_m_j0=no
21796 fi
21797 rm -f conftest.err conftest.$ac_objext \
21798       conftest$ac_exeext conftest.$ac_ext
21799 LIBS=$ac_check_lib_save_LIBS
21800 fi
21801 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0" >&5
21802 echo "${ECHO_T}$ac_cv_lib_m_j0" >&6
21803 if test $ac_cv_lib_m_j0 = yes; then
21804
21805 cat >>confdefs.h <<\_ACEOF
21806 #define HAVE_J0 1
21807 _ACEOF
21808
21809 fi
21810
21811 echo "$as_me:$LINENO: checking for j0l in -lm" >&5
21812 echo $ECHO_N "checking for j0l in -lm... $ECHO_C" >&6
21813 if test "${ac_cv_lib_m_j0l+set}" = set; then
21814   echo $ECHO_N "(cached) $ECHO_C" >&6
21815 else
21816   ac_check_lib_save_LIBS=$LIBS
21817 LIBS="-lm  $LIBS"
21818 if test x$gcc_no_link = xyes; then
21819   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21820 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21821    { (exit 1); exit 1; }; }
21822 fi
21823 cat >conftest.$ac_ext <<_ACEOF
21824 /* confdefs.h.  */
21825 _ACEOF
21826 cat confdefs.h >>conftest.$ac_ext
21827 cat >>conftest.$ac_ext <<_ACEOF
21828 /* end confdefs.h.  */
21829
21830 /* Override any gcc2 internal prototype to avoid an error.  */
21831 #ifdef __cplusplus
21832 extern "C"
21833 #endif
21834 /* We use char because int might match the return type of a gcc2
21835    builtin and then its argument prototype would still apply.  */
21836 char j0l ();
21837 int
21838 main ()
21839 {
21840 j0l ();
21841   ;
21842   return 0;
21843 }
21844 _ACEOF
21845 rm -f conftest.$ac_objext conftest$ac_exeext
21846 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21847   (eval $ac_link) 2>conftest.er1
21848   ac_status=$?
21849   grep -v '^ *+' conftest.er1 >conftest.err
21850   rm -f conftest.er1
21851   cat conftest.err >&5
21852   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21853   (exit $ac_status); } &&
21854          { ac_try='test -z "$ac_c_werror_flag"
21855                          || test ! -s conftest.err'
21856   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21857   (eval $ac_try) 2>&5
21858   ac_status=$?
21859   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21860   (exit $ac_status); }; } &&
21861          { ac_try='test -s conftest$ac_exeext'
21862   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21863   (eval $ac_try) 2>&5
21864   ac_status=$?
21865   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21866   (exit $ac_status); }; }; then
21867   ac_cv_lib_m_j0l=yes
21868 else
21869   echo "$as_me: failed program was:" >&5
21870 sed 's/^/| /' conftest.$ac_ext >&5
21871
21872 ac_cv_lib_m_j0l=no
21873 fi
21874 rm -f conftest.err conftest.$ac_objext \
21875       conftest$ac_exeext conftest.$ac_ext
21876 LIBS=$ac_check_lib_save_LIBS
21877 fi
21878 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0l" >&5
21879 echo "${ECHO_T}$ac_cv_lib_m_j0l" >&6
21880 if test $ac_cv_lib_m_j0l = yes; then
21881
21882 cat >>confdefs.h <<\_ACEOF
21883 #define HAVE_J0L 1
21884 _ACEOF
21885
21886 fi
21887
21888 echo "$as_me:$LINENO: checking for j1f in -lm" >&5
21889 echo $ECHO_N "checking for j1f in -lm... $ECHO_C" >&6
21890 if test "${ac_cv_lib_m_j1f+set}" = set; then
21891   echo $ECHO_N "(cached) $ECHO_C" >&6
21892 else
21893   ac_check_lib_save_LIBS=$LIBS
21894 LIBS="-lm  $LIBS"
21895 if test x$gcc_no_link = xyes; then
21896   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21897 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21898    { (exit 1); exit 1; }; }
21899 fi
21900 cat >conftest.$ac_ext <<_ACEOF
21901 /* confdefs.h.  */
21902 _ACEOF
21903 cat confdefs.h >>conftest.$ac_ext
21904 cat >>conftest.$ac_ext <<_ACEOF
21905 /* end confdefs.h.  */
21906
21907 /* Override any gcc2 internal prototype to avoid an error.  */
21908 #ifdef __cplusplus
21909 extern "C"
21910 #endif
21911 /* We use char because int might match the return type of a gcc2
21912    builtin and then its argument prototype would still apply.  */
21913 char j1f ();
21914 int
21915 main ()
21916 {
21917 j1f ();
21918   ;
21919   return 0;
21920 }
21921 _ACEOF
21922 rm -f conftest.$ac_objext conftest$ac_exeext
21923 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21924   (eval $ac_link) 2>conftest.er1
21925   ac_status=$?
21926   grep -v '^ *+' conftest.er1 >conftest.err
21927   rm -f conftest.er1
21928   cat conftest.err >&5
21929   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21930   (exit $ac_status); } &&
21931          { ac_try='test -z "$ac_c_werror_flag"
21932                          || test ! -s conftest.err'
21933   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21934   (eval $ac_try) 2>&5
21935   ac_status=$?
21936   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21937   (exit $ac_status); }; } &&
21938          { ac_try='test -s conftest$ac_exeext'
21939   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21940   (eval $ac_try) 2>&5
21941   ac_status=$?
21942   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21943   (exit $ac_status); }; }; then
21944   ac_cv_lib_m_j1f=yes
21945 else
21946   echo "$as_me: failed program was:" >&5
21947 sed 's/^/| /' conftest.$ac_ext >&5
21948
21949 ac_cv_lib_m_j1f=no
21950 fi
21951 rm -f conftest.err conftest.$ac_objext \
21952       conftest$ac_exeext conftest.$ac_ext
21953 LIBS=$ac_check_lib_save_LIBS
21954 fi
21955 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1f" >&5
21956 echo "${ECHO_T}$ac_cv_lib_m_j1f" >&6
21957 if test $ac_cv_lib_m_j1f = yes; then
21958
21959 cat >>confdefs.h <<\_ACEOF
21960 #define HAVE_J1F 1
21961 _ACEOF
21962
21963 fi
21964
21965 echo "$as_me:$LINENO: checking for j1 in -lm" >&5
21966 echo $ECHO_N "checking for j1 in -lm... $ECHO_C" >&6
21967 if test "${ac_cv_lib_m_j1+set}" = set; then
21968   echo $ECHO_N "(cached) $ECHO_C" >&6
21969 else
21970   ac_check_lib_save_LIBS=$LIBS
21971 LIBS="-lm  $LIBS"
21972 if test x$gcc_no_link = xyes; then
21973   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21974 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21975    { (exit 1); exit 1; }; }
21976 fi
21977 cat >conftest.$ac_ext <<_ACEOF
21978 /* confdefs.h.  */
21979 _ACEOF
21980 cat confdefs.h >>conftest.$ac_ext
21981 cat >>conftest.$ac_ext <<_ACEOF
21982 /* end confdefs.h.  */
21983
21984 /* Override any gcc2 internal prototype to avoid an error.  */
21985 #ifdef __cplusplus
21986 extern "C"
21987 #endif
21988 /* We use char because int might match the return type of a gcc2
21989    builtin and then its argument prototype would still apply.  */
21990 char j1 ();
21991 int
21992 main ()
21993 {
21994 j1 ();
21995   ;
21996   return 0;
21997 }
21998 _ACEOF
21999 rm -f conftest.$ac_objext conftest$ac_exeext
22000 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22001   (eval $ac_link) 2>conftest.er1
22002   ac_status=$?
22003   grep -v '^ *+' conftest.er1 >conftest.err
22004   rm -f conftest.er1
22005   cat conftest.err >&5
22006   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22007   (exit $ac_status); } &&
22008          { ac_try='test -z "$ac_c_werror_flag"
22009                          || test ! -s conftest.err'
22010   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22011   (eval $ac_try) 2>&5
22012   ac_status=$?
22013   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22014   (exit $ac_status); }; } &&
22015          { ac_try='test -s conftest$ac_exeext'
22016   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22017   (eval $ac_try) 2>&5
22018   ac_status=$?
22019   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22020   (exit $ac_status); }; }; then
22021   ac_cv_lib_m_j1=yes
22022 else
22023   echo "$as_me: failed program was:" >&5
22024 sed 's/^/| /' conftest.$ac_ext >&5
22025
22026 ac_cv_lib_m_j1=no
22027 fi
22028 rm -f conftest.err conftest.$ac_objext \
22029       conftest$ac_exeext conftest.$ac_ext
22030 LIBS=$ac_check_lib_save_LIBS
22031 fi
22032 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1" >&5
22033 echo "${ECHO_T}$ac_cv_lib_m_j1" >&6
22034 if test $ac_cv_lib_m_j1 = yes; then
22035
22036 cat >>confdefs.h <<\_ACEOF
22037 #define HAVE_J1 1
22038 _ACEOF
22039
22040 fi
22041
22042 echo "$as_me:$LINENO: checking for j1l in -lm" >&5
22043 echo $ECHO_N "checking for j1l in -lm... $ECHO_C" >&6
22044 if test "${ac_cv_lib_m_j1l+set}" = set; then
22045   echo $ECHO_N "(cached) $ECHO_C" >&6
22046 else
22047   ac_check_lib_save_LIBS=$LIBS
22048 LIBS="-lm  $LIBS"
22049 if test x$gcc_no_link = xyes; then
22050   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22051 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22052    { (exit 1); exit 1; }; }
22053 fi
22054 cat >conftest.$ac_ext <<_ACEOF
22055 /* confdefs.h.  */
22056 _ACEOF
22057 cat confdefs.h >>conftest.$ac_ext
22058 cat >>conftest.$ac_ext <<_ACEOF
22059 /* end confdefs.h.  */
22060
22061 /* Override any gcc2 internal prototype to avoid an error.  */
22062 #ifdef __cplusplus
22063 extern "C"
22064 #endif
22065 /* We use char because int might match the return type of a gcc2
22066    builtin and then its argument prototype would still apply.  */
22067 char j1l ();
22068 int
22069 main ()
22070 {
22071 j1l ();
22072   ;
22073   return 0;
22074 }
22075 _ACEOF
22076 rm -f conftest.$ac_objext conftest$ac_exeext
22077 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22078   (eval $ac_link) 2>conftest.er1
22079   ac_status=$?
22080   grep -v '^ *+' conftest.er1 >conftest.err
22081   rm -f conftest.er1
22082   cat conftest.err >&5
22083   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22084   (exit $ac_status); } &&
22085          { ac_try='test -z "$ac_c_werror_flag"
22086                          || test ! -s conftest.err'
22087   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22088   (eval $ac_try) 2>&5
22089   ac_status=$?
22090   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22091   (exit $ac_status); }; } &&
22092          { ac_try='test -s conftest$ac_exeext'
22093   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22094   (eval $ac_try) 2>&5
22095   ac_status=$?
22096   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22097   (exit $ac_status); }; }; then
22098   ac_cv_lib_m_j1l=yes
22099 else
22100   echo "$as_me: failed program was:" >&5
22101 sed 's/^/| /' conftest.$ac_ext >&5
22102
22103 ac_cv_lib_m_j1l=no
22104 fi
22105 rm -f conftest.err conftest.$ac_objext \
22106       conftest$ac_exeext conftest.$ac_ext
22107 LIBS=$ac_check_lib_save_LIBS
22108 fi
22109 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1l" >&5
22110 echo "${ECHO_T}$ac_cv_lib_m_j1l" >&6
22111 if test $ac_cv_lib_m_j1l = yes; then
22112
22113 cat >>confdefs.h <<\_ACEOF
22114 #define HAVE_J1L 1
22115 _ACEOF
22116
22117 fi
22118
22119 echo "$as_me:$LINENO: checking for jnf in -lm" >&5
22120 echo $ECHO_N "checking for jnf in -lm... $ECHO_C" >&6
22121 if test "${ac_cv_lib_m_jnf+set}" = set; then
22122   echo $ECHO_N "(cached) $ECHO_C" >&6
22123 else
22124   ac_check_lib_save_LIBS=$LIBS
22125 LIBS="-lm  $LIBS"
22126 if test x$gcc_no_link = xyes; then
22127   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22128 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22129    { (exit 1); exit 1; }; }
22130 fi
22131 cat >conftest.$ac_ext <<_ACEOF
22132 /* confdefs.h.  */
22133 _ACEOF
22134 cat confdefs.h >>conftest.$ac_ext
22135 cat >>conftest.$ac_ext <<_ACEOF
22136 /* end confdefs.h.  */
22137
22138 /* Override any gcc2 internal prototype to avoid an error.  */
22139 #ifdef __cplusplus
22140 extern "C"
22141 #endif
22142 /* We use char because int might match the return type of a gcc2
22143    builtin and then its argument prototype would still apply.  */
22144 char jnf ();
22145 int
22146 main ()
22147 {
22148 jnf ();
22149   ;
22150   return 0;
22151 }
22152 _ACEOF
22153 rm -f conftest.$ac_objext conftest$ac_exeext
22154 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22155   (eval $ac_link) 2>conftest.er1
22156   ac_status=$?
22157   grep -v '^ *+' conftest.er1 >conftest.err
22158   rm -f conftest.er1
22159   cat conftest.err >&5
22160   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22161   (exit $ac_status); } &&
22162          { ac_try='test -z "$ac_c_werror_flag"
22163                          || test ! -s conftest.err'
22164   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22165   (eval $ac_try) 2>&5
22166   ac_status=$?
22167   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22168   (exit $ac_status); }; } &&
22169          { ac_try='test -s conftest$ac_exeext'
22170   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22171   (eval $ac_try) 2>&5
22172   ac_status=$?
22173   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22174   (exit $ac_status); }; }; then
22175   ac_cv_lib_m_jnf=yes
22176 else
22177   echo "$as_me: failed program was:" >&5
22178 sed 's/^/| /' conftest.$ac_ext >&5
22179
22180 ac_cv_lib_m_jnf=no
22181 fi
22182 rm -f conftest.err conftest.$ac_objext \
22183       conftest$ac_exeext conftest.$ac_ext
22184 LIBS=$ac_check_lib_save_LIBS
22185 fi
22186 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jnf" >&5
22187 echo "${ECHO_T}$ac_cv_lib_m_jnf" >&6
22188 if test $ac_cv_lib_m_jnf = yes; then
22189
22190 cat >>confdefs.h <<\_ACEOF
22191 #define HAVE_JNF 1
22192 _ACEOF
22193
22194 fi
22195
22196 echo "$as_me:$LINENO: checking for jn in -lm" >&5
22197 echo $ECHO_N "checking for jn in -lm... $ECHO_C" >&6
22198 if test "${ac_cv_lib_m_jn+set}" = set; then
22199   echo $ECHO_N "(cached) $ECHO_C" >&6
22200 else
22201   ac_check_lib_save_LIBS=$LIBS
22202 LIBS="-lm  $LIBS"
22203 if test x$gcc_no_link = xyes; then
22204   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22205 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22206    { (exit 1); exit 1; }; }
22207 fi
22208 cat >conftest.$ac_ext <<_ACEOF
22209 /* confdefs.h.  */
22210 _ACEOF
22211 cat confdefs.h >>conftest.$ac_ext
22212 cat >>conftest.$ac_ext <<_ACEOF
22213 /* end confdefs.h.  */
22214
22215 /* Override any gcc2 internal prototype to avoid an error.  */
22216 #ifdef __cplusplus
22217 extern "C"
22218 #endif
22219 /* We use char because int might match the return type of a gcc2
22220    builtin and then its argument prototype would still apply.  */
22221 char jn ();
22222 int
22223 main ()
22224 {
22225 jn ();
22226   ;
22227   return 0;
22228 }
22229 _ACEOF
22230 rm -f conftest.$ac_objext conftest$ac_exeext
22231 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22232   (eval $ac_link) 2>conftest.er1
22233   ac_status=$?
22234   grep -v '^ *+' conftest.er1 >conftest.err
22235   rm -f conftest.er1
22236   cat conftest.err >&5
22237   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22238   (exit $ac_status); } &&
22239          { ac_try='test -z "$ac_c_werror_flag"
22240                          || test ! -s conftest.err'
22241   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22242   (eval $ac_try) 2>&5
22243   ac_status=$?
22244   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22245   (exit $ac_status); }; } &&
22246          { ac_try='test -s conftest$ac_exeext'
22247   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22248   (eval $ac_try) 2>&5
22249   ac_status=$?
22250   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22251   (exit $ac_status); }; }; then
22252   ac_cv_lib_m_jn=yes
22253 else
22254   echo "$as_me: failed program was:" >&5
22255 sed 's/^/| /' conftest.$ac_ext >&5
22256
22257 ac_cv_lib_m_jn=no
22258 fi
22259 rm -f conftest.err conftest.$ac_objext \
22260       conftest$ac_exeext conftest.$ac_ext
22261 LIBS=$ac_check_lib_save_LIBS
22262 fi
22263 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jn" >&5
22264 echo "${ECHO_T}$ac_cv_lib_m_jn" >&6
22265 if test $ac_cv_lib_m_jn = yes; then
22266
22267 cat >>confdefs.h <<\_ACEOF
22268 #define HAVE_JN 1
22269 _ACEOF
22270
22271 fi
22272
22273 echo "$as_me:$LINENO: checking for jnl in -lm" >&5
22274 echo $ECHO_N "checking for jnl in -lm... $ECHO_C" >&6
22275 if test "${ac_cv_lib_m_jnl+set}" = set; then
22276   echo $ECHO_N "(cached) $ECHO_C" >&6
22277 else
22278   ac_check_lib_save_LIBS=$LIBS
22279 LIBS="-lm  $LIBS"
22280 if test x$gcc_no_link = xyes; then
22281   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22282 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22283    { (exit 1); exit 1; }; }
22284 fi
22285 cat >conftest.$ac_ext <<_ACEOF
22286 /* confdefs.h.  */
22287 _ACEOF
22288 cat confdefs.h >>conftest.$ac_ext
22289 cat >>conftest.$ac_ext <<_ACEOF
22290 /* end confdefs.h.  */
22291
22292 /* Override any gcc2 internal prototype to avoid an error.  */
22293 #ifdef __cplusplus
22294 extern "C"
22295 #endif
22296 /* We use char because int might match the return type of a gcc2
22297    builtin and then its argument prototype would still apply.  */
22298 char jnl ();
22299 int
22300 main ()
22301 {
22302 jnl ();
22303   ;
22304   return 0;
22305 }
22306 _ACEOF
22307 rm -f conftest.$ac_objext conftest$ac_exeext
22308 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22309   (eval $ac_link) 2>conftest.er1
22310   ac_status=$?
22311   grep -v '^ *+' conftest.er1 >conftest.err
22312   rm -f conftest.er1
22313   cat conftest.err >&5
22314   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22315   (exit $ac_status); } &&
22316          { ac_try='test -z "$ac_c_werror_flag"
22317                          || test ! -s conftest.err'
22318   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22319   (eval $ac_try) 2>&5
22320   ac_status=$?
22321   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22322   (exit $ac_status); }; } &&
22323          { ac_try='test -s conftest$ac_exeext'
22324   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22325   (eval $ac_try) 2>&5
22326   ac_status=$?
22327   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22328   (exit $ac_status); }; }; then
22329   ac_cv_lib_m_jnl=yes
22330 else
22331   echo "$as_me: failed program was:" >&5
22332 sed 's/^/| /' conftest.$ac_ext >&5
22333
22334 ac_cv_lib_m_jnl=no
22335 fi
22336 rm -f conftest.err conftest.$ac_objext \
22337       conftest$ac_exeext conftest.$ac_ext
22338 LIBS=$ac_check_lib_save_LIBS
22339 fi
22340 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jnl" >&5
22341 echo "${ECHO_T}$ac_cv_lib_m_jnl" >&6
22342 if test $ac_cv_lib_m_jnl = yes; then
22343
22344 cat >>confdefs.h <<\_ACEOF
22345 #define HAVE_JNL 1
22346 _ACEOF
22347
22348 fi
22349
22350 echo "$as_me:$LINENO: checking for y0f in -lm" >&5
22351 echo $ECHO_N "checking for y0f in -lm... $ECHO_C" >&6
22352 if test "${ac_cv_lib_m_y0f+set}" = set; then
22353   echo $ECHO_N "(cached) $ECHO_C" >&6
22354 else
22355   ac_check_lib_save_LIBS=$LIBS
22356 LIBS="-lm  $LIBS"
22357 if test x$gcc_no_link = xyes; then
22358   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22359 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22360    { (exit 1); exit 1; }; }
22361 fi
22362 cat >conftest.$ac_ext <<_ACEOF
22363 /* confdefs.h.  */
22364 _ACEOF
22365 cat confdefs.h >>conftest.$ac_ext
22366 cat >>conftest.$ac_ext <<_ACEOF
22367 /* end confdefs.h.  */
22368
22369 /* Override any gcc2 internal prototype to avoid an error.  */
22370 #ifdef __cplusplus
22371 extern "C"
22372 #endif
22373 /* We use char because int might match the return type of a gcc2
22374    builtin and then its argument prototype would still apply.  */
22375 char y0f ();
22376 int
22377 main ()
22378 {
22379 y0f ();
22380   ;
22381   return 0;
22382 }
22383 _ACEOF
22384 rm -f conftest.$ac_objext conftest$ac_exeext
22385 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22386   (eval $ac_link) 2>conftest.er1
22387   ac_status=$?
22388   grep -v '^ *+' conftest.er1 >conftest.err
22389   rm -f conftest.er1
22390   cat conftest.err >&5
22391   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22392   (exit $ac_status); } &&
22393          { ac_try='test -z "$ac_c_werror_flag"
22394                          || test ! -s conftest.err'
22395   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22396   (eval $ac_try) 2>&5
22397   ac_status=$?
22398   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22399   (exit $ac_status); }; } &&
22400          { ac_try='test -s conftest$ac_exeext'
22401   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22402   (eval $ac_try) 2>&5
22403   ac_status=$?
22404   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22405   (exit $ac_status); }; }; then
22406   ac_cv_lib_m_y0f=yes
22407 else
22408   echo "$as_me: failed program was:" >&5
22409 sed 's/^/| /' conftest.$ac_ext >&5
22410
22411 ac_cv_lib_m_y0f=no
22412 fi
22413 rm -f conftest.err conftest.$ac_objext \
22414       conftest$ac_exeext conftest.$ac_ext
22415 LIBS=$ac_check_lib_save_LIBS
22416 fi
22417 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0f" >&5
22418 echo "${ECHO_T}$ac_cv_lib_m_y0f" >&6
22419 if test $ac_cv_lib_m_y0f = yes; then
22420
22421 cat >>confdefs.h <<\_ACEOF
22422 #define HAVE_Y0F 1
22423 _ACEOF
22424
22425 fi
22426
22427 echo "$as_me:$LINENO: checking for y0 in -lm" >&5
22428 echo $ECHO_N "checking for y0 in -lm... $ECHO_C" >&6
22429 if test "${ac_cv_lib_m_y0+set}" = set; then
22430   echo $ECHO_N "(cached) $ECHO_C" >&6
22431 else
22432   ac_check_lib_save_LIBS=$LIBS
22433 LIBS="-lm  $LIBS"
22434 if test x$gcc_no_link = xyes; then
22435   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22436 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22437    { (exit 1); exit 1; }; }
22438 fi
22439 cat >conftest.$ac_ext <<_ACEOF
22440 /* confdefs.h.  */
22441 _ACEOF
22442 cat confdefs.h >>conftest.$ac_ext
22443 cat >>conftest.$ac_ext <<_ACEOF
22444 /* end confdefs.h.  */
22445
22446 /* Override any gcc2 internal prototype to avoid an error.  */
22447 #ifdef __cplusplus
22448 extern "C"
22449 #endif
22450 /* We use char because int might match the return type of a gcc2
22451    builtin and then its argument prototype would still apply.  */
22452 char y0 ();
22453 int
22454 main ()
22455 {
22456 y0 ();
22457   ;
22458   return 0;
22459 }
22460 _ACEOF
22461 rm -f conftest.$ac_objext conftest$ac_exeext
22462 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22463   (eval $ac_link) 2>conftest.er1
22464   ac_status=$?
22465   grep -v '^ *+' conftest.er1 >conftest.err
22466   rm -f conftest.er1
22467   cat conftest.err >&5
22468   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22469   (exit $ac_status); } &&
22470          { ac_try='test -z "$ac_c_werror_flag"
22471                          || test ! -s conftest.err'
22472   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22473   (eval $ac_try) 2>&5
22474   ac_status=$?
22475   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22476   (exit $ac_status); }; } &&
22477          { ac_try='test -s conftest$ac_exeext'
22478   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22479   (eval $ac_try) 2>&5
22480   ac_status=$?
22481   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22482   (exit $ac_status); }; }; then
22483   ac_cv_lib_m_y0=yes
22484 else
22485   echo "$as_me: failed program was:" >&5
22486 sed 's/^/| /' conftest.$ac_ext >&5
22487
22488 ac_cv_lib_m_y0=no
22489 fi
22490 rm -f conftest.err conftest.$ac_objext \
22491       conftest$ac_exeext conftest.$ac_ext
22492 LIBS=$ac_check_lib_save_LIBS
22493 fi
22494 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0" >&5
22495 echo "${ECHO_T}$ac_cv_lib_m_y0" >&6
22496 if test $ac_cv_lib_m_y0 = yes; then
22497
22498 cat >>confdefs.h <<\_ACEOF
22499 #define HAVE_Y0 1
22500 _ACEOF
22501
22502 fi
22503
22504 echo "$as_me:$LINENO: checking for y0l in -lm" >&5
22505 echo $ECHO_N "checking for y0l in -lm... $ECHO_C" >&6
22506 if test "${ac_cv_lib_m_y0l+set}" = set; then
22507   echo $ECHO_N "(cached) $ECHO_C" >&6
22508 else
22509   ac_check_lib_save_LIBS=$LIBS
22510 LIBS="-lm  $LIBS"
22511 if test x$gcc_no_link = xyes; then
22512   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22513 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22514    { (exit 1); exit 1; }; }
22515 fi
22516 cat >conftest.$ac_ext <<_ACEOF
22517 /* confdefs.h.  */
22518 _ACEOF
22519 cat confdefs.h >>conftest.$ac_ext
22520 cat >>conftest.$ac_ext <<_ACEOF
22521 /* end confdefs.h.  */
22522
22523 /* Override any gcc2 internal prototype to avoid an error.  */
22524 #ifdef __cplusplus
22525 extern "C"
22526 #endif
22527 /* We use char because int might match the return type of a gcc2
22528    builtin and then its argument prototype would still apply.  */
22529 char y0l ();
22530 int
22531 main ()
22532 {
22533 y0l ();
22534   ;
22535   return 0;
22536 }
22537 _ACEOF
22538 rm -f conftest.$ac_objext conftest$ac_exeext
22539 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22540   (eval $ac_link) 2>conftest.er1
22541   ac_status=$?
22542   grep -v '^ *+' conftest.er1 >conftest.err
22543   rm -f conftest.er1
22544   cat conftest.err >&5
22545   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22546   (exit $ac_status); } &&
22547          { ac_try='test -z "$ac_c_werror_flag"
22548                          || test ! -s conftest.err'
22549   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22550   (eval $ac_try) 2>&5
22551   ac_status=$?
22552   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22553   (exit $ac_status); }; } &&
22554          { ac_try='test -s conftest$ac_exeext'
22555   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22556   (eval $ac_try) 2>&5
22557   ac_status=$?
22558   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22559   (exit $ac_status); }; }; then
22560   ac_cv_lib_m_y0l=yes
22561 else
22562   echo "$as_me: failed program was:" >&5
22563 sed 's/^/| /' conftest.$ac_ext >&5
22564
22565 ac_cv_lib_m_y0l=no
22566 fi
22567 rm -f conftest.err conftest.$ac_objext \
22568       conftest$ac_exeext conftest.$ac_ext
22569 LIBS=$ac_check_lib_save_LIBS
22570 fi
22571 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0l" >&5
22572 echo "${ECHO_T}$ac_cv_lib_m_y0l" >&6
22573 if test $ac_cv_lib_m_y0l = yes; then
22574
22575 cat >>confdefs.h <<\_ACEOF
22576 #define HAVE_Y0L 1
22577 _ACEOF
22578
22579 fi
22580
22581 echo "$as_me:$LINENO: checking for y1f in -lm" >&5
22582 echo $ECHO_N "checking for y1f in -lm... $ECHO_C" >&6
22583 if test "${ac_cv_lib_m_y1f+set}" = set; then
22584   echo $ECHO_N "(cached) $ECHO_C" >&6
22585 else
22586   ac_check_lib_save_LIBS=$LIBS
22587 LIBS="-lm  $LIBS"
22588 if test x$gcc_no_link = xyes; then
22589   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22590 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22591    { (exit 1); exit 1; }; }
22592 fi
22593 cat >conftest.$ac_ext <<_ACEOF
22594 /* confdefs.h.  */
22595 _ACEOF
22596 cat confdefs.h >>conftest.$ac_ext
22597 cat >>conftest.$ac_ext <<_ACEOF
22598 /* end confdefs.h.  */
22599
22600 /* Override any gcc2 internal prototype to avoid an error.  */
22601 #ifdef __cplusplus
22602 extern "C"
22603 #endif
22604 /* We use char because int might match the return type of a gcc2
22605    builtin and then its argument prototype would still apply.  */
22606 char y1f ();
22607 int
22608 main ()
22609 {
22610 y1f ();
22611   ;
22612   return 0;
22613 }
22614 _ACEOF
22615 rm -f conftest.$ac_objext conftest$ac_exeext
22616 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22617   (eval $ac_link) 2>conftest.er1
22618   ac_status=$?
22619   grep -v '^ *+' conftest.er1 >conftest.err
22620   rm -f conftest.er1
22621   cat conftest.err >&5
22622   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22623   (exit $ac_status); } &&
22624          { ac_try='test -z "$ac_c_werror_flag"
22625                          || test ! -s conftest.err'
22626   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22627   (eval $ac_try) 2>&5
22628   ac_status=$?
22629   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22630   (exit $ac_status); }; } &&
22631          { ac_try='test -s conftest$ac_exeext'
22632   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22633   (eval $ac_try) 2>&5
22634   ac_status=$?
22635   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22636   (exit $ac_status); }; }; then
22637   ac_cv_lib_m_y1f=yes
22638 else
22639   echo "$as_me: failed program was:" >&5
22640 sed 's/^/| /' conftest.$ac_ext >&5
22641
22642 ac_cv_lib_m_y1f=no
22643 fi
22644 rm -f conftest.err conftest.$ac_objext \
22645       conftest$ac_exeext conftest.$ac_ext
22646 LIBS=$ac_check_lib_save_LIBS
22647 fi
22648 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1f" >&5
22649 echo "${ECHO_T}$ac_cv_lib_m_y1f" >&6
22650 if test $ac_cv_lib_m_y1f = yes; then
22651
22652 cat >>confdefs.h <<\_ACEOF
22653 #define HAVE_Y1F 1
22654 _ACEOF
22655
22656 fi
22657
22658 echo "$as_me:$LINENO: checking for y1 in -lm" >&5
22659 echo $ECHO_N "checking for y1 in -lm... $ECHO_C" >&6
22660 if test "${ac_cv_lib_m_y1+set}" = set; then
22661   echo $ECHO_N "(cached) $ECHO_C" >&6
22662 else
22663   ac_check_lib_save_LIBS=$LIBS
22664 LIBS="-lm  $LIBS"
22665 if test x$gcc_no_link = xyes; then
22666   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22667 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22668    { (exit 1); exit 1; }; }
22669 fi
22670 cat >conftest.$ac_ext <<_ACEOF
22671 /* confdefs.h.  */
22672 _ACEOF
22673 cat confdefs.h >>conftest.$ac_ext
22674 cat >>conftest.$ac_ext <<_ACEOF
22675 /* end confdefs.h.  */
22676
22677 /* Override any gcc2 internal prototype to avoid an error.  */
22678 #ifdef __cplusplus
22679 extern "C"
22680 #endif
22681 /* We use char because int might match the return type of a gcc2
22682    builtin and then its argument prototype would still apply.  */
22683 char y1 ();
22684 int
22685 main ()
22686 {
22687 y1 ();
22688   ;
22689   return 0;
22690 }
22691 _ACEOF
22692 rm -f conftest.$ac_objext conftest$ac_exeext
22693 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22694   (eval $ac_link) 2>conftest.er1
22695   ac_status=$?
22696   grep -v '^ *+' conftest.er1 >conftest.err
22697   rm -f conftest.er1
22698   cat conftest.err >&5
22699   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22700   (exit $ac_status); } &&
22701          { ac_try='test -z "$ac_c_werror_flag"
22702                          || test ! -s conftest.err'
22703   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22704   (eval $ac_try) 2>&5
22705   ac_status=$?
22706   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22707   (exit $ac_status); }; } &&
22708          { ac_try='test -s conftest$ac_exeext'
22709   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22710   (eval $ac_try) 2>&5
22711   ac_status=$?
22712   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22713   (exit $ac_status); }; }; then
22714   ac_cv_lib_m_y1=yes
22715 else
22716   echo "$as_me: failed program was:" >&5
22717 sed 's/^/| /' conftest.$ac_ext >&5
22718
22719 ac_cv_lib_m_y1=no
22720 fi
22721 rm -f conftest.err conftest.$ac_objext \
22722       conftest$ac_exeext conftest.$ac_ext
22723 LIBS=$ac_check_lib_save_LIBS
22724 fi
22725 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1" >&5
22726 echo "${ECHO_T}$ac_cv_lib_m_y1" >&6
22727 if test $ac_cv_lib_m_y1 = yes; then
22728
22729 cat >>confdefs.h <<\_ACEOF
22730 #define HAVE_Y1 1
22731 _ACEOF
22732
22733 fi
22734
22735 echo "$as_me:$LINENO: checking for y1l in -lm" >&5
22736 echo $ECHO_N "checking for y1l in -lm... $ECHO_C" >&6
22737 if test "${ac_cv_lib_m_y1l+set}" = set; then
22738   echo $ECHO_N "(cached) $ECHO_C" >&6
22739 else
22740   ac_check_lib_save_LIBS=$LIBS
22741 LIBS="-lm  $LIBS"
22742 if test x$gcc_no_link = xyes; then
22743   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22744 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22745    { (exit 1); exit 1; }; }
22746 fi
22747 cat >conftest.$ac_ext <<_ACEOF
22748 /* confdefs.h.  */
22749 _ACEOF
22750 cat confdefs.h >>conftest.$ac_ext
22751 cat >>conftest.$ac_ext <<_ACEOF
22752 /* end confdefs.h.  */
22753
22754 /* Override any gcc2 internal prototype to avoid an error.  */
22755 #ifdef __cplusplus
22756 extern "C"
22757 #endif
22758 /* We use char because int might match the return type of a gcc2
22759    builtin and then its argument prototype would still apply.  */
22760 char y1l ();
22761 int
22762 main ()
22763 {
22764 y1l ();
22765   ;
22766   return 0;
22767 }
22768 _ACEOF
22769 rm -f conftest.$ac_objext conftest$ac_exeext
22770 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22771   (eval $ac_link) 2>conftest.er1
22772   ac_status=$?
22773   grep -v '^ *+' conftest.er1 >conftest.err
22774   rm -f conftest.er1
22775   cat conftest.err >&5
22776   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22777   (exit $ac_status); } &&
22778          { ac_try='test -z "$ac_c_werror_flag"
22779                          || test ! -s conftest.err'
22780   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22781   (eval $ac_try) 2>&5
22782   ac_status=$?
22783   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22784   (exit $ac_status); }; } &&
22785          { ac_try='test -s conftest$ac_exeext'
22786   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22787   (eval $ac_try) 2>&5
22788   ac_status=$?
22789   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22790   (exit $ac_status); }; }; then
22791   ac_cv_lib_m_y1l=yes
22792 else
22793   echo "$as_me: failed program was:" >&5
22794 sed 's/^/| /' conftest.$ac_ext >&5
22795
22796 ac_cv_lib_m_y1l=no
22797 fi
22798 rm -f conftest.err conftest.$ac_objext \
22799       conftest$ac_exeext conftest.$ac_ext
22800 LIBS=$ac_check_lib_save_LIBS
22801 fi
22802 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1l" >&5
22803 echo "${ECHO_T}$ac_cv_lib_m_y1l" >&6
22804 if test $ac_cv_lib_m_y1l = yes; then
22805
22806 cat >>confdefs.h <<\_ACEOF
22807 #define HAVE_Y1L 1
22808 _ACEOF
22809
22810 fi
22811
22812 echo "$as_me:$LINENO: checking for ynf in -lm" >&5
22813 echo $ECHO_N "checking for ynf in -lm... $ECHO_C" >&6
22814 if test "${ac_cv_lib_m_ynf+set}" = set; then
22815   echo $ECHO_N "(cached) $ECHO_C" >&6
22816 else
22817   ac_check_lib_save_LIBS=$LIBS
22818 LIBS="-lm  $LIBS"
22819 if test x$gcc_no_link = xyes; then
22820   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22821 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22822    { (exit 1); exit 1; }; }
22823 fi
22824 cat >conftest.$ac_ext <<_ACEOF
22825 /* confdefs.h.  */
22826 _ACEOF
22827 cat confdefs.h >>conftest.$ac_ext
22828 cat >>conftest.$ac_ext <<_ACEOF
22829 /* end confdefs.h.  */
22830
22831 /* Override any gcc2 internal prototype to avoid an error.  */
22832 #ifdef __cplusplus
22833 extern "C"
22834 #endif
22835 /* We use char because int might match the return type of a gcc2
22836    builtin and then its argument prototype would still apply.  */
22837 char ynf ();
22838 int
22839 main ()
22840 {
22841 ynf ();
22842   ;
22843   return 0;
22844 }
22845 _ACEOF
22846 rm -f conftest.$ac_objext conftest$ac_exeext
22847 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22848   (eval $ac_link) 2>conftest.er1
22849   ac_status=$?
22850   grep -v '^ *+' conftest.er1 >conftest.err
22851   rm -f conftest.er1
22852   cat conftest.err >&5
22853   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22854   (exit $ac_status); } &&
22855          { ac_try='test -z "$ac_c_werror_flag"
22856                          || test ! -s conftest.err'
22857   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22858   (eval $ac_try) 2>&5
22859   ac_status=$?
22860   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22861   (exit $ac_status); }; } &&
22862          { ac_try='test -s conftest$ac_exeext'
22863   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22864   (eval $ac_try) 2>&5
22865   ac_status=$?
22866   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22867   (exit $ac_status); }; }; then
22868   ac_cv_lib_m_ynf=yes
22869 else
22870   echo "$as_me: failed program was:" >&5
22871 sed 's/^/| /' conftest.$ac_ext >&5
22872
22873 ac_cv_lib_m_ynf=no
22874 fi
22875 rm -f conftest.err conftest.$ac_objext \
22876       conftest$ac_exeext conftest.$ac_ext
22877 LIBS=$ac_check_lib_save_LIBS
22878 fi
22879 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ynf" >&5
22880 echo "${ECHO_T}$ac_cv_lib_m_ynf" >&6
22881 if test $ac_cv_lib_m_ynf = yes; then
22882
22883 cat >>confdefs.h <<\_ACEOF
22884 #define HAVE_YNF 1
22885 _ACEOF
22886
22887 fi
22888
22889 echo "$as_me:$LINENO: checking for yn in -lm" >&5
22890 echo $ECHO_N "checking for yn in -lm... $ECHO_C" >&6
22891 if test "${ac_cv_lib_m_yn+set}" = set; then
22892   echo $ECHO_N "(cached) $ECHO_C" >&6
22893 else
22894   ac_check_lib_save_LIBS=$LIBS
22895 LIBS="-lm  $LIBS"
22896 if test x$gcc_no_link = xyes; then
22897   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22898 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22899    { (exit 1); exit 1; }; }
22900 fi
22901 cat >conftest.$ac_ext <<_ACEOF
22902 /* confdefs.h.  */
22903 _ACEOF
22904 cat confdefs.h >>conftest.$ac_ext
22905 cat >>conftest.$ac_ext <<_ACEOF
22906 /* end confdefs.h.  */
22907
22908 /* Override any gcc2 internal prototype to avoid an error.  */
22909 #ifdef __cplusplus
22910 extern "C"
22911 #endif
22912 /* We use char because int might match the return type of a gcc2
22913    builtin and then its argument prototype would still apply.  */
22914 char yn ();
22915 int
22916 main ()
22917 {
22918 yn ();
22919   ;
22920   return 0;
22921 }
22922 _ACEOF
22923 rm -f conftest.$ac_objext conftest$ac_exeext
22924 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22925   (eval $ac_link) 2>conftest.er1
22926   ac_status=$?
22927   grep -v '^ *+' conftest.er1 >conftest.err
22928   rm -f conftest.er1
22929   cat conftest.err >&5
22930   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22931   (exit $ac_status); } &&
22932          { ac_try='test -z "$ac_c_werror_flag"
22933                          || test ! -s conftest.err'
22934   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22935   (eval $ac_try) 2>&5
22936   ac_status=$?
22937   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22938   (exit $ac_status); }; } &&
22939          { ac_try='test -s conftest$ac_exeext'
22940   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22941   (eval $ac_try) 2>&5
22942   ac_status=$?
22943   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22944   (exit $ac_status); }; }; then
22945   ac_cv_lib_m_yn=yes
22946 else
22947   echo "$as_me: failed program was:" >&5
22948 sed 's/^/| /' conftest.$ac_ext >&5
22949
22950 ac_cv_lib_m_yn=no
22951 fi
22952 rm -f conftest.err conftest.$ac_objext \
22953       conftest$ac_exeext conftest.$ac_ext
22954 LIBS=$ac_check_lib_save_LIBS
22955 fi
22956 echo "$as_me:$LINENO: result: $ac_cv_lib_m_yn" >&5
22957 echo "${ECHO_T}$ac_cv_lib_m_yn" >&6
22958 if test $ac_cv_lib_m_yn = yes; then
22959
22960 cat >>confdefs.h <<\_ACEOF
22961 #define HAVE_YN 1
22962 _ACEOF
22963
22964 fi
22965
22966 echo "$as_me:$LINENO: checking for ynl in -lm" >&5
22967 echo $ECHO_N "checking for ynl in -lm... $ECHO_C" >&6
22968 if test "${ac_cv_lib_m_ynl+set}" = set; then
22969   echo $ECHO_N "(cached) $ECHO_C" >&6
22970 else
22971   ac_check_lib_save_LIBS=$LIBS
22972 LIBS="-lm  $LIBS"
22973 if test x$gcc_no_link = xyes; then
22974   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22975 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22976    { (exit 1); exit 1; }; }
22977 fi
22978 cat >conftest.$ac_ext <<_ACEOF
22979 /* confdefs.h.  */
22980 _ACEOF
22981 cat confdefs.h >>conftest.$ac_ext
22982 cat >>conftest.$ac_ext <<_ACEOF
22983 /* end confdefs.h.  */
22984
22985 /* Override any gcc2 internal prototype to avoid an error.  */
22986 #ifdef __cplusplus
22987 extern "C"
22988 #endif
22989 /* We use char because int might match the return type of a gcc2
22990    builtin and then its argument prototype would still apply.  */
22991 char ynl ();
22992 int
22993 main ()
22994 {
22995 ynl ();
22996   ;
22997   return 0;
22998 }
22999 _ACEOF
23000 rm -f conftest.$ac_objext conftest$ac_exeext
23001 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23002   (eval $ac_link) 2>conftest.er1
23003   ac_status=$?
23004   grep -v '^ *+' conftest.er1 >conftest.err
23005   rm -f conftest.er1
23006   cat conftest.err >&5
23007   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23008   (exit $ac_status); } &&
23009          { ac_try='test -z "$ac_c_werror_flag"
23010                          || test ! -s conftest.err'
23011   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23012   (eval $ac_try) 2>&5
23013   ac_status=$?
23014   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23015   (exit $ac_status); }; } &&
23016          { ac_try='test -s conftest$ac_exeext'
23017   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23018   (eval $ac_try) 2>&5
23019   ac_status=$?
23020   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23021   (exit $ac_status); }; }; then
23022   ac_cv_lib_m_ynl=yes
23023 else
23024   echo "$as_me: failed program was:" >&5
23025 sed 's/^/| /' conftest.$ac_ext >&5
23026
23027 ac_cv_lib_m_ynl=no
23028 fi
23029 rm -f conftest.err conftest.$ac_objext \
23030       conftest$ac_exeext conftest.$ac_ext
23031 LIBS=$ac_check_lib_save_LIBS
23032 fi
23033 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ynl" >&5
23034 echo "${ECHO_T}$ac_cv_lib_m_ynl" >&6
23035 if test $ac_cv_lib_m_ynl = yes; then
23036
23037 cat >>confdefs.h <<\_ACEOF
23038 #define HAVE_YNL 1
23039 _ACEOF
23040
23041 fi
23042
23043
23044 # On AIX, clog is present in libm as __clog
23045 echo "$as_me:$LINENO: checking for __clog in -lm" >&5
23046 echo $ECHO_N "checking for __clog in -lm... $ECHO_C" >&6
23047 if test "${ac_cv_lib_m___clog+set}" = set; then
23048   echo $ECHO_N "(cached) $ECHO_C" >&6
23049 else
23050   ac_check_lib_save_LIBS=$LIBS
23051 LIBS="-lm  $LIBS"
23052 if test x$gcc_no_link = xyes; then
23053   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23054 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23055    { (exit 1); exit 1; }; }
23056 fi
23057 cat >conftest.$ac_ext <<_ACEOF
23058 /* confdefs.h.  */
23059 _ACEOF
23060 cat confdefs.h >>conftest.$ac_ext
23061 cat >>conftest.$ac_ext <<_ACEOF
23062 /* end confdefs.h.  */
23063
23064 /* Override any gcc2 internal prototype to avoid an error.  */
23065 #ifdef __cplusplus
23066 extern "C"
23067 #endif
23068 /* We use char because int might match the return type of a gcc2
23069    builtin and then its argument prototype would still apply.  */
23070 char __clog ();
23071 int
23072 main ()
23073 {
23074 __clog ();
23075   ;
23076   return 0;
23077 }
23078 _ACEOF
23079 rm -f conftest.$ac_objext conftest$ac_exeext
23080 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23081   (eval $ac_link) 2>conftest.er1
23082   ac_status=$?
23083   grep -v '^ *+' conftest.er1 >conftest.err
23084   rm -f conftest.er1
23085   cat conftest.err >&5
23086   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23087   (exit $ac_status); } &&
23088          { ac_try='test -z "$ac_c_werror_flag"
23089                          || test ! -s conftest.err'
23090   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23091   (eval $ac_try) 2>&5
23092   ac_status=$?
23093   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23094   (exit $ac_status); }; } &&
23095          { ac_try='test -s conftest$ac_exeext'
23096   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23097   (eval $ac_try) 2>&5
23098   ac_status=$?
23099   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23100   (exit $ac_status); }; }; then
23101   ac_cv_lib_m___clog=yes
23102 else
23103   echo "$as_me: failed program was:" >&5
23104 sed 's/^/| /' conftest.$ac_ext >&5
23105
23106 ac_cv_lib_m___clog=no
23107 fi
23108 rm -f conftest.err conftest.$ac_objext \
23109       conftest$ac_exeext conftest.$ac_ext
23110 LIBS=$ac_check_lib_save_LIBS
23111 fi
23112 echo "$as_me:$LINENO: result: $ac_cv_lib_m___clog" >&5
23113 echo "${ECHO_T}$ac_cv_lib_m___clog" >&6
23114 if test $ac_cv_lib_m___clog = yes; then
23115
23116 cat >>confdefs.h <<\_ACEOF
23117 #define HAVE_CLOG 1
23118 _ACEOF
23119
23120 fi
23121
23122
23123 # Check for a isfinite macro that works on long doubles.
23124
23125   echo "$as_me:$LINENO: checking whether isfinite is broken" >&5
23126 echo $ECHO_N "checking whether isfinite is broken... $ECHO_C" >&6
23127 if test "${have_broken_isfinite+set}" = set; then
23128   echo $ECHO_N "(cached) $ECHO_C" >&6
23129 else
23130
23131   libgfor_check_for_broken_isfinite_save_LIBS=$LIBS
23132   LIBS="$LIBS -lm"
23133   if test "$cross_compiling" = yes; then
23134
23135 case "${target}" in
23136   hppa*-*-hpux*) have_broken_isfinite=yes ;;
23137   *) have_broken_isfinite=no ;;
23138 esac
23139 else
23140   cat >conftest.$ac_ext <<_ACEOF
23141 /* confdefs.h.  */
23142 _ACEOF
23143 cat confdefs.h >>conftest.$ac_ext
23144 cat >>conftest.$ac_ext <<_ACEOF
23145 /* end confdefs.h.  */
23146
23147 #ifdef HAVE_MATH_H
23148 #include <math.h>
23149 #endif
23150 #include <float.h>
23151 int main ()
23152 {
23153 #ifdef isfinite
23154 #ifdef LDBL_MAX
23155   if (!isfinite(LDBL_MAX)) return 1;
23156 #endif
23157 #ifdef DBL_MAX
23158   if (!isfinite(DBL_MAX)) return 1;
23159 #endif
23160 #endif
23161 return 0;
23162 }
23163 _ACEOF
23164 rm -f conftest$ac_exeext
23165 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23166   (eval $ac_link) 2>&5
23167   ac_status=$?
23168   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23169   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
23170   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23171   (eval $ac_try) 2>&5
23172   ac_status=$?
23173   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23174   (exit $ac_status); }; }; then
23175   have_broken_isfinite=no
23176 else
23177   echo "$as_me: program exited with status $ac_status" >&5
23178 echo "$as_me: failed program was:" >&5
23179 sed 's/^/| /' conftest.$ac_ext >&5
23180
23181 ( exit $ac_status )
23182 have_broken_isfinite=yes
23183 fi
23184 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23185 fi
23186   LIBS=$libgfor_check_for_broken_isfinite_save_LIBS
23187 fi
23188 echo "$as_me:$LINENO: result: $have_broken_isfinite" >&5
23189 echo "${ECHO_T}$have_broken_isfinite" >&6
23190 if test x"$have_broken_isfinite" = xyes; then
23191
23192 cat >>confdefs.h <<\_ACEOF
23193 #define HAVE_BROKEN_ISFINITE 1
23194 _ACEOF
23195
23196 fi
23197
23198 # Check for a isnan macro that works on long doubles.
23199
23200   echo "$as_me:$LINENO: checking whether isnan is broken" >&5
23201 echo $ECHO_N "checking whether isnan is broken... $ECHO_C" >&6
23202 if test "${have_broken_isnan+set}" = set; then
23203   echo $ECHO_N "(cached) $ECHO_C" >&6
23204 else
23205
23206   libgfor_check_for_broken_isnan_save_LIBS=$LIBS
23207   LIBS="$LIBS -lm"
23208   if test "$cross_compiling" = yes; then
23209
23210 case "${target}" in
23211   hppa*-*-hpux*) have_broken_isnan=yes ;;
23212   *) have_broken_isnan=no ;;
23213 esac
23214 else
23215   cat >conftest.$ac_ext <<_ACEOF
23216 /* confdefs.h.  */
23217 _ACEOF
23218 cat confdefs.h >>conftest.$ac_ext
23219 cat >>conftest.$ac_ext <<_ACEOF
23220 /* end confdefs.h.  */
23221
23222 #ifdef HAVE_MATH_H
23223 #include <math.h>
23224 #endif
23225 #include <float.h>
23226 int main ()
23227 {
23228 #ifdef isnan
23229 #ifdef LDBL_MAX
23230   {
23231     long double x;
23232     x = __builtin_nanl ("");
23233     if (!isnan(x)) return 1;
23234     if (isnan(LDBL_MAX)) return 1;
23235 #ifdef NAN
23236     x = (long double) NAN;
23237     if (!isnan(x)) return 1;
23238 #endif
23239   }
23240 #endif
23241 #ifdef DBL_MAX
23242   {
23243     double y;
23244     y = __builtin_nan ("");
23245     if (!isnan(y)) return 1;
23246     if (isnan(DBL_MAX)) return 1;
23247 #ifdef NAN
23248     y = (double) NAN;
23249     if (!isnan(y)) return 1;
23250 #endif
23251   }
23252 #endif
23253 #endif
23254 return 0;
23255 }
23256 _ACEOF
23257 rm -f conftest$ac_exeext
23258 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23259   (eval $ac_link) 2>&5
23260   ac_status=$?
23261   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23262   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
23263   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23264   (eval $ac_try) 2>&5
23265   ac_status=$?
23266   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23267   (exit $ac_status); }; }; then
23268   have_broken_isnan=no
23269 else
23270   echo "$as_me: program exited with status $ac_status" >&5
23271 echo "$as_me: failed program was:" >&5
23272 sed 's/^/| /' conftest.$ac_ext >&5
23273
23274 ( exit $ac_status )
23275 have_broken_isnan=yes
23276 fi
23277 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23278 fi
23279   LIBS=$libgfor_check_for_broken_isnan_save_LIBS
23280 fi
23281 echo "$as_me:$LINENO: result: $have_broken_isnan" >&5
23282 echo "${ECHO_T}$have_broken_isnan" >&6
23283 if test x"$have_broken_isnan" = xyes; then
23284
23285 cat >>confdefs.h <<\_ACEOF
23286 #define HAVE_BROKEN_ISNAN 1
23287 _ACEOF
23288
23289 fi
23290
23291 # Check for a fpclassify macro that works on long doubles.
23292
23293   echo "$as_me:$LINENO: checking whether fpclassify is broken" >&5
23294 echo $ECHO_N "checking whether fpclassify is broken... $ECHO_C" >&6
23295 if test "${have_broken_fpclassify+set}" = set; then
23296   echo $ECHO_N "(cached) $ECHO_C" >&6
23297 else
23298
23299   libgfor_check_for_broken_fpclassify_save_LIBS=$LIBS
23300   LIBS="$LIBS -lm"
23301   if test "$cross_compiling" = yes; then
23302
23303 case "${target}" in
23304   hppa*-*-hpux*) have_broken_fpclassify=yes ;;
23305   *) have_broken_fpclassify=no ;;
23306 esac
23307 else
23308   cat >conftest.$ac_ext <<_ACEOF
23309 /* confdefs.h.  */
23310 _ACEOF
23311 cat confdefs.h >>conftest.$ac_ext
23312 cat >>conftest.$ac_ext <<_ACEOF
23313 /* end confdefs.h.  */
23314
23315 #ifdef HAVE_MATH_H
23316 #include <math.h>
23317 #endif
23318 #include <float.h>
23319 int main ()
23320 {
23321 #ifdef fpclassify
23322 #ifdef LDBL_MAX
23323         if (fpclassify(LDBL_MAX) == FP_NAN
23324             || fpclassify(LDBL_MAX) == FP_INFINITE) return 1;
23325 #endif
23326 #ifdef DBL_MAX
23327         if (fpclassify(DBL_MAX) == FP_NAN
23328             || fpclassify(DBL_MAX) == FP_INFINITE) return 1;
23329 #endif
23330 #endif
23331 return 0;
23332 }
23333 _ACEOF
23334 rm -f conftest$ac_exeext
23335 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23336   (eval $ac_link) 2>&5
23337   ac_status=$?
23338   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23339   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
23340   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23341   (eval $ac_try) 2>&5
23342   ac_status=$?
23343   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23344   (exit $ac_status); }; }; then
23345   have_broken_fpclassify=no
23346 else
23347   echo "$as_me: program exited with status $ac_status" >&5
23348 echo "$as_me: failed program was:" >&5
23349 sed 's/^/| /' conftest.$ac_ext >&5
23350
23351 ( exit $ac_status )
23352 have_broken_fpclassify=yes
23353 fi
23354 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23355 fi
23356   LIBS=$libgfor_check_for_broken_fpclassify_save_LIBS
23357 fi
23358 echo "$as_me:$LINENO: result: $have_broken_fpclassify" >&5
23359 echo "${ECHO_T}$have_broken_fpclassify" >&6
23360 if test x"$have_broken_fpclassify" = xyes; then
23361
23362 cat >>confdefs.h <<\_ACEOF
23363 #define HAVE_BROKEN_FPCLASSIFY 1
23364 _ACEOF
23365
23366 fi
23367
23368 # Check whether the system has a working stat()
23369
23370   echo "$as_me:$LINENO: checking whether the target stat is reliable" >&5
23371 echo $ECHO_N "checking whether the target stat is reliable... $ECHO_C" >&6
23372 if test "${have_working_stat+set}" = set; then
23373   echo $ECHO_N "(cached) $ECHO_C" >&6
23374 else
23375
23376   if test "$cross_compiling" = yes; then
23377
23378 case "${target}" in
23379   *mingw*) have_working_stat=no ;;
23380   *) have_working_stat=yes;;
23381 esac
23382 else
23383   cat >conftest.$ac_ext <<_ACEOF
23384 /* confdefs.h.  */
23385 _ACEOF
23386 cat confdefs.h >>conftest.$ac_ext
23387 cat >>conftest.$ac_ext <<_ACEOF
23388 /* end confdefs.h.  */
23389
23390 #include <stdio.h>
23391 #include <sys/types.h>
23392 #include <sys/stat.h>
23393 #include <unistd.h>
23394
23395 int main ()
23396 {
23397   FILE *f, *g;
23398   struct stat st1, st2;
23399
23400   f = fopen ("foo", "w");
23401   g = fopen ("bar", "w");
23402   if (stat ("foo", &st1) != 0 || stat ("bar", &st2))
23403     return 1;
23404   if (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino)
23405     return 1;
23406   fclose(f);
23407   fclose(g);
23408   return 0;
23409 }
23410 _ACEOF
23411 rm -f conftest$ac_exeext
23412 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23413   (eval $ac_link) 2>&5
23414   ac_status=$?
23415   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23416   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
23417   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23418   (eval $ac_try) 2>&5
23419   ac_status=$?
23420   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23421   (exit $ac_status); }; }; then
23422   have_working_stat=yes
23423 else
23424   echo "$as_me: program exited with status $ac_status" >&5
23425 echo "$as_me: failed program was:" >&5
23426 sed 's/^/| /' conftest.$ac_ext >&5
23427
23428 ( exit $ac_status )
23429 have_working_stat=no
23430 fi
23431 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23432 fi
23433 fi
23434 echo "$as_me:$LINENO: result: $have_working_stat" >&5
23435 echo "${ECHO_T}$have_working_stat" >&6
23436 if test x"$have_working_stat" = xyes; then
23437
23438 cat >>confdefs.h <<\_ACEOF
23439 #define HAVE_WORKING_STAT 1
23440 _ACEOF
23441
23442 fi
23443
23444 # Check for GNU libc feenableexcept
23445 echo "$as_me:$LINENO: checking for feenableexcept in -lm" >&5
23446 echo $ECHO_N "checking for feenableexcept in -lm... $ECHO_C" >&6
23447 if test "${ac_cv_lib_m_feenableexcept+set}" = set; then
23448   echo $ECHO_N "(cached) $ECHO_C" >&6
23449 else
23450   ac_check_lib_save_LIBS=$LIBS
23451 LIBS="-lm  $LIBS"
23452 if test x$gcc_no_link = xyes; then
23453   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23454 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23455    { (exit 1); exit 1; }; }
23456 fi
23457 cat >conftest.$ac_ext <<_ACEOF
23458 /* confdefs.h.  */
23459 _ACEOF
23460 cat confdefs.h >>conftest.$ac_ext
23461 cat >>conftest.$ac_ext <<_ACEOF
23462 /* end confdefs.h.  */
23463
23464 /* Override any gcc2 internal prototype to avoid an error.  */
23465 #ifdef __cplusplus
23466 extern "C"
23467 #endif
23468 /* We use char because int might match the return type of a gcc2
23469    builtin and then its argument prototype would still apply.  */
23470 char feenableexcept ();
23471 int
23472 main ()
23473 {
23474 feenableexcept ();
23475   ;
23476   return 0;
23477 }
23478 _ACEOF
23479 rm -f conftest.$ac_objext conftest$ac_exeext
23480 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23481   (eval $ac_link) 2>conftest.er1
23482   ac_status=$?
23483   grep -v '^ *+' conftest.er1 >conftest.err
23484   rm -f conftest.er1
23485   cat conftest.err >&5
23486   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23487   (exit $ac_status); } &&
23488          { ac_try='test -z "$ac_c_werror_flag"
23489                          || test ! -s conftest.err'
23490   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23491   (eval $ac_try) 2>&5
23492   ac_status=$?
23493   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23494   (exit $ac_status); }; } &&
23495          { ac_try='test -s conftest$ac_exeext'
23496   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23497   (eval $ac_try) 2>&5
23498   ac_status=$?
23499   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23500   (exit $ac_status); }; }; then
23501   ac_cv_lib_m_feenableexcept=yes
23502 else
23503   echo "$as_me: failed program was:" >&5
23504 sed 's/^/| /' conftest.$ac_ext >&5
23505
23506 ac_cv_lib_m_feenableexcept=no
23507 fi
23508 rm -f conftest.err conftest.$ac_objext \
23509       conftest$ac_exeext conftest.$ac_ext
23510 LIBS=$ac_check_lib_save_LIBS
23511 fi
23512 echo "$as_me:$LINENO: result: $ac_cv_lib_m_feenableexcept" >&5
23513 echo "${ECHO_T}$ac_cv_lib_m_feenableexcept" >&6
23514 if test $ac_cv_lib_m_feenableexcept = yes; then
23515   have_feenableexcept=yes
23516 cat >>confdefs.h <<\_ACEOF
23517 #define HAVE_FEENABLEEXCEPT 1
23518 _ACEOF
23519
23520 fi
23521
23522
23523 # Check for SysV fpsetmask
23524
23525   echo "$as_me:$LINENO: checking whether fpsetmask is present" >&5
23526 echo $ECHO_N "checking whether fpsetmask is present... $ECHO_C" >&6
23527 if test "${have_fpsetmask+set}" = set; then
23528   echo $ECHO_N "(cached) $ECHO_C" >&6
23529 else
23530
23531     if test x$gcc_no_link = xyes; then
23532   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23533 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23534    { (exit 1); exit 1; }; }
23535 fi
23536 cat >conftest.$ac_ext <<_ACEOF
23537 /* confdefs.h.  */
23538 _ACEOF
23539 cat confdefs.h >>conftest.$ac_ext
23540 cat >>conftest.$ac_ext <<_ACEOF
23541 /* end confdefs.h.  */
23542
23543 #if HAVE_FLOATINGPOINT_H
23544 # include <floatingpoint.h>
23545 #endif /* HAVE_FLOATINGPOINT_H */
23546 #if HAVE_IEEEFP_H
23547 # include <ieeefp.h>
23548 #endif /* HAVE_IEEEFP_H */
23549 int
23550 main ()
23551 {
23552 fpsetmask(0);
23553   ;
23554   return 0;
23555 }
23556 _ACEOF
23557 rm -f conftest.$ac_objext conftest$ac_exeext
23558 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23559   (eval $ac_link) 2>conftest.er1
23560   ac_status=$?
23561   grep -v '^ *+' conftest.er1 >conftest.err
23562   rm -f conftest.er1
23563   cat conftest.err >&5
23564   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23565   (exit $ac_status); } &&
23566          { ac_try='test -z "$ac_c_werror_flag"
23567                          || test ! -s conftest.err'
23568   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23569   (eval $ac_try) 2>&5
23570   ac_status=$?
23571   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23572   (exit $ac_status); }; } &&
23573          { ac_try='test -s conftest$ac_exeext'
23574   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23575   (eval $ac_try) 2>&5
23576   ac_status=$?
23577   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23578   (exit $ac_status); }; }; then
23579   eval "have_fpsetmask=yes"
23580 else
23581   echo "$as_me: failed program was:" >&5
23582 sed 's/^/| /' conftest.$ac_ext >&5
23583
23584 eval "have_fpsetmask=no"
23585 fi
23586 rm -f conftest.err conftest.$ac_objext \
23587       conftest$ac_exeext conftest.$ac_ext
23588
23589 fi
23590 echo "$as_me:$LINENO: result: $have_fpsetmask" >&5
23591 echo "${ECHO_T}$have_fpsetmask" >&6
23592   if test x"$have_fpsetmask" = xyes; then
23593
23594 cat >>confdefs.h <<\_ACEOF
23595 #define HAVE_FPSETMASK 1
23596 _ACEOF
23597
23598   fi
23599
23600
23601 # Check for AIX fp_trap and fp_enable
23602 echo "$as_me:$LINENO: checking for fp_trap" >&5
23603 echo $ECHO_N "checking for fp_trap... $ECHO_C" >&6
23604 if test "${ac_cv_func_fp_trap+set}" = set; then
23605   echo $ECHO_N "(cached) $ECHO_C" >&6
23606 else
23607   if test x$gcc_no_link = xyes; then
23608   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23609 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23610    { (exit 1); exit 1; }; }
23611 fi
23612 cat >conftest.$ac_ext <<_ACEOF
23613 /* confdefs.h.  */
23614 _ACEOF
23615 cat confdefs.h >>conftest.$ac_ext
23616 cat >>conftest.$ac_ext <<_ACEOF
23617 /* end confdefs.h.  */
23618 /* Define fp_trap to an innocuous variant, in case <limits.h> declares fp_trap.
23619    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
23620 #define fp_trap innocuous_fp_trap
23621
23622 /* System header to define __stub macros and hopefully few prototypes,
23623     which can conflict with char fp_trap (); below.
23624     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
23625     <limits.h> exists even on freestanding compilers.  */
23626
23627 #ifdef __STDC__
23628 # include <limits.h>
23629 #else
23630 # include <assert.h>
23631 #endif
23632
23633 #undef fp_trap
23634
23635 /* Override any gcc2 internal prototype to avoid an error.  */
23636 #ifdef __cplusplus
23637 extern "C"
23638 {
23639 #endif
23640 /* We use char because int might match the return type of a gcc2
23641    builtin and then its argument prototype would still apply.  */
23642 char fp_trap ();
23643 /* The GNU C library defines this for functions which it implements
23644     to always fail with ENOSYS.  Some functions are actually named
23645     something starting with __ and the normal name is an alias.  */
23646 #if defined (__stub_fp_trap) || defined (__stub___fp_trap)
23647 choke me
23648 #else
23649 char (*f) () = fp_trap;
23650 #endif
23651 #ifdef __cplusplus
23652 }
23653 #endif
23654
23655 int
23656 main ()
23657 {
23658 return f != fp_trap;
23659   ;
23660   return 0;
23661 }
23662 _ACEOF
23663 rm -f conftest.$ac_objext conftest$ac_exeext
23664 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23665   (eval $ac_link) 2>conftest.er1
23666   ac_status=$?
23667   grep -v '^ *+' conftest.er1 >conftest.err
23668   rm -f conftest.er1
23669   cat conftest.err >&5
23670   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23671   (exit $ac_status); } &&
23672          { ac_try='test -z "$ac_c_werror_flag"
23673                          || test ! -s conftest.err'
23674   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23675   (eval $ac_try) 2>&5
23676   ac_status=$?
23677   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23678   (exit $ac_status); }; } &&
23679          { ac_try='test -s conftest$ac_exeext'
23680   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23681   (eval $ac_try) 2>&5
23682   ac_status=$?
23683   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23684   (exit $ac_status); }; }; then
23685   ac_cv_func_fp_trap=yes
23686 else
23687   echo "$as_me: failed program was:" >&5
23688 sed 's/^/| /' conftest.$ac_ext >&5
23689
23690 ac_cv_func_fp_trap=no
23691 fi
23692 rm -f conftest.err conftest.$ac_objext \
23693       conftest$ac_exeext conftest.$ac_ext
23694 fi
23695 echo "$as_me:$LINENO: result: $ac_cv_func_fp_trap" >&5
23696 echo "${ECHO_T}$ac_cv_func_fp_trap" >&6
23697 if test $ac_cv_func_fp_trap = yes; then
23698   have_fp_trap=yes
23699 cat >>confdefs.h <<\_ACEOF
23700 #define HAVE_FP_TRAP 1
23701 _ACEOF
23702
23703 fi
23704
23705 echo "$as_me:$LINENO: checking for fp_enable" >&5
23706 echo $ECHO_N "checking for fp_enable... $ECHO_C" >&6
23707 if test "${ac_cv_func_fp_enable+set}" = set; then
23708   echo $ECHO_N "(cached) $ECHO_C" >&6
23709 else
23710   if test x$gcc_no_link = xyes; then
23711   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23712 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23713    { (exit 1); exit 1; }; }
23714 fi
23715 cat >conftest.$ac_ext <<_ACEOF
23716 /* confdefs.h.  */
23717 _ACEOF
23718 cat confdefs.h >>conftest.$ac_ext
23719 cat >>conftest.$ac_ext <<_ACEOF
23720 /* end confdefs.h.  */
23721 /* Define fp_enable to an innocuous variant, in case <limits.h> declares fp_enable.
23722    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
23723 #define fp_enable innocuous_fp_enable
23724
23725 /* System header to define __stub macros and hopefully few prototypes,
23726     which can conflict with char fp_enable (); below.
23727     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
23728     <limits.h> exists even on freestanding compilers.  */
23729
23730 #ifdef __STDC__
23731 # include <limits.h>
23732 #else
23733 # include <assert.h>
23734 #endif
23735
23736 #undef fp_enable
23737
23738 /* Override any gcc2 internal prototype to avoid an error.  */
23739 #ifdef __cplusplus
23740 extern "C"
23741 {
23742 #endif
23743 /* We use char because int might match the return type of a gcc2
23744    builtin and then its argument prototype would still apply.  */
23745 char fp_enable ();
23746 /* The GNU C library defines this for functions which it implements
23747     to always fail with ENOSYS.  Some functions are actually named
23748     something starting with __ and the normal name is an alias.  */
23749 #if defined (__stub_fp_enable) || defined (__stub___fp_enable)
23750 choke me
23751 #else
23752 char (*f) () = fp_enable;
23753 #endif
23754 #ifdef __cplusplus
23755 }
23756 #endif
23757
23758 int
23759 main ()
23760 {
23761 return f != fp_enable;
23762   ;
23763   return 0;
23764 }
23765 _ACEOF
23766 rm -f conftest.$ac_objext conftest$ac_exeext
23767 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23768   (eval $ac_link) 2>conftest.er1
23769   ac_status=$?
23770   grep -v '^ *+' conftest.er1 >conftest.err
23771   rm -f conftest.er1
23772   cat conftest.err >&5
23773   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23774   (exit $ac_status); } &&
23775          { ac_try='test -z "$ac_c_werror_flag"
23776                          || test ! -s conftest.err'
23777   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23778   (eval $ac_try) 2>&5
23779   ac_status=$?
23780   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23781   (exit $ac_status); }; } &&
23782          { ac_try='test -s conftest$ac_exeext'
23783   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23784   (eval $ac_try) 2>&5
23785   ac_status=$?
23786   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23787   (exit $ac_status); }; }; then
23788   ac_cv_func_fp_enable=yes
23789 else
23790   echo "$as_me: failed program was:" >&5
23791 sed 's/^/| /' conftest.$ac_ext >&5
23792
23793 ac_cv_func_fp_enable=no
23794 fi
23795 rm -f conftest.err conftest.$ac_objext \
23796       conftest$ac_exeext conftest.$ac_ext
23797 fi
23798 echo "$as_me:$LINENO: result: $ac_cv_func_fp_enable" >&5
23799 echo "${ECHO_T}$ac_cv_func_fp_enable" >&6
23800 if test $ac_cv_func_fp_enable = yes; then
23801   have_fp_enable=yes
23802 cat >>confdefs.h <<\_ACEOF
23803 #define HAVE_FP_ENABLE 1
23804 _ACEOF
23805
23806 fi
23807
23808
23809 # Runs configure.host to set up necessary host-dependent shell variables.
23810 # We then display a message about it, and propagate them through the
23811 # build chain.
23812 . ${srcdir}/configure.host
23813 { echo "$as_me:$LINENO: FPU dependent file will be ${fpu_host}.h" >&5
23814 echo "$as_me: FPU dependent file will be ${fpu_host}.h" >&6;}
23815 FPU_HOST_HEADER=config/${fpu_host}.h
23816
23817
23818 # Attempt to assert that the target is of common type in case we don't
23819 # have C99 integer types at all.
23820
23821   echo "$as_me:$LINENO: checking whether the target is ILP32" >&5
23822 echo $ECHO_N "checking whether the target is ILP32... $ECHO_C" >&6
23823 if test "${target_ilp32+set}" = set; then
23824   echo $ECHO_N "(cached) $ECHO_C" >&6
23825 else
23826
23827   save_CFLAGS="$CFLAGS"
23828   CFLAGS="-O2"
23829   if test x$gcc_no_link = xyes; then
23830   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23831 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23832    { (exit 1); exit 1; }; }
23833 fi
23834 cat >conftest.$ac_ext <<_ACEOF
23835 /* confdefs.h.  */
23836 _ACEOF
23837 cat confdefs.h >>conftest.$ac_ext
23838 cat >>conftest.$ac_ext <<_ACEOF
23839 /* end confdefs.h.  */
23840
23841 int
23842 main ()
23843 {
23844
23845 if (sizeof(int) == 4 && sizeof(long) == 4 && sizeof(void *) == 4)
23846   ;
23847 else
23848   undefined_function ();
23849
23850   ;
23851   return 0;
23852 }
23853 _ACEOF
23854 rm -f conftest.$ac_objext conftest$ac_exeext
23855 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23856   (eval $ac_link) 2>conftest.er1
23857   ac_status=$?
23858   grep -v '^ *+' conftest.er1 >conftest.err
23859   rm -f conftest.er1
23860   cat conftest.err >&5
23861   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23862   (exit $ac_status); } &&
23863          { ac_try='test -z "$ac_c_werror_flag"
23864                          || test ! -s conftest.err'
23865   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23866   (eval $ac_try) 2>&5
23867   ac_status=$?
23868   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23869   (exit $ac_status); }; } &&
23870          { ac_try='test -s conftest$ac_exeext'
23871   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23872   (eval $ac_try) 2>&5
23873   ac_status=$?
23874   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23875   (exit $ac_status); }; }; then
23876   target_ilp32=yes
23877 else
23878   echo "$as_me: failed program was:" >&5
23879 sed 's/^/| /' conftest.$ac_ext >&5
23880
23881 target_ilp32=no
23882 fi
23883 rm -f conftest.err conftest.$ac_objext \
23884       conftest$ac_exeext conftest.$ac_ext
23885   CFLAGS="$save_CFLAGS"
23886 fi
23887 echo "$as_me:$LINENO: result: $target_ilp32" >&5
23888 echo "${ECHO_T}$target_ilp32" >&6
23889   if test $target_ilp32 = yes; then
23890
23891 cat >>confdefs.h <<\_ACEOF
23892 #define TARGET_ILP32 1
23893 _ACEOF
23894
23895   fi
23896
23897
23898 # Check out attribute support.
23899
23900   echo "$as_me:$LINENO: checking whether the target supports hidden visibility" >&5
23901 echo $ECHO_N "checking whether the target supports hidden visibility... $ECHO_C" >&6
23902 if test "${have_attribute_visibility+set}" = set; then
23903   echo $ECHO_N "(cached) $ECHO_C" >&6
23904 else
23905
23906   save_CFLAGS="$CFLAGS"
23907   CFLAGS="$CFLAGS -Werror"
23908   cat >conftest.$ac_ext <<_ACEOF
23909 /* confdefs.h.  */
23910 _ACEOF
23911 cat confdefs.h >>conftest.$ac_ext
23912 cat >>conftest.$ac_ext <<_ACEOF
23913 /* end confdefs.h.  */
23914 void __attribute__((visibility("hidden"))) foo(void) { }
23915 int
23916 main ()
23917 {
23918
23919   ;
23920   return 0;
23921 }
23922 _ACEOF
23923 rm -f conftest.$ac_objext
23924 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
23925   (eval $ac_compile) 2>conftest.er1
23926   ac_status=$?
23927   grep -v '^ *+' conftest.er1 >conftest.err
23928   rm -f conftest.er1
23929   cat conftest.err >&5
23930   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23931   (exit $ac_status); } &&
23932          { ac_try='test -z "$ac_c_werror_flag"
23933                          || test ! -s conftest.err'
23934   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23935   (eval $ac_try) 2>&5
23936   ac_status=$?
23937   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23938   (exit $ac_status); }; } &&
23939          { ac_try='test -s conftest.$ac_objext'
23940   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23941   (eval $ac_try) 2>&5
23942   ac_status=$?
23943   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23944   (exit $ac_status); }; }; then
23945   have_attribute_visibility=yes
23946 else
23947   echo "$as_me: failed program was:" >&5
23948 sed 's/^/| /' conftest.$ac_ext >&5
23949
23950 have_attribute_visibility=no
23951 fi
23952 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
23953   CFLAGS="$save_CFLAGS"
23954 fi
23955 echo "$as_me:$LINENO: result: $have_attribute_visibility" >&5
23956 echo "${ECHO_T}$have_attribute_visibility" >&6
23957   if test $have_attribute_visibility = yes; then
23958
23959 cat >>confdefs.h <<\_ACEOF
23960 #define HAVE_ATTRIBUTE_VISIBILITY 1
23961 _ACEOF
23962
23963   fi
23964
23965   echo "$as_me:$LINENO: checking whether the target supports dllexport" >&5
23966 echo $ECHO_N "checking whether the target supports dllexport... $ECHO_C" >&6
23967 if test "${have_attribute_dllexport+set}" = set; then
23968   echo $ECHO_N "(cached) $ECHO_C" >&6
23969 else
23970
23971   save_CFLAGS="$CFLAGS"
23972   CFLAGS="$CFLAGS -Werror"
23973   cat >conftest.$ac_ext <<_ACEOF
23974 /* confdefs.h.  */
23975 _ACEOF
23976 cat confdefs.h >>conftest.$ac_ext
23977 cat >>conftest.$ac_ext <<_ACEOF
23978 /* end confdefs.h.  */
23979 void __attribute__((dllexport)) foo(void) { }
23980 int
23981 main ()
23982 {
23983
23984   ;
23985   return 0;
23986 }
23987 _ACEOF
23988 rm -f conftest.$ac_objext
23989 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
23990   (eval $ac_compile) 2>conftest.er1
23991   ac_status=$?
23992   grep -v '^ *+' conftest.er1 >conftest.err
23993   rm -f conftest.er1
23994   cat conftest.err >&5
23995   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23996   (exit $ac_status); } &&
23997          { ac_try='test -z "$ac_c_werror_flag"
23998                          || test ! -s conftest.err'
23999   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24000   (eval $ac_try) 2>&5
24001   ac_status=$?
24002   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24003   (exit $ac_status); }; } &&
24004          { ac_try='test -s conftest.$ac_objext'
24005   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24006   (eval $ac_try) 2>&5
24007   ac_status=$?
24008   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24009   (exit $ac_status); }; }; then
24010   have_attribute_dllexport=yes
24011 else
24012   echo "$as_me: failed program was:" >&5
24013 sed 's/^/| /' conftest.$ac_ext >&5
24014
24015 have_attribute_dllexport=no
24016 fi
24017 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
24018   CFLAGS="$save_CFLAGS"
24019 fi
24020 echo "$as_me:$LINENO: result: $have_attribute_dllexport" >&5
24021 echo "${ECHO_T}$have_attribute_dllexport" >&6
24022   if test $have_attribute_dllexport = yes; then
24023
24024 cat >>confdefs.h <<\_ACEOF
24025 #define HAVE_ATTRIBUTE_DLLEXPORT 1
24026 _ACEOF
24027
24028   fi
24029
24030   echo "$as_me:$LINENO: checking whether the target supports symbol aliases" >&5
24031 echo $ECHO_N "checking whether the target supports symbol aliases... $ECHO_C" >&6
24032 if test "${have_attribute_alias+set}" = set; then
24033   echo $ECHO_N "(cached) $ECHO_C" >&6
24034 else
24035
24036   if test x$gcc_no_link = xyes; then
24037   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
24038 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
24039    { (exit 1); exit 1; }; }
24040 fi
24041 cat >conftest.$ac_ext <<_ACEOF
24042 /* confdefs.h.  */
24043 _ACEOF
24044 cat confdefs.h >>conftest.$ac_ext
24045 cat >>conftest.$ac_ext <<_ACEOF
24046 /* end confdefs.h.  */
24047
24048 void foo(void) { }
24049 extern void bar(void) __attribute__((alias("foo")));
24050 int
24051 main ()
24052 {
24053 bar();
24054   ;
24055   return 0;
24056 }
24057 _ACEOF
24058 rm -f conftest.$ac_objext conftest$ac_exeext
24059 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
24060   (eval $ac_link) 2>conftest.er1
24061   ac_status=$?
24062   grep -v '^ *+' conftest.er1 >conftest.err
24063   rm -f conftest.er1
24064   cat conftest.err >&5
24065   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24066   (exit $ac_status); } &&
24067          { ac_try='test -z "$ac_c_werror_flag"
24068                          || test ! -s conftest.err'
24069   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24070   (eval $ac_try) 2>&5
24071   ac_status=$?
24072   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24073   (exit $ac_status); }; } &&
24074          { ac_try='test -s conftest$ac_exeext'
24075   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24076   (eval $ac_try) 2>&5
24077   ac_status=$?
24078   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24079   (exit $ac_status); }; }; then
24080   have_attribute_alias=yes
24081 else
24082   echo "$as_me: failed program was:" >&5
24083 sed 's/^/| /' conftest.$ac_ext >&5
24084
24085 have_attribute_alias=no
24086 fi
24087 rm -f conftest.err conftest.$ac_objext \
24088       conftest$ac_exeext conftest.$ac_ext
24089 fi
24090 echo "$as_me:$LINENO: result: $have_attribute_alias" >&5
24091 echo "${ECHO_T}$have_attribute_alias" >&6
24092   if test $have_attribute_alias = yes; then
24093
24094 cat >>confdefs.h <<\_ACEOF
24095 #define HAVE_ATTRIBUTE_ALIAS 1
24096 _ACEOF
24097
24098   fi
24099
24100 # Check out sync builtins support.
24101
24102   echo "$as_me:$LINENO: checking whether the target supports __sync_fetch_and_add" >&5
24103 echo $ECHO_N "checking whether the target supports __sync_fetch_and_add... $ECHO_C" >&6
24104 if test "${have_sync_fetch_and_add+set}" = set; then
24105   echo $ECHO_N "(cached) $ECHO_C" >&6
24106 else
24107
24108   if test x$gcc_no_link = xyes; then
24109   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
24110 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
24111    { (exit 1); exit 1; }; }
24112 fi
24113 cat >conftest.$ac_ext <<_ACEOF
24114 /* confdefs.h.  */
24115 _ACEOF
24116 cat confdefs.h >>conftest.$ac_ext
24117 cat >>conftest.$ac_ext <<_ACEOF
24118 /* end confdefs.h.  */
24119 int foovar = 0;
24120 int
24121 main ()
24122 {
24123
24124 if (foovar <= 0) return __sync_fetch_and_add (&foovar, 1);
24125 if (foovar > 10) return __sync_add_and_fetch (&foovar, -1);
24126   ;
24127   return 0;
24128 }
24129 _ACEOF
24130 rm -f conftest.$ac_objext conftest$ac_exeext
24131 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
24132   (eval $ac_link) 2>conftest.er1
24133   ac_status=$?
24134   grep -v '^ *+' conftest.er1 >conftest.err
24135   rm -f conftest.er1
24136   cat conftest.err >&5
24137   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24138   (exit $ac_status); } &&
24139          { ac_try='test -z "$ac_c_werror_flag"
24140                          || test ! -s conftest.err'
24141   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24142   (eval $ac_try) 2>&5
24143   ac_status=$?
24144   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24145   (exit $ac_status); }; } &&
24146          { ac_try='test -s conftest$ac_exeext'
24147   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24148   (eval $ac_try) 2>&5
24149   ac_status=$?
24150   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24151   (exit $ac_status); }; }; then
24152   have_sync_fetch_and_add=yes
24153 else
24154   echo "$as_me: failed program was:" >&5
24155 sed 's/^/| /' conftest.$ac_ext >&5
24156
24157 have_sync_fetch_and_add=no
24158 fi
24159 rm -f conftest.err conftest.$ac_objext \
24160       conftest$ac_exeext conftest.$ac_ext
24161 fi
24162 echo "$as_me:$LINENO: result: $have_sync_fetch_and_add" >&5
24163 echo "${ECHO_T}$have_sync_fetch_and_add" >&6
24164   if test $have_sync_fetch_and_add = yes; then
24165
24166 cat >>confdefs.h <<\_ACEOF
24167 #define HAVE_SYNC_FETCH_AND_ADD 1
24168 _ACEOF
24169
24170   fi
24171
24172 # Check out thread support.
24173
24174   echo "$as_me:$LINENO: checking configured target thread model" >&5
24175 echo $ECHO_N "checking configured target thread model... $ECHO_C" >&6
24176 if test "${target_thread_file+set}" = set; then
24177   echo $ECHO_N "(cached) $ECHO_C" >&6
24178 else
24179
24180 target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`
24181 fi
24182 echo "$as_me:$LINENO: result: $target_thread_file" >&5
24183 echo "${ECHO_T}$target_thread_file" >&6
24184
24185   if test $target_thread_file != single; then
24186
24187 cat >>confdefs.h <<\_ACEOF
24188 #define HAVE_GTHR_DEFAULT 1
24189 _ACEOF
24190
24191   fi
24192
24193 # Check out #pragma weak.
24194
24195   echo "$as_me:$LINENO: checking whether pragma weak works" >&5
24196 echo $ECHO_N "checking whether pragma weak works... $ECHO_C" >&6
24197 if test "${have_pragma_weak+set}" = set; then
24198   echo $ECHO_N "(cached) $ECHO_C" >&6
24199 else
24200
24201   gfor_save_CFLAGS="$CFLAGS"
24202   CFLAGS="$CFLAGS -Wunknown-pragmas"
24203   cat >conftest.$ac_ext <<_ACEOF
24204 /* confdefs.h.  */
24205 _ACEOF
24206 cat confdefs.h >>conftest.$ac_ext
24207 cat >>conftest.$ac_ext <<_ACEOF
24208 /* end confdefs.h.  */
24209 void foo (void);
24210 #pragma weak foo
24211 int
24212 main ()
24213 {
24214 if (foo) foo ();
24215   ;
24216   return 0;
24217 }
24218 _ACEOF
24219 rm -f conftest.$ac_objext
24220 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
24221   (eval $ac_compile) 2>conftest.er1
24222   ac_status=$?
24223   grep -v '^ *+' conftest.er1 >conftest.err
24224   rm -f conftest.er1
24225   cat conftest.err >&5
24226   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24227   (exit $ac_status); } &&
24228          { ac_try='test -z "$ac_c_werror_flag"
24229                          || test ! -s conftest.err'
24230   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24231   (eval $ac_try) 2>&5
24232   ac_status=$?
24233   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24234   (exit $ac_status); }; } &&
24235          { ac_try='test -s conftest.$ac_objext'
24236   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24237   (eval $ac_try) 2>&5
24238   ac_status=$?
24239   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24240   (exit $ac_status); }; }; then
24241   have_pragma_weak=yes
24242 else
24243   echo "$as_me: failed program was:" >&5
24244 sed 's/^/| /' conftest.$ac_ext >&5
24245
24246 have_pragma_weak=no
24247 fi
24248 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
24249 fi
24250 echo "$as_me:$LINENO: result: $have_pragma_weak" >&5
24251 echo "${ECHO_T}$have_pragma_weak" >&6
24252   if test $have_pragma_weak = yes; then
24253
24254 cat >>confdefs.h <<\_ACEOF
24255 #define SUPPORTS_WEAK 1
24256 _ACEOF
24257
24258   fi
24259   case "$host" in
24260     *-*-darwin* | *-*-hpux* | *-*-cygwin*)
24261
24262 cat >>confdefs.h <<\_ACEOF
24263 #define GTHREAD_USE_WEAK 0
24264 _ACEOF
24265
24266       ;;
24267   esac
24268
24269 # Various other checks on target
24270
24271   echo "$as_me:$LINENO: checking whether the target can unlink an open file" >&5
24272 echo $ECHO_N "checking whether the target can unlink an open file... $ECHO_C" >&6
24273 if test "${have_unlink_open_file+set}" = set; then
24274   echo $ECHO_N "(cached) $ECHO_C" >&6
24275 else
24276
24277   if test "$cross_compiling" = yes; then
24278
24279 case "${target}" in
24280   *mingw*) have_unlink_open_file=no ;;
24281   *) have_unlink_open_file=yes;;
24282 esac
24283 else
24284   cat >conftest.$ac_ext <<_ACEOF
24285 /* confdefs.h.  */
24286 _ACEOF
24287 cat confdefs.h >>conftest.$ac_ext
24288 cat >>conftest.$ac_ext <<_ACEOF
24289 /* end confdefs.h.  */
24290
24291 #include <errno.h>
24292 #include <fcntl.h>
24293 #include <unistd.h>
24294 #include <sys/stat.h>
24295
24296 int main ()
24297 {
24298   int fd;
24299
24300   fd = open ("testfile", O_RDWR | O_CREAT, S_IWRITE | S_IREAD);
24301   if (fd <= 0)
24302     return 0;
24303   if (unlink ("testfile") == -1)
24304     return 1;
24305   write (fd, "This is a test\n", 15);
24306   close (fd);
24307
24308   if (open ("testfile", O_RDONLY, S_IWRITE | S_IREAD) == -1 && errno == ENOENT)
24309     return 0;
24310   else
24311     return 1;
24312 }
24313 _ACEOF
24314 rm -f conftest$ac_exeext
24315 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
24316   (eval $ac_link) 2>&5
24317   ac_status=$?
24318   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24319   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
24320   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24321   (eval $ac_try) 2>&5
24322   ac_status=$?
24323   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24324   (exit $ac_status); }; }; then
24325   have_unlink_open_file=yes
24326 else
24327   echo "$as_me: program exited with status $ac_status" >&5
24328 echo "$as_me: failed program was:" >&5
24329 sed 's/^/| /' conftest.$ac_ext >&5
24330
24331 ( exit $ac_status )
24332 have_unlink_open_file=no
24333 fi
24334 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
24335 fi
24336 fi
24337 echo "$as_me:$LINENO: result: $have_unlink_open_file" >&5
24338 echo "${ECHO_T}$have_unlink_open_file" >&6
24339 if test x"$have_unlink_open_file" = xyes; then
24340
24341 cat >>confdefs.h <<\_ACEOF
24342 #define HAVE_UNLINK_OPEN_FILE 1
24343 _ACEOF
24344
24345 fi
24346
24347 # Check whether line terminator is LF or CRLF
24348
24349   echo "$as_me:$LINENO: checking whether the target has CRLF as line terminator" >&5
24350 echo $ECHO_N "checking whether the target has CRLF as line terminator... $ECHO_C" >&6
24351 if test "${have_crlf+set}" = set; then
24352   echo $ECHO_N "(cached) $ECHO_C" >&6
24353 else
24354
24355   if test "$cross_compiling" = yes; then
24356
24357 case "${target}" in
24358   *mingw*) have_crlf=yes ;;
24359   *) have_crlf=no;;
24360 esac
24361 else
24362   cat >conftest.$ac_ext <<_ACEOF
24363 /* confdefs.h.  */
24364 _ACEOF
24365 cat confdefs.h >>conftest.$ac_ext
24366 cat >>conftest.$ac_ext <<_ACEOF
24367 /* end confdefs.h.  */
24368
24369 /* This test program should exit with status 0 if system uses a CRLF as
24370    line terminator, and status 1 otherwise.
24371    Since it is used to check for mingw systems, and should return 0 in any
24372    other case, in case of a failure we will not use CRLF.  */
24373 #include <sys/stat.h>
24374 #include <stdlib.h>
24375 #include <fcntl.h>
24376 #include <stdio.h>
24377
24378 int main ()
24379 {
24380 #ifndef O_BINARY
24381   exit(1);
24382 #else
24383   int fd, bytes;
24384   char buff[5];
24385
24386   fd = open ("foo", O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
24387   if (fd < 0)
24388     exit(1);
24389   if (write (fd, "\n", 1) < 0)
24390     perror ("write");
24391
24392   close (fd);
24393
24394   if ((fd = open ("foo", O_RDONLY | O_BINARY, S_IRWXU)) < 0)
24395     exit(1);
24396   bytes = read (fd, buff, 5);
24397   if (bytes == 2 && buff[0] == '\r' && buff[1] == '\n')
24398     exit(0);
24399   else
24400     exit(1);
24401 #endif
24402 }
24403 _ACEOF
24404 rm -f conftest$ac_exeext
24405 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
24406   (eval $ac_link) 2>&5
24407   ac_status=$?
24408   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24409   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
24410   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24411   (eval $ac_try) 2>&5
24412   ac_status=$?
24413   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24414   (exit $ac_status); }; }; then
24415   have_crlf=yes
24416 else
24417   echo "$as_me: program exited with status $ac_status" >&5
24418 echo "$as_me: failed program was:" >&5
24419 sed 's/^/| /' conftest.$ac_ext >&5
24420
24421 ( exit $ac_status )
24422 have_crlf=no
24423 fi
24424 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
24425 fi
24426 fi
24427 echo "$as_me:$LINENO: result: $have_crlf" >&5
24428 echo "${ECHO_T}$have_crlf" >&6
24429 if test x"$have_crlf" = xyes; then
24430
24431 cat >>confdefs.h <<\_ACEOF
24432 #define HAVE_CRLF 1
24433 _ACEOF
24434
24435 fi
24436
24437 cat >confcache <<\_ACEOF
24438 # This file is a shell script that caches the results of configure
24439 # tests run on this system so they can be shared between configure
24440 # scripts and configure runs, see configure's option --config-cache.
24441 # It is not useful on other systems.  If it contains results you don't
24442 # want to keep, you may remove or edit it.
24443 #
24444 # config.status only pays attention to the cache file if you give it
24445 # the --recheck option to rerun configure.
24446 #
24447 # `ac_cv_env_foo' variables (set or unset) will be overridden when
24448 # loading this file, other *unset* `ac_cv_foo' will be assigned the
24449 # following values.
24450
24451 _ACEOF
24452
24453 # The following way of writing the cache mishandles newlines in values,
24454 # but we know of no workaround that is simple, portable, and efficient.
24455 # So, don't put newlines in cache variables' values.
24456 # Ultrix sh set writes to stderr and can't be redirected directly,
24457 # and sets the high bit in the cache file unless we assign to the vars.
24458 {
24459   (set) 2>&1 |
24460     case `(ac_space=' '; set | grep ac_space) 2>&1` in
24461     *ac_space=\ *)
24462       # `set' does not quote correctly, so add quotes (double-quote
24463       # substitution turns \\\\ into \\, and sed turns \\ into \).
24464       sed -n \
24465         "s/'/'\\\\''/g;
24466           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
24467       ;;
24468     *)
24469       # `set' quotes correctly as required by POSIX, so do not add quotes.
24470       sed -n \
24471         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
24472       ;;
24473     esac;
24474 } |
24475   sed '
24476      t clear
24477      : clear
24478      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
24479      t end
24480      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
24481      : end' >>confcache
24482 if diff $cache_file confcache >/dev/null 2>&1; then :; else
24483   if test -w $cache_file; then
24484     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
24485     cat confcache >$cache_file
24486   else
24487     echo "not updating unwritable cache $cache_file"
24488   fi
24489 fi
24490 rm -f confcache
24491
24492 if test ${multilib} = yes; then
24493   multilib_arg="--enable-multilib"
24494 else
24495   multilib_arg=
24496 fi
24497
24498 # Write our Makefile.
24499           ac_config_files="$ac_config_files Makefile"
24500
24501 cat >confcache <<\_ACEOF
24502 # This file is a shell script that caches the results of configure
24503 # tests run on this system so they can be shared between configure
24504 # scripts and configure runs, see configure's option --config-cache.
24505 # It is not useful on other systems.  If it contains results you don't
24506 # want to keep, you may remove or edit it.
24507 #
24508 # config.status only pays attention to the cache file if you give it
24509 # the --recheck option to rerun configure.
24510 #
24511 # `ac_cv_env_foo' variables (set or unset) will be overridden when
24512 # loading this file, other *unset* `ac_cv_foo' will be assigned the
24513 # following values.
24514
24515 _ACEOF
24516
24517 # The following way of writing the cache mishandles newlines in values,
24518 # but we know of no workaround that is simple, portable, and efficient.
24519 # So, don't put newlines in cache variables' values.
24520 # Ultrix sh set writes to stderr and can't be redirected directly,
24521 # and sets the high bit in the cache file unless we assign to the vars.
24522 {
24523   (set) 2>&1 |
24524     case `(ac_space=' '; set | grep ac_space) 2>&1` in
24525     *ac_space=\ *)
24526       # `set' does not quote correctly, so add quotes (double-quote
24527       # substitution turns \\\\ into \\, and sed turns \\ into \).
24528       sed -n \
24529         "s/'/'\\\\''/g;
24530           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
24531       ;;
24532     *)
24533       # `set' quotes correctly as required by POSIX, so do not add quotes.
24534       sed -n \
24535         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
24536       ;;
24537     esac;
24538 } |
24539   sed '
24540      t clear
24541      : clear
24542      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
24543      t end
24544      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
24545      : end' >>confcache
24546 if diff $cache_file confcache >/dev/null 2>&1; then :; else
24547   if test -w $cache_file; then
24548     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
24549     cat confcache >$cache_file
24550   else
24551     echo "not updating unwritable cache $cache_file"
24552   fi
24553 fi
24554 rm -f confcache
24555
24556 test "x$prefix" = xNONE && prefix=$ac_default_prefix
24557 # Let make expand exec_prefix.
24558 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
24559
24560 # VPATH may cause trouble with some makes, so we remove $(srcdir),
24561 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
24562 # trailing colons and then remove the whole line if VPATH becomes empty
24563 # (actually we leave an empty line to preserve line numbers).
24564 if test "x$srcdir" = x.; then
24565   ac_vpsub='/^[  ]*VPATH[        ]*=/{
24566 s/:*\$(srcdir):*/:/;
24567 s/:*\${srcdir}:*/:/;
24568 s/:*@srcdir@:*/:/;
24569 s/^\([^=]*=[     ]*\):*/\1/;
24570 s/:*$//;
24571 s/^[^=]*=[       ]*$//;
24572 }'
24573 fi
24574
24575 DEFS=-DHAVE_CONFIG_H
24576
24577 ac_libobjs=
24578 ac_ltlibobjs=
24579 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
24580   # 1. Remove the extension, and $U if already installed.
24581   ac_i=`echo "$ac_i" |
24582          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
24583   # 2. Add them.
24584   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
24585   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
24586 done
24587 LIBOBJS=$ac_libobjs
24588
24589 LTLIBOBJS=$ac_ltlibobjs
24590
24591
24592 if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then
24593   { { echo "$as_me:$LINENO: error: conditional \"MAINTAINER_MODE\" was never defined.
24594 Usually this means the macro was only invoked conditionally." >&5
24595 echo "$as_me: error: conditional \"MAINTAINER_MODE\" was never defined.
24596 Usually this means the macro was only invoked conditionally." >&2;}
24597    { (exit 1); exit 1; }; }
24598 fi
24599 if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
24600   { { echo "$as_me:$LINENO: error: conditional \"AMDEP\" was never defined.
24601 Usually this means the macro was only invoked conditionally." >&5
24602 echo "$as_me: error: conditional \"AMDEP\" was never defined.
24603 Usually this means the macro was only invoked conditionally." >&2;}
24604    { (exit 1); exit 1; }; }
24605 fi
24606 if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
24607   { { echo "$as_me:$LINENO: error: conditional \"am__fastdepCC\" was never defined.
24608 Usually this means the macro was only invoked conditionally." >&5
24609 echo "$as_me: error: conditional \"am__fastdepCC\" was never defined.
24610 Usually this means the macro was only invoked conditionally." >&2;}
24611    { (exit 1); exit 1; }; }
24612 fi
24613 if test -z "${LIBGFOR_USE_SYMVER_TRUE}" && test -z "${LIBGFOR_USE_SYMVER_FALSE}"; then
24614   { { echo "$as_me:$LINENO: error: conditional \"LIBGFOR_USE_SYMVER\" was never defined.
24615 Usually this means the macro was only invoked conditionally." >&5
24616 echo "$as_me: error: conditional \"LIBGFOR_USE_SYMVER\" was never defined.
24617 Usually this means the macro was only invoked conditionally." >&2;}
24618    { (exit 1); exit 1; }; }
24619 fi
24620
24621 : ${CONFIG_STATUS=./config.status}
24622 ac_clean_files_save=$ac_clean_files
24623 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
24624 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
24625 echo "$as_me: creating $CONFIG_STATUS" >&6;}
24626 cat >$CONFIG_STATUS <<_ACEOF
24627 #! $SHELL
24628 # Generated by $as_me.
24629 # Run this file to recreate the current configuration.
24630 # Compiler output produced by configure, useful for debugging
24631 # configure, is in config.log if it exists.
24632
24633 debug=false
24634 ac_cs_recheck=false
24635 ac_cs_silent=false
24636 SHELL=\${CONFIG_SHELL-$SHELL}
24637 _ACEOF
24638
24639 cat >>$CONFIG_STATUS <<\_ACEOF
24640 ## --------------------- ##
24641 ## M4sh Initialization.  ##
24642 ## --------------------- ##
24643
24644 # Be Bourne compatible
24645 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
24646   emulate sh
24647   NULLCMD=:
24648   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
24649   # is contrary to our usage.  Disable this feature.
24650   alias -g '${1+"$@"}'='"$@"'
24651 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
24652   set -o posix
24653 fi
24654 DUALCASE=1; export DUALCASE # for MKS sh
24655
24656 # Support unset when possible.
24657 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
24658   as_unset=unset
24659 else
24660   as_unset=false
24661 fi
24662
24663
24664 # Work around bugs in pre-3.0 UWIN ksh.
24665 $as_unset ENV MAIL MAILPATH
24666 PS1='$ '
24667 PS2='> '
24668 PS4='+ '
24669
24670 # NLS nuisances.
24671 for as_var in \
24672   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
24673   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
24674   LC_TELEPHONE LC_TIME
24675 do
24676   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
24677     eval $as_var=C; export $as_var
24678   else
24679     $as_unset $as_var
24680   fi
24681 done
24682
24683 # Required to use basename.
24684 if expr a : '\(a\)' >/dev/null 2>&1; then
24685   as_expr=expr
24686 else
24687   as_expr=false
24688 fi
24689
24690 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
24691   as_basename=basename
24692 else
24693   as_basename=false
24694 fi
24695
24696
24697 # Name of the executable.
24698 as_me=`$as_basename "$0" ||
24699 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
24700          X"$0" : 'X\(//\)$' \| \
24701          X"$0" : 'X\(/\)$' \| \
24702          .     : '\(.\)' 2>/dev/null ||
24703 echo X/"$0" |
24704     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
24705           /^X\/\(\/\/\)$/{ s//\1/; q; }
24706           /^X\/\(\/\).*/{ s//\1/; q; }
24707           s/.*/./; q'`
24708
24709
24710 # PATH needs CR, and LINENO needs CR and PATH.
24711 # Avoid depending upon Character Ranges.
24712 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
24713 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
24714 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
24715 as_cr_digits='0123456789'
24716 as_cr_alnum=$as_cr_Letters$as_cr_digits
24717
24718 # The user is always right.
24719 if test "${PATH_SEPARATOR+set}" != set; then
24720   echo "#! /bin/sh" >conf$$.sh
24721   echo  "exit 0"   >>conf$$.sh
24722   chmod +x conf$$.sh
24723   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
24724     PATH_SEPARATOR=';'
24725   else
24726     PATH_SEPARATOR=:
24727   fi
24728   rm -f conf$$.sh
24729 fi
24730
24731
24732   as_lineno_1=$LINENO
24733   as_lineno_2=$LINENO
24734   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
24735   test "x$as_lineno_1" != "x$as_lineno_2" &&
24736   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
24737   # Find who we are.  Look in the path if we contain no path at all
24738   # relative or not.
24739   case $0 in
24740     *[\\/]* ) as_myself=$0 ;;
24741     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24742 for as_dir in $PATH
24743 do
24744   IFS=$as_save_IFS
24745   test -z "$as_dir" && as_dir=.
24746   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
24747 done
24748
24749        ;;
24750   esac
24751   # We did not find ourselves, most probably we were run as `sh COMMAND'
24752   # in which case we are not to be found in the path.
24753   if test "x$as_myself" = x; then
24754     as_myself=$0
24755   fi
24756   if test ! -f "$as_myself"; then
24757     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
24758 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
24759    { (exit 1); exit 1; }; }
24760   fi
24761   case $CONFIG_SHELL in
24762   '')
24763     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24764 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
24765 do
24766   IFS=$as_save_IFS
24767   test -z "$as_dir" && as_dir=.
24768   for as_base in sh bash ksh sh5; do
24769          case $as_dir in
24770          /*)
24771            if ("$as_dir/$as_base" -c '
24772   as_lineno_1=$LINENO
24773   as_lineno_2=$LINENO
24774   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
24775   test "x$as_lineno_1" != "x$as_lineno_2" &&
24776   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
24777              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
24778              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
24779              CONFIG_SHELL=$as_dir/$as_base
24780              export CONFIG_SHELL
24781              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
24782            fi;;
24783          esac
24784        done
24785 done
24786 ;;
24787   esac
24788
24789   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
24790   # uniformly replaced by the line number.  The first 'sed' inserts a
24791   # line-number line before each line; the second 'sed' does the real
24792   # work.  The second script uses 'N' to pair each line-number line
24793   # with the numbered line, and appends trailing '-' during
24794   # substitution so that $LINENO is not a special case at line end.
24795   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
24796   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
24797   sed '=' <$as_myself |
24798     sed '
24799       N
24800       s,$,-,
24801       : loop
24802       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
24803       t loop
24804       s,-$,,
24805       s,^['$as_cr_digits']*\n,,
24806     ' >$as_me.lineno &&
24807   chmod +x $as_me.lineno ||
24808     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
24809 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
24810    { (exit 1); exit 1; }; }
24811
24812   # Don't try to exec as it changes $[0], causing all sort of problems
24813   # (the dirname of $[0] is not the place where we might find the
24814   # original and so on.  Autoconf is especially sensible to this).
24815   . ./$as_me.lineno
24816   # Exit status is that of the last command.
24817   exit
24818 }
24819
24820
24821 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
24822   *c*,-n*) ECHO_N= ECHO_C='
24823 ' ECHO_T='      ' ;;
24824   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
24825   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
24826 esac
24827
24828 if expr a : '\(a\)' >/dev/null 2>&1; then
24829   as_expr=expr
24830 else
24831   as_expr=false
24832 fi
24833
24834 rm -f conf$$ conf$$.exe conf$$.file
24835 echo >conf$$.file
24836 if ln -s conf$$.file conf$$ 2>/dev/null; then
24837   # We could just check for DJGPP; but this test a) works b) is more generic
24838   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
24839   if test -f conf$$.exe; then
24840     # Don't use ln at all; we don't have any links
24841     as_ln_s='cp -p'
24842   else
24843     as_ln_s='ln -s'
24844   fi
24845 elif ln conf$$.file conf$$ 2>/dev/null; then
24846   as_ln_s=ln
24847 else
24848   as_ln_s='cp -p'
24849 fi
24850 rm -f conf$$ conf$$.exe conf$$.file
24851
24852 if mkdir -p . 2>/dev/null; then
24853   as_mkdir_p=:
24854 else
24855   test -d ./-p && rmdir ./-p
24856   as_mkdir_p=false
24857 fi
24858
24859 as_executable_p="test -f"
24860
24861 # Sed expression to map a string onto a valid CPP name.
24862 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
24863
24864 # Sed expression to map a string onto a valid variable name.
24865 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
24866
24867
24868 # IFS
24869 # We need space, tab and new line, in precisely that order.
24870 as_nl='
24871 '
24872 IFS="   $as_nl"
24873
24874 # CDPATH.
24875 $as_unset CDPATH
24876
24877 exec 6>&1
24878
24879 # Open the log real soon, to keep \$[0] and so on meaningful, and to
24880 # report actual input values of CONFIG_FILES etc. instead of their
24881 # values after options handling.  Logging --version etc. is OK.
24882 exec 5>>config.log
24883 {
24884   echo
24885   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
24886 ## Running $as_me. ##
24887 _ASBOX
24888 } >&5
24889 cat >&5 <<_CSEOF
24890
24891 This file was extended by GNU Fortran Runtime Library $as_me 0.3, which was
24892 generated by GNU Autoconf 2.59.  Invocation command line was
24893
24894   CONFIG_FILES    = $CONFIG_FILES
24895   CONFIG_HEADERS  = $CONFIG_HEADERS
24896   CONFIG_LINKS    = $CONFIG_LINKS
24897   CONFIG_COMMANDS = $CONFIG_COMMANDS
24898   $ $0 $@
24899
24900 _CSEOF
24901 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
24902 echo >&5
24903 _ACEOF
24904
24905 # Files that config.status was made for.
24906 if test -n "$ac_config_files"; then
24907   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
24908 fi
24909
24910 if test -n "$ac_config_headers"; then
24911   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
24912 fi
24913
24914 if test -n "$ac_config_links"; then
24915   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
24916 fi
24917
24918 if test -n "$ac_config_commands"; then
24919   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
24920 fi
24921
24922 cat >>$CONFIG_STATUS <<\_ACEOF
24923
24924 ac_cs_usage="\
24925 \`$as_me' instantiates files from templates according to the
24926 current configuration.
24927
24928 Usage: $0 [OPTIONS] [FILE]...
24929
24930   -h, --help       print this help, then exit
24931   -V, --version    print version number, then exit
24932   -q, --quiet      do not print progress messages
24933   -d, --debug      don't remove temporary files
24934       --recheck    update $as_me by reconfiguring in the same conditions
24935   --file=FILE[:TEMPLATE]
24936                    instantiate the configuration file FILE
24937   --header=FILE[:TEMPLATE]
24938                    instantiate the configuration header FILE
24939
24940 Configuration files:
24941 $config_files
24942
24943 Configuration headers:
24944 $config_headers
24945
24946 Configuration commands:
24947 $config_commands
24948
24949 Report bugs to <bug-autoconf@gnu.org>."
24950 _ACEOF
24951
24952 cat >>$CONFIG_STATUS <<_ACEOF
24953 ac_cs_version="\\
24954 GNU Fortran Runtime Library config.status 0.3
24955 configured by $0, generated by GNU Autoconf 2.59,
24956   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
24957
24958 Copyright (C) 2003 Free Software Foundation, Inc.
24959 This config.status script is free software; the Free Software Foundation
24960 gives unlimited permission to copy, distribute and modify it."
24961 srcdir=$srcdir
24962 INSTALL="$INSTALL"
24963 _ACEOF
24964
24965 cat >>$CONFIG_STATUS <<\_ACEOF
24966 # If no file are specified by the user, then we need to provide default
24967 # value.  By we need to know if files were specified by the user.
24968 ac_need_defaults=:
24969 while test $# != 0
24970 do
24971   case $1 in
24972   --*=*)
24973     ac_option=`expr "x$1" : 'x\([^=]*\)='`
24974     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
24975     ac_shift=:
24976     ;;
24977   -*)
24978     ac_option=$1
24979     ac_optarg=$2
24980     ac_shift=shift
24981     ;;
24982   *) # This is not an option, so the user has probably given explicit
24983      # arguments.
24984      ac_option=$1
24985      ac_need_defaults=false;;
24986   esac
24987
24988   case $ac_option in
24989   # Handling of the options.
24990 _ACEOF
24991 cat >>$CONFIG_STATUS <<\_ACEOF
24992   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
24993     ac_cs_recheck=: ;;
24994   --version | --vers* | -V )
24995     echo "$ac_cs_version"; exit 0 ;;
24996   --he | --h)
24997     # Conflict between --help and --header
24998     { { echo "$as_me:$LINENO: error: ambiguous option: $1
24999 Try \`$0 --help' for more information." >&5
25000 echo "$as_me: error: ambiguous option: $1
25001 Try \`$0 --help' for more information." >&2;}
25002    { (exit 1); exit 1; }; };;
25003   --help | --hel | -h )
25004     echo "$ac_cs_usage"; exit 0 ;;
25005   --debug | --d* | -d )
25006     debug=: ;;
25007   --file | --fil | --fi | --f )
25008     $ac_shift
25009     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
25010     ac_need_defaults=false;;
25011   --header | --heade | --head | --hea )
25012     $ac_shift
25013     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
25014     ac_need_defaults=false;;
25015   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
25016   | -silent | --silent | --silen | --sile | --sil | --si | --s)
25017     ac_cs_silent=: ;;
25018
25019   # This is an error.
25020   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
25021 Try \`$0 --help' for more information." >&5
25022 echo "$as_me: error: unrecognized option: $1
25023 Try \`$0 --help' for more information." >&2;}
25024    { (exit 1); exit 1; }; } ;;
25025
25026   *) ac_config_targets="$ac_config_targets $1" ;;
25027
25028   esac
25029   shift
25030 done
25031
25032 ac_configure_extra_args=
25033
25034 if $ac_cs_silent; then
25035   exec 6>/dev/null
25036   ac_configure_extra_args="$ac_configure_extra_args --silent"
25037 fi
25038
25039 _ACEOF
25040 cat >>$CONFIG_STATUS <<_ACEOF
25041 if \$ac_cs_recheck; then
25042   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
25043   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
25044 fi
25045
25046 _ACEOF
25047
25048 cat >>$CONFIG_STATUS <<_ACEOF
25049 #
25050 # INIT-COMMANDS section.
25051 #
25052
25053
25054 srcdir="$srcdir"
25055 host="$host"
25056 target="$target"
25057 with_multisubdir="$with_multisubdir"
25058 with_multisrctop="$with_multisrctop"
25059 with_target_subdir="$with_target_subdir"
25060 ac_configure_args="${multilib_arg} ${ac_configure_args}"
25061 multi_basedir="$multi_basedir"
25062 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
25063 CC="$CC"
25064 AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
25065
25066 GCC="$GCC"
25067 CC="$CC"
25068 acx_cv_header_stdint="$acx_cv_header_stdint"
25069 acx_cv_type_int8_t="$acx_cv_type_int8_t"
25070 acx_cv_type_int16_t="$acx_cv_type_int16_t"
25071 acx_cv_type_int32_t="$acx_cv_type_int32_t"
25072 acx_cv_type_int64_t="$acx_cv_type_int64_t"
25073 acx_cv_type_intptr_t="$acx_cv_type_intptr_t"
25074 ac_cv_type_uintmax_t="$ac_cv_type_uintmax_t"
25075 ac_cv_type_uintptr_t="$ac_cv_type_uintptr_t"
25076 ac_cv_type_uint64_t="$ac_cv_type_uint64_t"
25077 ac_cv_type_u_int64_t="$ac_cv_type_u_int64_t"
25078 ac_cv_type_u_int32_t="$ac_cv_type_u_int32_t"
25079 ac_cv_type_int_least32_t="$ac_cv_type_int_least32_t"
25080 ac_cv_type_int_fast32_t="$ac_cv_type_int_fast32_t"
25081 ac_cv_sizeof_void_p="$ac_cv_sizeof_void_p"
25082
25083
25084 _ACEOF
25085
25086
25087
25088 cat >>$CONFIG_STATUS <<\_ACEOF
25089 for ac_config_target in $ac_config_targets
25090 do
25091   case "$ac_config_target" in
25092   # Handling of arguments.
25093   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
25094   "default-1" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default-1" ;;
25095   "depfiles" ) CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
25096   "gstdint.h" ) CONFIG_COMMANDS="$CONFIG_COMMANDS gstdint.h" ;;
25097   "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
25098   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
25099 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
25100    { (exit 1); exit 1; }; };;
25101   esac
25102 done
25103
25104 # If the user did not use the arguments to specify the items to instantiate,
25105 # then the envvar interface is used.  Set only those that are not.
25106 # We use the long form for the default assignment because of an extremely
25107 # bizarre bug on SunOS 4.1.3.
25108 if $ac_need_defaults; then
25109   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
25110   test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
25111   test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
25112 fi
25113
25114 # Have a temporary directory for convenience.  Make it in the build tree
25115 # simply because there is no reason to put it here, and in addition,
25116 # creating and moving files from /tmp can sometimes cause problems.
25117 # Create a temporary directory, and hook for its removal unless debugging.
25118 $debug ||
25119 {
25120   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
25121   trap '{ (exit 1); exit 1; }' 1 2 13 15
25122 }
25123
25124 # Create a (secure) tmp directory for tmp files.
25125
25126 {
25127   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
25128   test -n "$tmp" && test -d "$tmp"
25129 }  ||
25130 {
25131   tmp=./confstat$$-$RANDOM
25132   (umask 077 && mkdir $tmp)
25133 } ||
25134 {
25135    echo "$me: cannot create a temporary directory in ." >&2
25136    { (exit 1); exit 1; }
25137 }
25138
25139 _ACEOF
25140
25141 cat >>$CONFIG_STATUS <<_ACEOF
25142
25143 #
25144 # CONFIG_FILES section.
25145 #
25146
25147 # No need to generate the scripts if there are no CONFIG_FILES.
25148 # This happens for instance when ./config.status config.h
25149 if test -n "\$CONFIG_FILES"; then
25150   # Protect against being on the right side of a sed subst in config.status.
25151   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
25152    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
25153 s,@SHELL@,$SHELL,;t t
25154 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
25155 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
25156 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
25157 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
25158 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
25159 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
25160 s,@exec_prefix@,$exec_prefix,;t t
25161 s,@prefix@,$prefix,;t t
25162 s,@program_transform_name@,$program_transform_name,;t t
25163 s,@bindir@,$bindir,;t t
25164 s,@sbindir@,$sbindir,;t t
25165 s,@libexecdir@,$libexecdir,;t t
25166 s,@datadir@,$datadir,;t t
25167 s,@sysconfdir@,$sysconfdir,;t t
25168 s,@sharedstatedir@,$sharedstatedir,;t t
25169 s,@localstatedir@,$localstatedir,;t t
25170 s,@libdir@,$libdir,;t t
25171 s,@includedir@,$includedir,;t t
25172 s,@oldincludedir@,$oldincludedir,;t t
25173 s,@infodir@,$infodir,;t t
25174 s,@mandir@,$mandir,;t t
25175 s,@build_alias@,$build_alias,;t t
25176 s,@host_alias@,$host_alias,;t t
25177 s,@target_alias@,$target_alias,;t t
25178 s,@DEFS@,$DEFS,;t t
25179 s,@ECHO_C@,$ECHO_C,;t t
25180 s,@ECHO_N@,$ECHO_N,;t t
25181 s,@ECHO_T@,$ECHO_T,;t t
25182 s,@LIBS@,$LIBS,;t t
25183 s,@build@,$build,;t t
25184 s,@build_cpu@,$build_cpu,;t t
25185 s,@build_vendor@,$build_vendor,;t t
25186 s,@build_os@,$build_os,;t t
25187 s,@build_libsubdir@,$build_libsubdir,;t t
25188 s,@build_subdir@,$build_subdir,;t t
25189 s,@host_subdir@,$host_subdir,;t t
25190 s,@target_subdir@,$target_subdir,;t t
25191 s,@host@,$host,;t t
25192 s,@host_cpu@,$host_cpu,;t t
25193 s,@host_vendor@,$host_vendor,;t t
25194 s,@host_os@,$host_os,;t t
25195 s,@target@,$target,;t t
25196 s,@target_cpu@,$target_cpu,;t t
25197 s,@target_vendor@,$target_vendor,;t t
25198 s,@target_os@,$target_os,;t t
25199 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
25200 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
25201 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
25202 s,@CYGPATH_W@,$CYGPATH_W,;t t
25203 s,@PACKAGE@,$PACKAGE,;t t
25204 s,@VERSION@,$VERSION,;t t
25205 s,@ACLOCAL@,$ACLOCAL,;t t
25206 s,@AUTOCONF@,$AUTOCONF,;t t
25207 s,@AUTOMAKE@,$AUTOMAKE,;t t
25208 s,@AUTOHEADER@,$AUTOHEADER,;t t
25209 s,@MAKEINFO@,$MAKEINFO,;t t
25210 s,@install_sh@,$install_sh,;t t
25211 s,@STRIP@,$STRIP,;t t
25212 s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t
25213 s,@INSTALL_STRIP_PROGRAM@,$INSTALL_STRIP_PROGRAM,;t t
25214 s,@mkdir_p@,$mkdir_p,;t t
25215 s,@AWK@,$AWK,;t t
25216 s,@SET_MAKE@,$SET_MAKE,;t t
25217 s,@am__leading_dot@,$am__leading_dot,;t t
25218 s,@AMTAR@,$AMTAR,;t t
25219 s,@am__tar@,$am__tar,;t t
25220 s,@am__untar@,$am__untar,;t t
25221 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
25222 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
25223 s,@MAINT@,$MAINT,;t t
25224 s,@multi_basedir@,$multi_basedir,;t t
25225 s,@toolexecdir@,$toolexecdir,;t t
25226 s,@toolexeclibdir@,$toolexeclibdir,;t t
25227 s,@CC@,$CC,;t t
25228 s,@ac_ct_CC@,$ac_ct_CC,;t t
25229 s,@EXEEXT@,$EXEEXT,;t t
25230 s,@OBJEXT@,$OBJEXT,;t t
25231 s,@DEPDIR@,$DEPDIR,;t t
25232 s,@am__include@,$am__include,;t t
25233 s,@am__quote@,$am__quote,;t t
25234 s,@AMDEP_TRUE@,$AMDEP_TRUE,;t t
25235 s,@AMDEP_FALSE@,$AMDEP_FALSE,;t t
25236 s,@AMDEPBACKSLASH@,$AMDEPBACKSLASH,;t t
25237 s,@CCDEPMODE@,$CCDEPMODE,;t t
25238 s,@am__fastdepCC_TRUE@,$am__fastdepCC_TRUE,;t t
25239 s,@am__fastdepCC_FALSE@,$am__fastdepCC_FALSE,;t t
25240 s,@AM_FCFLAGS@,$AM_FCFLAGS,;t t
25241 s,@AM_CFLAGS@,$AM_CFLAGS,;t t
25242 s,@LIBGFOR_USE_SYMVER_TRUE@,$LIBGFOR_USE_SYMVER_TRUE,;t t
25243 s,@LIBGFOR_USE_SYMVER_FALSE@,$LIBGFOR_USE_SYMVER_FALSE,;t t
25244 s,@AS@,$AS,;t t
25245 s,@ac_ct_AS@,$ac_ct_AS,;t t
25246 s,@AR@,$AR,;t t
25247 s,@ac_ct_AR@,$ac_ct_AR,;t t
25248 s,@RANLIB@,$RANLIB,;t t
25249 s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
25250 s,@LN_S@,$LN_S,;t t
25251 s,@LIBTOOL@,$LIBTOOL,;t t
25252 s,@enable_shared@,$enable_shared,;t t
25253 s,@enable_static@,$enable_static,;t t
25254 s,@FC@,$FC,;t t
25255 s,@FCFLAGS@,$FCFLAGS,;t t
25256 s,@LDFLAGS@,$LDFLAGS,;t t
25257 s,@ac_ct_FC@,$ac_ct_FC,;t t
25258 s,@extra_ldflags_libgfortran@,$extra_ldflags_libgfortran,;t t
25259 s,@CPP@,$CPP,;t t
25260 s,@CPPFLAGS@,$CPPFLAGS,;t t
25261 s,@EGREP@,$EGREP,;t t
25262 s,@FPU_HOST_HEADER@,$FPU_HOST_HEADER,;t t
25263 s,@LIBOBJS@,$LIBOBJS,;t t
25264 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
25265 CEOF
25266
25267 _ACEOF
25268
25269   cat >>$CONFIG_STATUS <<\_ACEOF
25270   # Split the substitutions into bite-sized pieces for seds with
25271   # small command number limits, like on Digital OSF/1 and HP-UX.
25272   ac_max_sed_lines=48
25273   ac_sed_frag=1 # Number of current file.
25274   ac_beg=1 # First line for current file.
25275   ac_end=$ac_max_sed_lines # Line after last line for current file.
25276   ac_more_lines=:
25277   ac_sed_cmds=
25278   while $ac_more_lines; do
25279     if test $ac_beg -gt 1; then
25280       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
25281     else
25282       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
25283     fi
25284     if test ! -s $tmp/subs.frag; then
25285       ac_more_lines=false
25286     else
25287       # The purpose of the label and of the branching condition is to
25288       # speed up the sed processing (if there are no `@' at all, there
25289       # is no need to browse any of the substitutions).
25290       # These are the two extra sed commands mentioned above.
25291       (echo ':t
25292   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
25293       if test -z "$ac_sed_cmds"; then
25294         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
25295       else
25296         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
25297       fi
25298       ac_sed_frag=`expr $ac_sed_frag + 1`
25299       ac_beg=$ac_end
25300       ac_end=`expr $ac_end + $ac_max_sed_lines`
25301     fi
25302   done
25303   if test -z "$ac_sed_cmds"; then
25304     ac_sed_cmds=cat
25305   fi
25306 fi # test -n "$CONFIG_FILES"
25307
25308 _ACEOF
25309 cat >>$CONFIG_STATUS <<\_ACEOF
25310 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
25311   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
25312   case $ac_file in
25313   - | *:- | *:-:* ) # input from stdin
25314         cat >$tmp/stdin
25315         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25316         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25317   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25318         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25319   * )   ac_file_in=$ac_file.in ;;
25320   esac
25321
25322   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
25323   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
25324 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25325          X"$ac_file" : 'X\(//\)[^/]' \| \
25326          X"$ac_file" : 'X\(//\)$' \| \
25327          X"$ac_file" : 'X\(/\)' \| \
25328          .     : '\(.\)' 2>/dev/null ||
25329 echo X"$ac_file" |
25330     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25331           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25332           /^X\(\/\/\)$/{ s//\1/; q; }
25333           /^X\(\/\).*/{ s//\1/; q; }
25334           s/.*/./; q'`
25335   { if $as_mkdir_p; then
25336     mkdir -p "$ac_dir"
25337   else
25338     as_dir="$ac_dir"
25339     as_dirs=
25340     while test ! -d "$as_dir"; do
25341       as_dirs="$as_dir $as_dirs"
25342       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25343 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25344          X"$as_dir" : 'X\(//\)[^/]' \| \
25345          X"$as_dir" : 'X\(//\)$' \| \
25346          X"$as_dir" : 'X\(/\)' \| \
25347          .     : '\(.\)' 2>/dev/null ||
25348 echo X"$as_dir" |
25349     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25350           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25351           /^X\(\/\/\)$/{ s//\1/; q; }
25352           /^X\(\/\).*/{ s//\1/; q; }
25353           s/.*/./; q'`
25354     done
25355     test ! -n "$as_dirs" || mkdir $as_dirs
25356   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
25357 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
25358    { (exit 1); exit 1; }; }; }
25359
25360   ac_builddir=.
25361
25362 if test "$ac_dir" != .; then
25363   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
25364   # A "../" for each directory in $ac_dir_suffix.
25365   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
25366 else
25367   ac_dir_suffix= ac_top_builddir=
25368 fi
25369
25370 case $srcdir in
25371   .)  # No --srcdir option.  We are building in place.
25372     ac_srcdir=.
25373     if test -z "$ac_top_builddir"; then
25374        ac_top_srcdir=.
25375     else
25376        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
25377     fi ;;
25378   [\\/]* | ?:[\\/]* )  # Absolute path.
25379     ac_srcdir=$srcdir$ac_dir_suffix;
25380     ac_top_srcdir=$srcdir ;;
25381   *) # Relative path.
25382     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
25383     ac_top_srcdir=$ac_top_builddir$srcdir ;;
25384 esac
25385
25386 # Do not use `cd foo && pwd` to compute absolute paths, because
25387 # the directories may not exist.
25388 case `pwd` in
25389 .) ac_abs_builddir="$ac_dir";;
25390 *)
25391   case "$ac_dir" in
25392   .) ac_abs_builddir=`pwd`;;
25393   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
25394   *) ac_abs_builddir=`pwd`/"$ac_dir";;
25395   esac;;
25396 esac
25397 case $ac_abs_builddir in
25398 .) ac_abs_top_builddir=${ac_top_builddir}.;;
25399 *)
25400   case ${ac_top_builddir}. in
25401   .) ac_abs_top_builddir=$ac_abs_builddir;;
25402   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
25403   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
25404   esac;;
25405 esac
25406 case $ac_abs_builddir in
25407 .) ac_abs_srcdir=$ac_srcdir;;
25408 *)
25409   case $ac_srcdir in
25410   .) ac_abs_srcdir=$ac_abs_builddir;;
25411   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
25412   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
25413   esac;;
25414 esac
25415 case $ac_abs_builddir in
25416 .) ac_abs_top_srcdir=$ac_top_srcdir;;
25417 *)
25418   case $ac_top_srcdir in
25419   .) ac_abs_top_srcdir=$ac_abs_builddir;;
25420   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
25421   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
25422   esac;;
25423 esac
25424
25425
25426   case $INSTALL in
25427   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
25428   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
25429   esac
25430
25431   if test x"$ac_file" != x-; then
25432     { echo "$as_me:$LINENO: creating $ac_file" >&5
25433 echo "$as_me: creating $ac_file" >&6;}
25434     rm -f "$ac_file"
25435   fi
25436   # Let's still pretend it is `configure' which instantiates (i.e., don't
25437   # use $as_me), people would be surprised to read:
25438   #    /* config.h.  Generated by config.status.  */
25439   if test x"$ac_file" = x-; then
25440     configure_input=
25441   else
25442     configure_input="$ac_file.  "
25443   fi
25444   configure_input=$configure_input"Generated from `echo $ac_file_in |
25445                                      sed 's,.*/,,'` by configure."
25446
25447   # First look for the input files in the build tree, otherwise in the
25448   # src tree.
25449   ac_file_inputs=`IFS=:
25450     for f in $ac_file_in; do
25451       case $f in
25452       -) echo $tmp/stdin ;;
25453       [\\/$]*)
25454          # Absolute (can't be DOS-style, as IFS=:)
25455          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25456 echo "$as_me: error: cannot find input file: $f" >&2;}
25457    { (exit 1); exit 1; }; }
25458          echo "$f";;
25459       *) # Relative
25460          if test -f "$f"; then
25461            # Build tree
25462            echo "$f"
25463          elif test -f "$srcdir/$f"; then
25464            # Source tree
25465            echo "$srcdir/$f"
25466          else
25467            # /dev/null tree
25468            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25469 echo "$as_me: error: cannot find input file: $f" >&2;}
25470    { (exit 1); exit 1; }; }
25471          fi;;
25472       esac
25473     done` || { (exit 1); exit 1; }
25474 _ACEOF
25475 cat >>$CONFIG_STATUS <<_ACEOF
25476   sed "$ac_vpsub
25477 $extrasub
25478 _ACEOF
25479 cat >>$CONFIG_STATUS <<\_ACEOF
25480 :t
25481 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
25482 s,@configure_input@,$configure_input,;t t
25483 s,@srcdir@,$ac_srcdir,;t t
25484 s,@abs_srcdir@,$ac_abs_srcdir,;t t
25485 s,@top_srcdir@,$ac_top_srcdir,;t t
25486 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
25487 s,@builddir@,$ac_builddir,;t t
25488 s,@abs_builddir@,$ac_abs_builddir,;t t
25489 s,@top_builddir@,$ac_top_builddir,;t t
25490 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
25491 s,@INSTALL@,$ac_INSTALL,;t t
25492 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
25493   rm -f $tmp/stdin
25494   if test x"$ac_file" != x-; then
25495     mv $tmp/out $ac_file
25496   else
25497     cat $tmp/out
25498     rm -f $tmp/out
25499   fi
25500
25501 done
25502 _ACEOF
25503 cat >>$CONFIG_STATUS <<\_ACEOF
25504
25505 #
25506 # CONFIG_HEADER section.
25507 #
25508
25509 # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
25510 # NAME is the cpp macro being defined and VALUE is the value it is being given.
25511 #
25512 # ac_d sets the value in "#define NAME VALUE" lines.
25513 ac_dA='s,^\([    ]*\)#\([        ]*define[       ][      ]*\)'
25514 ac_dB='[         ].*$,\1#\2'
25515 ac_dC=' '
25516 ac_dD=',;t'
25517 # ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
25518 ac_uA='s,^\([    ]*\)#\([        ]*\)undef\([    ][      ]*\)'
25519 ac_uB='$,\1#\2define\3'
25520 ac_uC=' '
25521 ac_uD=',;t'
25522
25523 for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue
25524   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
25525   case $ac_file in
25526   - | *:- | *:-:* ) # input from stdin
25527         cat >$tmp/stdin
25528         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25529         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25530   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25531         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25532   * )   ac_file_in=$ac_file.in ;;
25533   esac
25534
25535   test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5
25536 echo "$as_me: creating $ac_file" >&6;}
25537
25538   # First look for the input files in the build tree, otherwise in the
25539   # src tree.
25540   ac_file_inputs=`IFS=:
25541     for f in $ac_file_in; do
25542       case $f in
25543       -) echo $tmp/stdin ;;
25544       [\\/$]*)
25545          # Absolute (can't be DOS-style, as IFS=:)
25546          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25547 echo "$as_me: error: cannot find input file: $f" >&2;}
25548    { (exit 1); exit 1; }; }
25549          # Do quote $f, to prevent DOS paths from being IFS'd.
25550          echo "$f";;
25551       *) # Relative
25552          if test -f "$f"; then
25553            # Build tree
25554            echo "$f"
25555          elif test -f "$srcdir/$f"; then
25556            # Source tree
25557            echo "$srcdir/$f"
25558          else
25559            # /dev/null tree
25560            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25561 echo "$as_me: error: cannot find input file: $f" >&2;}
25562    { (exit 1); exit 1; }; }
25563          fi;;
25564       esac
25565     done` || { (exit 1); exit 1; }
25566   # Remove the trailing spaces.
25567   sed 's/[       ]*$//' $ac_file_inputs >$tmp/in
25568
25569 _ACEOF
25570
25571 # Transform confdefs.h into two sed scripts, `conftest.defines' and
25572 # `conftest.undefs', that substitutes the proper values into
25573 # config.h.in to produce config.h.  The first handles `#define'
25574 # templates, and the second `#undef' templates.
25575 # And first: Protect against being on the right side of a sed subst in
25576 # config.status.  Protect against being in an unquoted here document
25577 # in config.status.
25578 rm -f conftest.defines conftest.undefs
25579 # Using a here document instead of a string reduces the quoting nightmare.
25580 # Putting comments in sed scripts is not portable.
25581 #
25582 # `end' is used to avoid that the second main sed command (meant for
25583 # 0-ary CPP macros) applies to n-ary macro definitions.
25584 # See the Autoconf documentation for `clear'.
25585 cat >confdef2sed.sed <<\_ACEOF
25586 s/[\\&,]/\\&/g
25587 s,[\\$`],\\&,g
25588 t clear
25589 : clear
25590 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
25591 t end
25592 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
25593 : end
25594 _ACEOF
25595 # If some macros were called several times there might be several times
25596 # the same #defines, which is useless.  Nevertheless, we may not want to
25597 # sort them, since we want the *last* AC-DEFINE to be honored.
25598 uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines
25599 sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs
25600 rm -f confdef2sed.sed
25601
25602 # This sed command replaces #undef with comments.  This is necessary, for
25603 # example, in the case of _POSIX_SOURCE, which is predefined and required
25604 # on some systems where configure will not decide to define it.
25605 cat >>conftest.undefs <<\_ACEOF
25606 s,^[     ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
25607 _ACEOF
25608
25609 # Break up conftest.defines because some shells have a limit on the size
25610 # of here documents, and old seds have small limits too (100 cmds).
25611 echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
25612 echo '  if grep "^[      ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
25613 echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
25614 echo '  :' >>$CONFIG_STATUS
25615 rm -f conftest.tail
25616 while grep . conftest.defines >/dev/null
25617 do
25618   # Write a limited-size here document to $tmp/defines.sed.
25619   echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
25620   # Speed up: don't consider the non `#define' lines.
25621   echo '/^[      ]*#[    ]*define/!b' >>$CONFIG_STATUS
25622   # Work around the forget-to-reset-the-flag bug.
25623   echo 't clr' >>$CONFIG_STATUS
25624   echo ': clr' >>$CONFIG_STATUS
25625   sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS
25626   echo 'CEOF
25627   sed -f $tmp/defines.sed $tmp/in >$tmp/out
25628   rm -f $tmp/in
25629   mv $tmp/out $tmp/in
25630 ' >>$CONFIG_STATUS
25631   sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail
25632   rm -f conftest.defines
25633   mv conftest.tail conftest.defines
25634 done
25635 rm -f conftest.defines
25636 echo '  fi # grep' >>$CONFIG_STATUS
25637 echo >>$CONFIG_STATUS
25638
25639 # Break up conftest.undefs because some shells have a limit on the size
25640 # of here documents, and old seds have small limits too (100 cmds).
25641 echo '  # Handle all the #undef templates' >>$CONFIG_STATUS
25642 rm -f conftest.tail
25643 while grep . conftest.undefs >/dev/null
25644 do
25645   # Write a limited-size here document to $tmp/undefs.sed.
25646   echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
25647   # Speed up: don't consider the non `#undef'
25648   echo '/^[      ]*#[    ]*undef/!b' >>$CONFIG_STATUS
25649   # Work around the forget-to-reset-the-flag bug.
25650   echo 't clr' >>$CONFIG_STATUS
25651   echo ': clr' >>$CONFIG_STATUS
25652   sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS
25653   echo 'CEOF
25654   sed -f $tmp/undefs.sed $tmp/in >$tmp/out
25655   rm -f $tmp/in
25656   mv $tmp/out $tmp/in
25657 ' >>$CONFIG_STATUS
25658   sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail
25659   rm -f conftest.undefs
25660   mv conftest.tail conftest.undefs
25661 done
25662 rm -f conftest.undefs
25663
25664 cat >>$CONFIG_STATUS <<\_ACEOF
25665   # Let's still pretend it is `configure' which instantiates (i.e., don't
25666   # use $as_me), people would be surprised to read:
25667   #    /* config.h.  Generated by config.status.  */
25668   if test x"$ac_file" = x-; then
25669     echo "/* Generated by configure.  */" >$tmp/config.h
25670   else
25671     echo "/* $ac_file.  Generated by configure.  */" >$tmp/config.h
25672   fi
25673   cat $tmp/in >>$tmp/config.h
25674   rm -f $tmp/in
25675   if test x"$ac_file" != x-; then
25676     if diff $ac_file $tmp/config.h >/dev/null 2>&1; then
25677       { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
25678 echo "$as_me: $ac_file is unchanged" >&6;}
25679     else
25680       ac_dir=`(dirname "$ac_file") 2>/dev/null ||
25681 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25682          X"$ac_file" : 'X\(//\)[^/]' \| \
25683          X"$ac_file" : 'X\(//\)$' \| \
25684          X"$ac_file" : 'X\(/\)' \| \
25685          .     : '\(.\)' 2>/dev/null ||
25686 echo X"$ac_file" |
25687     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25688           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25689           /^X\(\/\/\)$/{ s//\1/; q; }
25690           /^X\(\/\).*/{ s//\1/; q; }
25691           s/.*/./; q'`
25692       { if $as_mkdir_p; then
25693     mkdir -p "$ac_dir"
25694   else
25695     as_dir="$ac_dir"
25696     as_dirs=
25697     while test ! -d "$as_dir"; do
25698       as_dirs="$as_dir $as_dirs"
25699       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25700 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25701          X"$as_dir" : 'X\(//\)[^/]' \| \
25702          X"$as_dir" : 'X\(//\)$' \| \
25703          X"$as_dir" : 'X\(/\)' \| \
25704          .     : '\(.\)' 2>/dev/null ||
25705 echo X"$as_dir" |
25706     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25707           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25708           /^X\(\/\/\)$/{ s//\1/; q; }
25709           /^X\(\/\).*/{ s//\1/; q; }
25710           s/.*/./; q'`
25711     done
25712     test ! -n "$as_dirs" || mkdir $as_dirs
25713   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
25714 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
25715    { (exit 1); exit 1; }; }; }
25716
25717       rm -f $ac_file
25718       mv $tmp/config.h $ac_file
25719     fi
25720   else
25721     cat $tmp/config.h
25722     rm -f $tmp/config.h
25723   fi
25724 # Compute $ac_file's index in $config_headers.
25725 _am_stamp_count=1
25726 for _am_header in $config_headers :; do
25727   case $_am_header in
25728     $ac_file | $ac_file:* )
25729       break ;;
25730     * )
25731       _am_stamp_count=`expr $_am_stamp_count + 1` ;;
25732   esac
25733 done
25734 echo "timestamp for $ac_file" >`(dirname $ac_file) 2>/dev/null ||
25735 $as_expr X$ac_file : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25736          X$ac_file : 'X\(//\)[^/]' \| \
25737          X$ac_file : 'X\(//\)$' \| \
25738          X$ac_file : 'X\(/\)' \| \
25739          .     : '\(.\)' 2>/dev/null ||
25740 echo X$ac_file |
25741     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25742           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25743           /^X\(\/\/\)$/{ s//\1/; q; }
25744           /^X\(\/\).*/{ s//\1/; q; }
25745           s/.*/./; q'`/stamp-h$_am_stamp_count
25746 done
25747 _ACEOF
25748 cat >>$CONFIG_STATUS <<\_ACEOF
25749
25750 #
25751 # CONFIG_COMMANDS section.
25752 #
25753 for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue
25754   ac_dest=`echo "$ac_file" | sed 's,:.*,,'`
25755   ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`
25756   ac_dir=`(dirname "$ac_dest") 2>/dev/null ||
25757 $as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25758          X"$ac_dest" : 'X\(//\)[^/]' \| \
25759          X"$ac_dest" : 'X\(//\)$' \| \
25760          X"$ac_dest" : 'X\(/\)' \| \
25761          .     : '\(.\)' 2>/dev/null ||
25762 echo X"$ac_dest" |
25763     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25764           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25765           /^X\(\/\/\)$/{ s//\1/; q; }
25766           /^X\(\/\).*/{ s//\1/; q; }
25767           s/.*/./; q'`
25768   { if $as_mkdir_p; then
25769     mkdir -p "$ac_dir"
25770   else
25771     as_dir="$ac_dir"
25772     as_dirs=
25773     while test ! -d "$as_dir"; do
25774       as_dirs="$as_dir $as_dirs"
25775       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25776 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25777          X"$as_dir" : 'X\(//\)[^/]' \| \
25778          X"$as_dir" : 'X\(//\)$' \| \
25779          X"$as_dir" : 'X\(/\)' \| \
25780          .     : '\(.\)' 2>/dev/null ||
25781 echo X"$as_dir" |
25782     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25783           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25784           /^X\(\/\/\)$/{ s//\1/; q; }
25785           /^X\(\/\).*/{ s//\1/; q; }
25786           s/.*/./; q'`
25787     done
25788     test ! -n "$as_dirs" || mkdir $as_dirs
25789   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
25790 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
25791    { (exit 1); exit 1; }; }; }
25792
25793   ac_builddir=.
25794
25795 if test "$ac_dir" != .; then
25796   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
25797   # A "../" for each directory in $ac_dir_suffix.
25798   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
25799 else
25800   ac_dir_suffix= ac_top_builddir=
25801 fi
25802
25803 case $srcdir in
25804   .)  # No --srcdir option.  We are building in place.
25805     ac_srcdir=.
25806     if test -z "$ac_top_builddir"; then
25807        ac_top_srcdir=.
25808     else
25809        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
25810     fi ;;
25811   [\\/]* | ?:[\\/]* )  # Absolute path.
25812     ac_srcdir=$srcdir$ac_dir_suffix;
25813     ac_top_srcdir=$srcdir ;;
25814   *) # Relative path.
25815     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
25816     ac_top_srcdir=$ac_top_builddir$srcdir ;;
25817 esac
25818
25819 # Do not use `cd foo && pwd` to compute absolute paths, because
25820 # the directories may not exist.
25821 case `pwd` in
25822 .) ac_abs_builddir="$ac_dir";;
25823 *)
25824   case "$ac_dir" in
25825   .) ac_abs_builddir=`pwd`;;
25826   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
25827   *) ac_abs_builddir=`pwd`/"$ac_dir";;
25828   esac;;
25829 esac
25830 case $ac_abs_builddir in
25831 .) ac_abs_top_builddir=${ac_top_builddir}.;;
25832 *)
25833   case ${ac_top_builddir}. in
25834   .) ac_abs_top_builddir=$ac_abs_builddir;;
25835   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
25836   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
25837   esac;;
25838 esac
25839 case $ac_abs_builddir in
25840 .) ac_abs_srcdir=$ac_srcdir;;
25841 *)
25842   case $ac_srcdir in
25843   .) ac_abs_srcdir=$ac_abs_builddir;;
25844   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
25845   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
25846   esac;;
25847 esac
25848 case $ac_abs_builddir in
25849 .) ac_abs_top_srcdir=$ac_top_srcdir;;
25850 *)
25851   case $ac_top_srcdir in
25852   .) ac_abs_top_srcdir=$ac_abs_builddir;;
25853   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
25854   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
25855   esac;;
25856 esac
25857
25858
25859   { echo "$as_me:$LINENO: executing $ac_dest commands" >&5
25860 echo "$as_me: executing $ac_dest commands" >&6;}
25861   case $ac_dest in
25862     default-1 )
25863 # Only add multilib support code if we just rebuilt the top-level
25864 # Makefile.
25865 case " $CONFIG_FILES " in
25866  *" Makefile "*)
25867    ac_file=Makefile . ${multi_basedir}/config-ml.in
25868    ;;
25869 esac ;;
25870     depfiles ) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do
25871   # Strip MF so we end up with the name of the file.
25872   mf=`echo "$mf" | sed -e 's/:.*$//'`
25873   # Check whether this is an Automake generated Makefile or not.
25874   # We used to match only the files named `Makefile.in', but
25875   # some people rename them; so instead we look at the file content.
25876   # Grep'ing the first line is not enough: some people post-process
25877   # each Makefile.in and add a new line on top of each file to say so.
25878   # So let's grep whole file.
25879   if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then
25880     dirpart=`(dirname "$mf") 2>/dev/null ||
25881 $as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25882          X"$mf" : 'X\(//\)[^/]' \| \
25883          X"$mf" : 'X\(//\)$' \| \
25884          X"$mf" : 'X\(/\)' \| \
25885          .     : '\(.\)' 2>/dev/null ||
25886 echo X"$mf" |
25887     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25888           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25889           /^X\(\/\/\)$/{ s//\1/; q; }
25890           /^X\(\/\).*/{ s//\1/; q; }
25891           s/.*/./; q'`
25892   else
25893     continue
25894   fi
25895   # Extract the definition of DEPDIR, am__include, and am__quote
25896   # from the Makefile without running `make'.
25897   DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
25898   test -z "$DEPDIR" && continue
25899   am__include=`sed -n 's/^am__include = //p' < "$mf"`
25900   test -z "am__include" && continue
25901   am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
25902   # When using ansi2knr, U may be empty or an underscore; expand it
25903   U=`sed -n 's/^U = //p' < "$mf"`
25904   # Find all dependency output files, they are included files with
25905   # $(DEPDIR) in their names.  We invoke sed twice because it is the
25906   # simplest approach to changing $(DEPDIR) to its actual value in the
25907   # expansion.
25908   for file in `sed -n "
25909     s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
25910        sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
25911     # Make sure the directory exists.
25912     test -f "$dirpart/$file" && continue
25913     fdir=`(dirname "$file") 2>/dev/null ||
25914 $as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25915          X"$file" : 'X\(//\)[^/]' \| \
25916          X"$file" : 'X\(//\)$' \| \
25917          X"$file" : 'X\(/\)' \| \
25918          .     : '\(.\)' 2>/dev/null ||
25919 echo X"$file" |
25920     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25921           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25922           /^X\(\/\/\)$/{ s//\1/; q; }
25923           /^X\(\/\).*/{ s//\1/; q; }
25924           s/.*/./; q'`
25925     { if $as_mkdir_p; then
25926     mkdir -p $dirpart/$fdir
25927   else
25928     as_dir=$dirpart/$fdir
25929     as_dirs=
25930     while test ! -d "$as_dir"; do
25931       as_dirs="$as_dir $as_dirs"
25932       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25933 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25934          X"$as_dir" : 'X\(//\)[^/]' \| \
25935          X"$as_dir" : 'X\(//\)$' \| \
25936          X"$as_dir" : 'X\(/\)' \| \
25937          .     : '\(.\)' 2>/dev/null ||
25938 echo X"$as_dir" |
25939     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25940           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25941           /^X\(\/\/\)$/{ s//\1/; q; }
25942           /^X\(\/\).*/{ s//\1/; q; }
25943           s/.*/./; q'`
25944     done
25945     test ! -n "$as_dirs" || mkdir $as_dirs
25946   fi || { { echo "$as_me:$LINENO: error: cannot create directory $dirpart/$fdir" >&5
25947 echo "$as_me: error: cannot create directory $dirpart/$fdir" >&2;}
25948    { (exit 1); exit 1; }; }; }
25949
25950     # echo "creating $dirpart/$file"
25951     echo '# dummy' > "$dirpart/$file"
25952   done
25953 done
25954  ;;
25955     gstdint.h )
25956 if test "$GCC" = yes; then
25957   echo "/* generated for " `$CC --version | sed 1q` "*/" > tmp-stdint.h
25958 else
25959   echo "/* generated for $CC */" > tmp-stdint.h
25960 fi
25961
25962 sed 's/^ *//' >> tmp-stdint.h <<EOF
25963
25964   #ifndef GCC_GENERATED_STDINT_H
25965   #define GCC_GENERATED_STDINT_H 1
25966
25967   #include <sys/types.h>
25968 EOF
25969
25970 if test "$acx_cv_header_stdint" != stdint.h; then
25971   echo "#include <stddef.h>" >> tmp-stdint.h
25972 fi
25973 if test "$acx_cv_header_stdint" != stddef.h; then
25974   echo "#include <$acx_cv_header_stdint>" >> tmp-stdint.h
25975 fi
25976
25977 sed 's/^ *//' >> tmp-stdint.h <<EOF
25978   /* glibc uses these symbols as guards to prevent redefinitions.  */
25979   #ifdef __int8_t_defined
25980   #define _INT8_T
25981   #define _INT16_T
25982   #define _INT32_T
25983   #endif
25984   #ifdef __uint32_t_defined
25985   #define _UINT32_T
25986   #endif
25987
25988 EOF
25989
25990 # ----------------- done header, emit basic int types -------------
25991 if test "$acx_cv_header_stdint" = stddef.h; then
25992   sed 's/^ *//' >> tmp-stdint.h <<EOF
25993
25994     #ifndef _UINT8_T
25995     #define _UINT8_T
25996     #ifndef __uint8_t_defined
25997     #define __uint8_t_defined
25998     typedef unsigned $acx_cv_type_int8_t uint8_t;
25999     #endif
26000     #endif
26001
26002     #ifndef _UINT16_T
26003     #define _UINT16_T
26004     #ifndef __uint16_t_defined
26005     #define __uint16_t_defined
26006     typedef unsigned $acx_cv_type_int16_t uint16_t;
26007     #endif
26008     #endif
26009
26010     #ifndef _UINT32_T
26011     #define _UINT32_T
26012     #ifndef __uint32_t_defined
26013     #define __uint32_t_defined
26014     typedef unsigned $acx_cv_type_int32_t uint32_t;
26015     #endif
26016     #endif
26017
26018     #ifndef _INT8_T
26019     #define _INT8_T
26020     #ifndef __int8_t_defined
26021     #define __int8_t_defined
26022     typedef $acx_cv_type_int8_t int8_t;
26023     #endif
26024     #endif
26025
26026     #ifndef _INT16_T
26027     #define _INT16_T
26028     #ifndef __int16_t_defined
26029     #define __int16_t_defined
26030     typedef $acx_cv_type_int16_t int16_t;
26031     #endif
26032     #endif
26033
26034     #ifndef _INT32_T
26035     #define _INT32_T
26036     #ifndef __int32_t_defined
26037     #define __int32_t_defined
26038     typedef $acx_cv_type_int32_t int32_t;
26039     #endif
26040     #endif
26041 EOF
26042 elif test "$ac_cv_type_u_int32_t" = yes; then
26043   sed 's/^ *//' >> tmp-stdint.h <<EOF
26044
26045     /* int8_t int16_t int32_t defined by inet code, we do the u_intXX types */
26046     #ifndef _INT8_T
26047     #define _INT8_T
26048     #endif
26049     #ifndef _INT16_T
26050     #define _INT16_T
26051     #endif
26052     #ifndef _INT32_T
26053     #define _INT32_T
26054     #endif
26055
26056     #ifndef _UINT8_T
26057     #define _UINT8_T
26058     #ifndef __uint8_t_defined
26059     #define __uint8_t_defined
26060     typedef u_int8_t uint8_t;
26061     #endif
26062     #endif
26063
26064     #ifndef _UINT16_T
26065     #define _UINT16_T
26066     #ifndef __uint16_t_defined
26067     #define __uint16_t_defined
26068     typedef u_int16_t uint16_t;
26069     #endif
26070     #endif
26071
26072     #ifndef _UINT32_T
26073     #define _UINT32_T
26074     #ifndef __uint32_t_defined
26075     #define __uint32_t_defined
26076     typedef u_int32_t uint32_t;
26077     #endif
26078     #endif
26079 EOF
26080 else
26081   sed 's/^ *//' >> tmp-stdint.h <<EOF
26082
26083     /* Some systems have guard macros to prevent redefinitions, define them.  */
26084     #ifndef _INT8_T
26085     #define _INT8_T
26086     #endif
26087     #ifndef _INT16_T
26088     #define _INT16_T
26089     #endif
26090     #ifndef _INT32_T
26091     #define _INT32_T
26092     #endif
26093     #ifndef _UINT8_T
26094     #define _UINT8_T
26095     #endif
26096     #ifndef _UINT16_T
26097     #define _UINT16_T
26098     #endif
26099     #ifndef _UINT32_T
26100     #define _UINT32_T
26101     #endif
26102 EOF
26103 fi
26104
26105 # ------------- done basic int types, emit int64_t types ------------
26106 if test "$ac_cv_type_uint64_t" = yes; then
26107   sed 's/^ *//' >> tmp-stdint.h <<EOF
26108
26109     /* system headers have good uint64_t and int64_t */
26110     #ifndef _INT64_T
26111     #define _INT64_T
26112     #endif
26113     #ifndef _UINT64_T
26114     #define _UINT64_T
26115     #endif
26116 EOF
26117 elif test "$ac_cv_type_u_int64_t" = yes; then
26118   sed 's/^ *//' >> tmp-stdint.h <<EOF
26119
26120     /* system headers have an u_int64_t (and int64_t) */
26121     #ifndef _INT64_T
26122     #define _INT64_T
26123     #endif
26124     #ifndef _UINT64_T
26125     #define _UINT64_T
26126     #ifndef __uint64_t_defined
26127     #define __uint64_t_defined
26128     typedef u_int64_t uint64_t;
26129     #endif
26130     #endif
26131 EOF
26132 elif test -n "$acx_cv_type_int64_t"; then
26133   sed 's/^ *//' >> tmp-stdint.h <<EOF
26134
26135     /* architecture has a 64-bit type, $acx_cv_type_int64_t */
26136     #ifndef _INT64_T
26137     #define _INT64_T
26138     typedef $acx_cv_type_int64_t int64_t;
26139     #endif
26140     #ifndef _UINT64_T
26141     #define _UINT64_T
26142     #ifndef __uint64_t_defined
26143     #define __uint64_t_defined
26144     typedef unsigned $acx_cv_type_int64_t uint64_t;
26145     #endif
26146     #endif
26147 EOF
26148 else
26149   sed 's/^ *//' >> tmp-stdint.h <<EOF
26150
26151     /* some common heuristics for int64_t, using compiler-specific tests */
26152     #if defined __STDC_VERSION__ && (__STDC_VERSION__-0) >= 199901L
26153     #ifndef _INT64_T
26154     #define _INT64_T
26155     #ifndef __int64_t_defined
26156     typedef long long int64_t;
26157     #endif
26158     #endif
26159     #ifndef _UINT64_T
26160     #define _UINT64_T
26161     typedef unsigned long long uint64_t;
26162     #endif
26163
26164     #elif defined __GNUC__ && defined (__STDC__) && __STDC__-0
26165     /* NextStep 2.0 cc is really gcc 1.93 but it defines __GNUC__ = 2 and
26166        does not implement __extension__.  But that compiler doesn't define
26167        __GNUC_MINOR__.  */
26168     # if __GNUC__ < 2 || (__NeXT__ && !__GNUC_MINOR__)
26169     # define __extension__
26170     # endif
26171
26172     # ifndef _INT64_T
26173     # define _INT64_T
26174     __extension__ typedef long long int64_t;
26175     # endif
26176     # ifndef _UINT64_T
26177     # define _UINT64_T
26178     __extension__ typedef unsigned long long uint64_t;
26179     # endif
26180
26181     #elif !defined __STRICT_ANSI__
26182     # if defined _MSC_VER || defined __WATCOMC__ || defined __BORLANDC__
26183
26184     #  ifndef _INT64_T
26185     #  define _INT64_T
26186     typedef __int64 int64_t;
26187     #  endif
26188     #  ifndef _UINT64_T
26189     #  define _UINT64_T
26190     typedef unsigned __int64 uint64_t;
26191     #  endif
26192     # endif /* compiler */
26193
26194     #endif /* ANSI version */
26195 EOF
26196 fi
26197
26198 # ------------- done int64_t types, emit intptr types ------------
26199 if test "$ac_cv_type_uintptr_t" != yes; then
26200   sed 's/^ *//' >> tmp-stdint.h <<EOF
26201
26202     /* Define intptr_t based on sizeof(void*) = $ac_cv_sizeof_void_p */
26203     #ifndef __uintptr_t_defined
26204     typedef u$acx_cv_type_intptr_t uintptr_t;
26205     #endif
26206     #ifndef __intptr_t_defined
26207     typedef $acx_cv_type_intptr_t  intptr_t;
26208     #endif
26209 EOF
26210 fi
26211
26212 # ------------- done intptr types, emit int_least types ------------
26213 if test "$ac_cv_type_int_least32_t" != yes; then
26214   sed 's/^ *//' >> tmp-stdint.h <<EOF
26215
26216     /* Define int_least types */
26217     typedef int8_t     int_least8_t;
26218     typedef int16_t    int_least16_t;
26219     typedef int32_t    int_least32_t;
26220     #ifdef _INT64_T
26221     typedef int64_t    int_least64_t;
26222     #endif
26223
26224     typedef uint8_t    uint_least8_t;
26225     typedef uint16_t   uint_least16_t;
26226     typedef uint32_t   uint_least32_t;
26227     #ifdef _UINT64_T
26228     typedef uint64_t   uint_least64_t;
26229     #endif
26230 EOF
26231 fi
26232
26233 # ------------- done intptr types, emit int_fast types ------------
26234 if test "$ac_cv_type_int_fast32_t" != yes; then
26235       sed 's/^ *//' >> tmp-stdint.h <<EOF
26236
26237     /* Define int_fast types.  short is often slow */
26238     typedef int8_t       int_fast8_t;
26239     typedef int          int_fast16_t;
26240     typedef int32_t      int_fast32_t;
26241     #ifdef _INT64_T
26242     typedef int64_t      int_fast64_t;
26243     #endif
26244
26245     typedef uint8_t      uint_fast8_t;
26246     typedef unsigned int uint_fast16_t;
26247     typedef uint32_t     uint_fast32_t;
26248     #ifdef _UINT64_T
26249     typedef uint64_t     uint_fast64_t;
26250     #endif
26251 EOF
26252 fi
26253
26254 if test "$ac_cv_type_uintmax_t" != yes; then
26255   sed 's/^ *//' >> tmp-stdint.h <<EOF
26256
26257     /* Define intmax based on what we found */
26258     #ifdef _INT64_T
26259     typedef int64_t       intmax_t;
26260     #else
26261     typedef long          intmax_t;
26262     #endif
26263     #ifdef _UINT64_T
26264     typedef uint64_t      uintmax_t;
26265     #else
26266     typedef unsigned long uintmax_t;
26267     #endif
26268 EOF
26269 fi
26270
26271 sed 's/^ *//' >> tmp-stdint.h <<EOF
26272
26273   #endif /* GCC_GENERATED_STDINT_H */
26274 EOF
26275
26276 if test -r gstdint.h && cmp -s tmp-stdint.h gstdint.h; then
26277   rm -f tmp-stdint.h
26278 else
26279   mv -f tmp-stdint.h gstdint.h
26280 fi
26281
26282  ;;
26283   esac
26284 done
26285 _ACEOF
26286
26287 cat >>$CONFIG_STATUS <<\_ACEOF
26288
26289 { (exit 0); exit 0; }
26290 _ACEOF
26291 chmod +x $CONFIG_STATUS
26292 ac_clean_files=$ac_clean_files_save
26293
26294
26295 # configure is writing to config.log, and then calls config.status.
26296 # config.status does its own redirection, appending to config.log.
26297 # Unfortunately, on DOS this fails, as config.log is still kept open
26298 # by configure, so config.status won't be able to write to it; its
26299 # output is simply discarded.  So we exec the FD to /dev/null,
26300 # effectively closing config.log, so it can be properly (re)opened and
26301 # appended to by config.status.  When coming back to configure, we
26302 # need to make the FD available again.
26303 if test "$no_create" != yes; then
26304   ac_cs_success=:
26305   ac_config_status_args=
26306   test "$silent" = yes &&
26307     ac_config_status_args="$ac_config_status_args --quiet"
26308   exec 5>/dev/null
26309   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
26310   exec 5>>config.log
26311   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
26312   # would make configure fail if this is the last instruction.
26313   $ac_cs_success || { (exit 1); exit 1; }
26314 fi
26315