libgfortran/configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59 for GNU Fortran Runtime Library 0.3.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME='GNU Fortran Runtime Library'
 269 PACKAGE_TARNAME='libgfortran'
 270 PACKAGE_VERSION='0.3'
 271 PACKAGE_STRING='GNU Fortran Runtime Library 0.3'
 272 PACKAGE_BUGREPORT=''
 273
 274 # Factoring default headers for most tests.
 275 ac_includes_default="\
 276 #include <stdio.h>
 277 #if HAVE_SYS_TYPES_H
 278 # include <sys/types.h>
 279 #endif
 280 #if HAVE_SYS_STAT_H
 281 # include <sys/stat.h>
 282 #endif
 283 #if STDC_HEADERS
 284 # include <stdlib.h>
 285 # include <stddef.h>
 286 #else
 287 # if HAVE_STDLIB_H
 288 #  include <stdlib.h>
 289 # endif
 290 #endif
 291 #if HAVE_STRING_H
 292 # if !STDC_HEADERS && HAVE_MEMORY_H
 293 #  include <memory.h>
 294 # endif
 295 # include <string.h>
 296 #endif
 297 #if HAVE_STRINGS_H
 298 # include <strings.h>
 299 #endif
 300 #if HAVE_INTTYPES_H
 301 # include <inttypes.h>
 302 #else
 303 # if HAVE_STDINT_H
 304 #  include <stdint.h>
 305 # endif
 306 #endif
 307 #if HAVE_UNISTD_H
 308 # include <unistd.h>
 309 #endif"
 310
 311 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os build_libsubdir build_subdir host_subdir target_subdir host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA CYGPATH_W PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM mkdir_p AWK SET_MAKE am__leading_dot AMTAR am__tar am__untar MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT multi_basedir toolexecdir toolexeclibdir CC ac_ct_CC EXEEXT OBJEXT DEPDIR am__include am__quote AMDEP_TRUE AMDEP_FALSE AMDEPBACKSLASH CCDEPMODE am__fastdepCC_TRUE am__fastdepCC_FALSE AM_FCFLAGS AM_CFLAGS AS ac_ct_AS AR ac_ct_AR RANLIB ac_ct_RANLIB LN_S LIBTOOL enable_shared enable_static FC FCFLAGS LDFLAGS ac_ct_FC extra_ldflags_libgfortran CPP CPPFLAGS EGREP FPU_HOST_HEADER LIBOBJS LTLIBOBJS'
 312 ac_subst_files=''
 313
 314 # Initialize some variables set by options.
 315 ac_init_help=
 316 ac_init_version=false
 317 # The variables have the same names as the options, with
 318 # dashes changed to underlines.
 319 cache_file=/dev/null
 320 exec_prefix=NONE
 321 no_create=
 322 no_recursion=
 323 prefix=NONE
 324 program_prefix=NONE
 325 program_suffix=NONE
 326 program_transform_name=s,x,x,
 327 silent=
 328 site=
 329 srcdir=
 330 verbose=
 331 x_includes=NONE
 332 x_libraries=NONE
 333
 334 # Installation directory options.
 335 # These are left unexpanded so users can "make install exec_prefix=/foo"
 336 # and all the variables that are supposed to be based on exec_prefix
 337 # by default will actually change.
 338 # Use braces instead of parens because sh, perl, etc. also accept them.
 339 bindir='${exec_prefix}/bin'
 340 sbindir='${exec_prefix}/sbin'
 341 libexecdir='${exec_prefix}/libexec'
 342 datadir='${prefix}/share'
 343 sysconfdir='${prefix}/etc'
 344 sharedstatedir='${prefix}/com'
 345 localstatedir='${prefix}/var'
 346 libdir='${exec_prefix}/lib'
 347 includedir='${prefix}/include'
 348 oldincludedir='/usr/include'
 349 infodir='${prefix}/info'
 350 mandir='${prefix}/man'
 351
 352 ac_prev=
 353 for ac_option
 354 do
 355   # If the previous option needs an argument, assign it.
 356   if test -n "$ac_prev"; then
 357     eval "$ac_prev=\$ac_option"
 358     ac_prev=
 359     continue
 360   fi
 361
 362   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 363
 364   # Accept the important Cygnus configure options, so we can diagnose typos.
 365
 366   case $ac_option in
 367
 368   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 369     ac_prev=bindir ;;
 370   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 371     bindir=$ac_optarg ;;
 372
 373   -build | --build | --buil | --bui | --bu)
 374     ac_prev=build_alias ;;
 375   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 376     build_alias=$ac_optarg ;;
 377
 378   -cache-file | --cache-file | --cache-fil | --cache-fi \
 379   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 380     ac_prev=cache_file ;;
 381   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 382   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 383     cache_file=$ac_optarg ;;
 384
 385   --config-cache | -C)
 386     cache_file=config.cache ;;
 387
 388   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 389     ac_prev=datadir ;;
 390   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 391   | --da=*)
 392     datadir=$ac_optarg ;;
 393
 394   -disable-* | --disable-*)
 395     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 396     # Reject names that are not valid shell variable names.
 397     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 398       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 399    { (exit 1); exit 1; }; }
 400     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 401     eval "enable_$ac_feature=no" ;;
 402
 403   -enable-* | --enable-*)
 404     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 405     # Reject names that are not valid shell variable names.
 406     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 407       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 408    { (exit 1); exit 1; }; }
 409     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 410     case $ac_option in
 411       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 412       *) ac_optarg=yes ;;
 413     esac
 414     eval "enable_$ac_feature='$ac_optarg'" ;;
 415
 416   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 417   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 418   | --exec | --exe | --ex)
 419     ac_prev=exec_prefix ;;
 420   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 421   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 422   | --exec=* | --exe=* | --ex=*)
 423     exec_prefix=$ac_optarg ;;
 424
 425   -gas | --gas | --ga | --g)
 426     # Obsolete; use --with-gas.
 427     with_gas=yes ;;
 428
 429   -help | --help | --hel | --he | -h)
 430     ac_init_help=long ;;
 431   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 432     ac_init_help=recursive ;;
 433   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 434     ac_init_help=short ;;
 435
 436   -host | --host | --hos | --ho)
 437     ac_prev=host_alias ;;
 438   -host=* | --host=* | --hos=* | --ho=*)
 439     host_alias=$ac_optarg ;;
 440
 441   -includedir | --includedir | --includedi | --included | --include \
 442   | --includ | --inclu | --incl | --inc)
 443     ac_prev=includedir ;;
 444   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 445   | --includ=* | --inclu=* | --incl=* | --inc=*)
 446     includedir=$ac_optarg ;;
 447
 448   -infodir | --infodir | --infodi | --infod | --info | --inf)
 449     ac_prev=infodir ;;
 450   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 451     infodir=$ac_optarg ;;
 452
 453   -libdir | --libdir | --libdi | --libd)
 454     ac_prev=libdir ;;
 455   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 456     libdir=$ac_optarg ;;
 457
 458   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 459   | --libexe | --libex | --libe)
 460     ac_prev=libexecdir ;;
 461   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 462   | --libexe=* | --libex=* | --libe=*)
 463     libexecdir=$ac_optarg ;;
 464
 465   -localstatedir | --localstatedir | --localstatedi | --localstated \
 466   | --localstate | --localstat | --localsta | --localst \
 467   | --locals | --local | --loca | --loc | --lo)
 468     ac_prev=localstatedir ;;
 469   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 470   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 471   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 472     localstatedir=$ac_optarg ;;
 473
 474   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 475     ac_prev=mandir ;;
 476   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 477     mandir=$ac_optarg ;;
 478
 479   -nfp | --nfp | --nf)
 480     # Obsolete; use --without-fp.
 481     with_fp=no ;;
 482
 483   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 484   | --no-cr | --no-c | -n)
 485     no_create=yes ;;
 486
 487   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 488   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 489     no_recursion=yes ;;
 490
 491   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 492   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 493   | --oldin | --oldi | --old | --ol | --o)
 494     ac_prev=oldincludedir ;;
 495   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 496   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 497   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 498     oldincludedir=$ac_optarg ;;
 499
 500   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 501     ac_prev=prefix ;;
 502   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 503     prefix=$ac_optarg ;;
 504
 505   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 506   | --program-pre | --program-pr | --program-p)
 507     ac_prev=program_prefix ;;
 508   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 509   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 510     program_prefix=$ac_optarg ;;
 511
 512   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 513   | --program-suf | --program-su | --program-s)
 514     ac_prev=program_suffix ;;
 515   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 516   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 517     program_suffix=$ac_optarg ;;
 518
 519   -program-transform-name | --program-transform-name \
 520   | --program-transform-nam | --program-transform-na \
 521   | --program-transform-n | --program-transform- \
 522   | --program-transform | --program-transfor \
 523   | --program-transfo | --program-transf \
 524   | --program-trans | --program-tran \
 525   | --progr-tra | --program-tr | --program-t)
 526     ac_prev=program_transform_name ;;
 527   -program-transform-name=* | --program-transform-name=* \
 528   | --program-transform-nam=* | --program-transform-na=* \
 529   | --program-transform-n=* | --program-transform-=* \
 530   | --program-transform=* | --program-transfor=* \
 531   | --program-transfo=* | --program-transf=* \
 532   | --program-trans=* | --program-tran=* \
 533   | --progr-tra=* | --program-tr=* | --program-t=*)
 534     program_transform_name=$ac_optarg ;;
 535
 536   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 537   | -silent | --silent | --silen | --sile | --sil)
 538     silent=yes ;;
 539
 540   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 541     ac_prev=sbindir ;;
 542   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 543   | --sbi=* | --sb=*)
 544     sbindir=$ac_optarg ;;
 545
 546   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 547   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 548   | --sharedst | --shareds | --shared | --share | --shar \
 549   | --sha | --sh)
 550     ac_prev=sharedstatedir ;;
 551   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 552   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 553   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 554   | --sha=* | --sh=*)
 555     sharedstatedir=$ac_optarg ;;
 556
 557   -site | --site | --sit)
 558     ac_prev=site ;;
 559   -site=* | --site=* | --sit=*)
 560     site=$ac_optarg ;;
 561
 562   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 563     ac_prev=srcdir ;;
 564   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 565     srcdir=$ac_optarg ;;
 566
 567   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 568   | --syscon | --sysco | --sysc | --sys | --sy)
 569     ac_prev=sysconfdir ;;
 570   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 571   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 572     sysconfdir=$ac_optarg ;;
 573
 574   -target | --target | --targe | --targ | --tar | --ta | --t)
 575     ac_prev=target_alias ;;
 576   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 577     target_alias=$ac_optarg ;;
 578
 579   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 580     verbose=yes ;;
 581
 582   -version | --version | --versio | --versi | --vers | -V)
 583     ac_init_version=: ;;
 584
 585   -with-* | --with-*)
 586     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 587     # Reject names that are not valid shell variable names.
 588     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 589       { echo "$as_me: error: invalid package name: $ac_package" >&2
 590    { (exit 1); exit 1; }; }
 591     ac_package=`echo $ac_package| sed 's/-/_/g'`
 592     case $ac_option in
 593       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 594       *) ac_optarg=yes ;;
 595     esac
 596     eval "with_$ac_package='$ac_optarg'" ;;
 597
 598   -without-* | --without-*)
 599     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 600     # Reject names that are not valid shell variable names.
 601     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 602       { echo "$as_me: error: invalid package name: $ac_package" >&2
 603    { (exit 1); exit 1; }; }
 604     ac_package=`echo $ac_package | sed 's/-/_/g'`
 605     eval "with_$ac_package=no" ;;
 606
 607   --x)
 608     # Obsolete; use --with-x.
 609     with_x=yes ;;
 610
 611   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 612   | --x-incl | --x-inc | --x-in | --x-i)
 613     ac_prev=x_includes ;;
 614   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 615   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 616     x_includes=$ac_optarg ;;
 617
 618   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 619   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 620     ac_prev=x_libraries ;;
 621   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 622   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 623     x_libraries=$ac_optarg ;;
 624
 625   -*) { echo "$as_me: error: unrecognized option: $ac_option
 626 Try \`$0 --help' for more information." >&2
 627    { (exit 1); exit 1; }; }
 628     ;;
 629
 630   *=*)
 631     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 632     # Reject names that are not valid shell variable names.
 633     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 634       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 635    { (exit 1); exit 1; }; }
 636     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 637     eval "$ac_envvar='$ac_optarg'"
 638     export $ac_envvar ;;
 639
 640   *)
 641     # FIXME: should be removed in autoconf 3.0.
 642     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 643     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 644       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 645     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 646     ;;
 647
 648   esac
 649 done
 650
 651 if test -n "$ac_prev"; then
 652   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 653   { echo "$as_me: error: missing argument to $ac_option" >&2
 654    { (exit 1); exit 1; }; }
 655 fi
 656
 657 # Be sure to have absolute paths.
 658 for ac_var in exec_prefix prefix
 659 do
 660   eval ac_val=$`echo $ac_var`
 661   case $ac_val in
 662     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 663     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 664    { (exit 1); exit 1; }; };;
 665   esac
 666 done
 667
 668 # Be sure to have absolute paths.
 669 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 670               localstatedir libdir includedir oldincludedir infodir mandir
 671 do
 672   eval ac_val=$`echo $ac_var`
 673   case $ac_val in
 674     [\\/$]* | ?:[\\/]* ) ;;
 675     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 676    { (exit 1); exit 1; }; };;
 677   esac
 678 done
 679
 680 # There might be people who depend on the old broken behavior: `$host'
 681 # used to hold the argument of --host etc.
 682 # FIXME: To remove some day.
 683 build=$build_alias
 684 host=$host_alias
 685 target=$target_alias
 686
 687 # FIXME: To remove some day.
 688 if test "x$host_alias" != x; then
 689   if test "x$build_alias" = x; then
 690     cross_compiling=maybe
 691     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 692     If a cross compiler is detected then cross compile mode will be used." >&2
 693   elif test "x$build_alias" != "x$host_alias"; then
 694     cross_compiling=yes
 695   fi
 696 fi
 697
 698 ac_tool_prefix=
 699 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 700
 701 test "$silent" = yes && exec 6>/dev/null
 702
 703
 704 # Find the source files, if location was not specified.
 705 if test -z "$srcdir"; then
 706   ac_srcdir_defaulted=yes
 707   # Try the directory containing this script, then its parent.
 708   ac_confdir=`(dirname "$0") 2>/dev/null ||
 709 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 710          X"$0" : 'X\(//\)[^/]' \| \
 711          X"$0" : 'X\(//\)$' \| \
 712          X"$0" : 'X\(/\)' \| \
 713          .     : '\(.\)' 2>/dev/null ||
 714 echo X"$0" |
 715     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 716           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 717           /^X\(\/\/\)$/{ s//\1/; q; }
 718           /^X\(\/\).*/{ s//\1/; q; }
 719           s/.*/./; q'`
 720   srcdir=$ac_confdir
 721   if test ! -r $srcdir/$ac_unique_file; then
 722     srcdir=..
 723   fi
 724 else
 725   ac_srcdir_defaulted=no
 726 fi
 727 if test ! -r $srcdir/$ac_unique_file; then
 728   if test "$ac_srcdir_defaulted" = yes; then
 729     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 730    { (exit 1); exit 1; }; }
 731   else
 732     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 733    { (exit 1); exit 1; }; }
 734   fi
 735 fi
 736 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 737   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 738    { (exit 1); exit 1; }; }
 739 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 740 ac_env_build_alias_set=${build_alias+set}
 741 ac_env_build_alias_value=$build_alias
 742 ac_cv_env_build_alias_set=${build_alias+set}
 743 ac_cv_env_build_alias_value=$build_alias
 744 ac_env_host_alias_set=${host_alias+set}
 745 ac_env_host_alias_value=$host_alias
 746 ac_cv_env_host_alias_set=${host_alias+set}
 747 ac_cv_env_host_alias_value=$host_alias
 748 ac_env_target_alias_set=${target_alias+set}
 749 ac_env_target_alias_value=$target_alias
 750 ac_cv_env_target_alias_set=${target_alias+set}
 751 ac_cv_env_target_alias_value=$target_alias
 752 ac_env_FC_set=${FC+set}
 753 ac_env_FC_value=$FC
 754 ac_cv_env_FC_set=${FC+set}
 755 ac_cv_env_FC_value=$FC
 756 ac_env_FCFLAGS_set=${FCFLAGS+set}
 757 ac_env_FCFLAGS_value=$FCFLAGS
 758 ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
 759 ac_cv_env_FCFLAGS_value=$FCFLAGS
 760 ac_env_LDFLAGS_set=${LDFLAGS+set}
 761 ac_env_LDFLAGS_value=$LDFLAGS
 762 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 763 ac_cv_env_LDFLAGS_value=$LDFLAGS
 764 ac_env_CPP_set=${CPP+set}
 765 ac_env_CPP_value=$CPP
 766 ac_cv_env_CPP_set=${CPP+set}
 767 ac_cv_env_CPP_value=$CPP
 768 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 769 ac_env_CPPFLAGS_value=$CPPFLAGS
 770 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 771 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 772
 773 #
 774 # Report the --help message.
 775 #
 776 if test "$ac_init_help" = "long"; then
 777   # Omit some internal or obsolete options to make the list less imposing.
 778   # This message is too long to be a string in the A/UX 3.1 sh.
 779   cat <<_ACEOF
 780 \`configure' configures GNU Fortran Runtime Library 0.3 to adapt to many kinds of systems.
 781
 782 Usage: $0 [OPTION]... [VAR=VALUE]...
 783
 784 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 785 VAR=VALUE.  See below for descriptions of some of the useful variables.
 786
 787 Defaults for the options are specified in brackets.
 788
 789 Configuration:
 790   -h, --help              display this help and exit
 791       --help=short        display options specific to this package
 792       --help=recursive    display the short help of all the included packages
 793   -V, --version           display version information and exit
 794   -q, --quiet, --silent   do not print \`checking...' messages
 795       --cache-file=FILE   cache test results in FILE [disabled]
 796   -C, --config-cache      alias for \`--cache-file=config.cache'
 797   -n, --no-create         do not create output files
 798       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 799
 800 _ACEOF
 801
 802   cat <<_ACEOF
 803 Installation directories:
 804   --prefix=PREFIX         install architecture-independent files in PREFIX
 805                           [$ac_default_prefix]
 806   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 807                           [PREFIX]
 808
 809 By default, \`make install' will install all the files in
 810 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 811 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 812 for instance \`--prefix=\$HOME'.
 813
 814 For better control, use the options below.
 815
 816 Fine tuning of the installation directories:
 817   --bindir=DIR           user executables [EPREFIX/bin]
 818   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 819   --libexecdir=DIR       program executables [EPREFIX/libexec]
 820   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 821   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 822   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 823   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 824   --libdir=DIR           object code libraries [EPREFIX/lib]
 825   --includedir=DIR       C header files [PREFIX/include]
 826   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 827   --infodir=DIR          info documentation [PREFIX/info]
 828   --mandir=DIR           man documentation [PREFIX/man]
 829 _ACEOF
 830
 831   cat <<\_ACEOF
 832
 833 Program names:
 834   --program-prefix=PREFIX            prepend PREFIX to installed program names
 835   --program-suffix=SUFFIX            append SUFFIX to installed program names
 836   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 837
 838 System types:
 839   --build=BUILD     configure for building on BUILD [guessed]
 840   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 841   --target=TARGET   configure for building compilers for TARGET [HOST]
 842 _ACEOF
 843 fi
 844
 845 if test -n "$ac_init_help"; then
 846   case $ac_init_help in
 847      short | recursive ) echo "Configuration of GNU Fortran Runtime Library 0.3:";;
 848    esac
 849   cat <<\_ACEOF
 850
 851 Optional Features:
 852   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 853   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 854   --enable-version-specific-runtime-libs    Specify that runtime libraries should be installed in a compiler-specific directory
 855   --enable-maintainer-mode  enable make rules and dependencies not useful
 856                           (and sometimes confusing) to the casual installer
 857   --enable-multilib       build many library versions (default)
 858   --disable-dependency-tracking  speeds up one-time build
 859   --enable-dependency-tracking   do not reject slow dependency extractors
 860   --enable-shared=PKGS  build shared libraries default=yes
 861   --enable-static=PKGS  build static libraries default=yes
 862   --enable-fast-install=PKGS  optimize for fast installation default=yes
 863   --disable-libtool-lock  avoid locking (might break parallel builds)
 864   --disable-largefile     omit support for large files
 865
 866 Optional Packages:
 867   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 868   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 869   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 870   --with-gnu-ld           assume the C compiler uses GNU ld default=no
 871   --with-pic              try to use only PIC/non-PIC objects default=use both
 872
 873 Some influential environment variables:
 874   CC          C compiler command
 875   CFLAGS      C compiler flags
 876   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 877               nonstandard directory <lib dir>
 878   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 879               headers in a nonstandard directory <include dir>
 880   FC          Fortran compiler command
 881   FCFLAGS     Fortran compiler flags
 882   CPP         C preprocessor
 883
 884 Use these variables to override the choices made by `configure' or to help
 885 it to find libraries and programs with nonstandard names/locations.
 886
 887 _ACEOF
 888 fi
 889
 890 if test "$ac_init_help" = "recursive"; then
 891   # If there are subdirs, report their specific --help.
 892   ac_popdir=`pwd`
 893   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
 894     test -d $ac_dir || continue
 895     ac_builddir=.
 896
 897 if test "$ac_dir" != .; then
 898   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
 899   # A "../" for each directory in $ac_dir_suffix.
 900   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
 901 else
 902   ac_dir_suffix= ac_top_builddir=
 903 fi
 904
 905 case $srcdir in
 906   .)  # No --srcdir option.  We are building in place.
 907     ac_srcdir=.
 908     if test -z "$ac_top_builddir"; then
 909        ac_top_srcdir=.
 910     else
 911        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
 912     fi ;;
 913   [\\/]* | ?:[\\/]* )  # Absolute path.
 914     ac_srcdir=$srcdir$ac_dir_suffix;
 915     ac_top_srcdir=$srcdir ;;
 916   *) # Relative path.
 917     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
 918     ac_top_srcdir=$ac_top_builddir$srcdir ;;
 919 esac
 920
 921 # Do not use `cd foo && pwd` to compute absolute paths, because
 922 # the directories may not exist.
 923 case `pwd` in
 924 .) ac_abs_builddir="$ac_dir";;
 925 *)
 926   case "$ac_dir" in
 927   .) ac_abs_builddir=`pwd`;;
 928   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
 929   *) ac_abs_builddir=`pwd`/"$ac_dir";;
 930   esac;;
 931 esac
 932 case $ac_abs_builddir in
 933 .) ac_abs_top_builddir=${ac_top_builddir}.;;
 934 *)
 935   case ${ac_top_builddir}. in
 936   .) ac_abs_top_builddir=$ac_abs_builddir;;
 937   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
 938   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
 939   esac;;
 940 esac
 941 case $ac_abs_builddir in
 942 .) ac_abs_srcdir=$ac_srcdir;;
 943 *)
 944   case $ac_srcdir in
 945   .) ac_abs_srcdir=$ac_abs_builddir;;
 946   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
 947   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
 948   esac;;
 949 esac
 950 case $ac_abs_builddir in
 951 .) ac_abs_top_srcdir=$ac_top_srcdir;;
 952 *)
 953   case $ac_top_srcdir in
 954   .) ac_abs_top_srcdir=$ac_abs_builddir;;
 955   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
 956   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
 957   esac;;
 958 esac
 959
 960     cd $ac_dir
 961     # Check for guested configure; otherwise get Cygnus style configure.
 962     if test -f $ac_srcdir/configure.gnu; then
 963       echo
 964       $SHELL $ac_srcdir/configure.gnu  --help=recursive
 965     elif test -f $ac_srcdir/configure; then
 966       echo
 967       $SHELL $ac_srcdir/configure  --help=recursive
 968     elif test -f $ac_srcdir/configure.ac ||
 969            test -f $ac_srcdir/configure.in; then
 970       echo
 971       $ac_configure --help
 972     else
 973       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
 974     fi
 975     cd $ac_popdir
 976   done
 977 fi
 978
 979 test -n "$ac_init_help" && exit 0
 980 if $ac_init_version; then
 981   cat <<\_ACEOF
 982 GNU Fortran Runtime Library configure 0.3
 983 generated by GNU Autoconf 2.59
 984
 985 Copyright (C) 2003 Free Software Foundation, Inc.
 986 This configure script is free software; the Free Software Foundation
 987 gives unlimited permission to copy, distribute and modify it.
 988 _ACEOF
 989   exit 0
 990 fi
 991 exec 5>config.log
 992 cat >&5 <<_ACEOF
 993 This file contains any messages produced by compilers while
 994 running configure, to aid debugging if configure makes a mistake.
 995
 996 It was created by GNU Fortran Runtime Library $as_me 0.3, which was
 997 generated by GNU Autoconf 2.59.  Invocation command line was
 998
 999   $ $0 $@
1000
1001 _ACEOF
1002 {
1003 cat <<_ASUNAME
1004 ## --------- ##
1005 ## Platform. ##
1006 ## --------- ##
1007
1008 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1009 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1010 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1011 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1012 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1013
1014 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1015 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1016
1017 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1018 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1019 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1020 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1021 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1022 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1023 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1024
1025 _ASUNAME
1026
1027 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1028 for as_dir in $PATH
1029 do
1030   IFS=$as_save_IFS
1031   test -z "$as_dir" && as_dir=.
1032   echo "PATH: $as_dir"
1033 done
1034
1035 } >&5
1036
1037 cat >&5 <<_ACEOF
1038
1039
1040 ## ----------- ##
1041 ## Core tests. ##
1042 ## ----------- ##
1043
1044 _ACEOF
1045
1046
1047 # Keep a trace of the command line.
1048 # Strip out --no-create and --no-recursion so they do not pile up.
1049 # Strip out --silent because we don't want to record it for future runs.
1050 # Also quote any args containing shell meta-characters.
1051 # Make two passes to allow for proper duplicate-argument suppression.
1052 ac_configure_args=
1053 ac_configure_args0=
1054 ac_configure_args1=
1055 ac_sep=
1056 ac_must_keep_next=false
1057 for ac_pass in 1 2
1058 do
1059   for ac_arg
1060   do
1061     case $ac_arg in
1062     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1063     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1064     | -silent | --silent | --silen | --sile | --sil)
1065       continue ;;
1066     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1067       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1068     esac
1069     case $ac_pass in
1070     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1071     2)
1072       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1073       if test $ac_must_keep_next = true; then
1074         ac_must_keep_next=false # Got value, back to normal.
1075       else
1076         case $ac_arg in
1077           *=* | --config-cache | -C | -disable-* | --disable-* \
1078           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1079           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1080           | -with-* | --with-* | -without-* | --without-* | --x)
1081             case "$ac_configure_args0 " in
1082               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1083             esac
1084             ;;
1085           -* ) ac_must_keep_next=true ;;
1086         esac
1087       fi
1088       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1089       # Get rid of the leading space.
1090       ac_sep=" "
1091       ;;
1092     esac
1093   done
1094 done
1095 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1096 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1097
1098 # When interrupted or exit'd, cleanup temporary files, and complete
1099 # config.log.  We remove comments because anyway the quotes in there
1100 # would cause problems or look ugly.
1101 # WARNING: Be sure not to use single quotes in there, as some shells,
1102 # such as our DU 5.0 friend, will then `close' the trap.
1103 trap 'exit_status=$?
1104   # Save into config.log some information that might help in debugging.
1105   {
1106     echo
1107
1108     cat <<\_ASBOX
1109 ## ---------------- ##
1110 ## Cache variables. ##
1111 ## ---------------- ##
1112 _ASBOX
1113     echo
1114     # The following way of writing the cache mishandles newlines in values,
1115 {
1116   (set) 2>&1 |
1117     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1118     *ac_space=\ *)
1119       sed -n \
1120         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1121           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1122       ;;
1123     *)
1124       sed -n \
1125         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1126       ;;
1127     esac;
1128 }
1129     echo
1130
1131     cat <<\_ASBOX
1132 ## ----------------- ##
1133 ## Output variables. ##
1134 ## ----------------- ##
1135 _ASBOX
1136     echo
1137     for ac_var in $ac_subst_vars
1138     do
1139       eval ac_val=$`echo $ac_var`
1140       echo "$ac_var='"'"'$ac_val'"'"'"
1141     done | sort
1142     echo
1143
1144     if test -n "$ac_subst_files"; then
1145       cat <<\_ASBOX
1146 ## ------------- ##
1147 ## Output files. ##
1148 ## ------------- ##
1149 _ASBOX
1150       echo
1151       for ac_var in $ac_subst_files
1152       do
1153         eval ac_val=$`echo $ac_var`
1154         echo "$ac_var='"'"'$ac_val'"'"'"
1155       done | sort
1156       echo
1157     fi
1158
1159     if test -s confdefs.h; then
1160       cat <<\_ASBOX
1161 ## ----------- ##
1162 ## confdefs.h. ##
1163 ## ----------- ##
1164 _ASBOX
1165       echo
1166       sed "/^$/d" confdefs.h | sort
1167       echo
1168     fi
1169     test "$ac_signal" != 0 &&
1170       echo "$as_me: caught signal $ac_signal"
1171     echo "$as_me: exit $exit_status"
1172   } >&5
1173   rm -f core *.core &&
1174   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1175     exit $exit_status
1176      ' 0
1177 for ac_signal in 1 2 13 15; do
1178   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1179 done
1180 ac_signal=0
1181
1182 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1183 rm -rf conftest* confdefs.h
1184 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1185 echo >confdefs.h
1186
1187 # Predefined preprocessor variables.
1188
1189 cat >>confdefs.h <<_ACEOF
1190 #define PACKAGE_NAME "$PACKAGE_NAME"
1191 _ACEOF
1192
1193
1194 cat >>confdefs.h <<_ACEOF
1195 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1196 _ACEOF
1197
1198
1199 cat >>confdefs.h <<_ACEOF
1200 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1201 _ACEOF
1202
1203
1204 cat >>confdefs.h <<_ACEOF
1205 #define PACKAGE_STRING "$PACKAGE_STRING"
1206 _ACEOF
1207
1208
1209 cat >>confdefs.h <<_ACEOF
1210 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1211 _ACEOF
1212
1213
1214 # Let the site file select an alternate cache file if it wants to.
1215 # Prefer explicitly selected file to automatically selected ones.
1216 if test -z "$CONFIG_SITE"; then
1217   if test "x$prefix" != xNONE; then
1218     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1219   else
1220     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1221   fi
1222 fi
1223 for ac_site_file in $CONFIG_SITE; do
1224   if test -r "$ac_site_file"; then
1225     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1226 echo "$as_me: loading site script $ac_site_file" >&6;}
1227     sed 's/^/| /' "$ac_site_file" >&5
1228     . "$ac_site_file"
1229   fi
1230 done
1231
1232 if test -r "$cache_file"; then
1233   # Some versions of bash will fail to source /dev/null (special
1234   # files actually), so we avoid doing that.
1235   if test -f "$cache_file"; then
1236     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1237 echo "$as_me: loading cache $cache_file" >&6;}
1238     case $cache_file in
1239       [\\/]* | ?:[\\/]* ) . $cache_file;;
1240       *)                      . ./$cache_file;;
1241     esac
1242   fi
1243 else
1244   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1245 echo "$as_me: creating cache $cache_file" >&6;}
1246   >$cache_file
1247 fi
1248
1249 # Check that the precious variables saved in the cache have kept the same
1250 # value.
1251 ac_cache_corrupted=false
1252 for ac_var in `(set) 2>&1 |
1253                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1254   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1255   eval ac_new_set=\$ac_env_${ac_var}_set
1256   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1257   eval ac_new_val="\$ac_env_${ac_var}_value"
1258   case $ac_old_set,$ac_new_set in
1259     set,)
1260       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1261 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1262       ac_cache_corrupted=: ;;
1263     ,set)
1264       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1265 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1266       ac_cache_corrupted=: ;;
1267     ,);;
1268     *)
1269       if test "x$ac_old_val" != "x$ac_new_val"; then
1270         { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1271 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1272         { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1273 echo "$as_me:   former value:  $ac_old_val" >&2;}
1274         { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1275 echo "$as_me:   current value: $ac_new_val" >&2;}
1276         ac_cache_corrupted=:
1277       fi;;
1278   esac
1279   # Pass precious variables to config.status.
1280   if test "$ac_new_set" = set; then
1281     case $ac_new_val in
1282     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1283       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1284     *) ac_arg=$ac_var=$ac_new_val ;;
1285     esac
1286     case " $ac_configure_args " in
1287       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1288       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1289     esac
1290   fi
1291 done
1292 if $ac_cache_corrupted; then
1293   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1294 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1295   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1296 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1297    { (exit 1); exit 1; }; }
1298 fi
1299
1300 ac_ext=c
1301 ac_cpp='$CPP $CPPFLAGS'
1302 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1303 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1304 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332           ac_config_headers="$ac_config_headers config.h"
1333
1334 ac_aux_dir=
1335 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1336   if test -f $ac_dir/install-sh; then
1337     ac_aux_dir=$ac_dir
1338     ac_install_sh="$ac_aux_dir/install-sh -c"
1339     break
1340   elif test -f $ac_dir/install.sh; then
1341     ac_aux_dir=$ac_dir
1342     ac_install_sh="$ac_aux_dir/install.sh -c"
1343     break
1344   elif test -f $ac_dir/shtool; then
1345     ac_aux_dir=$ac_dir
1346     ac_install_sh="$ac_aux_dir/shtool install -c"
1347     break
1348   fi
1349 done
1350 if test -z "$ac_aux_dir"; then
1351   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1352 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1353    { (exit 1); exit 1; }; }
1354 fi
1355 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1356 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1357 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1358
1359 # Make sure we can run config.sub.
1360 $ac_config_sub sun4 >/dev/null 2>&1 ||
1361   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1362 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1363    { (exit 1); exit 1; }; }
1364
1365 echo "$as_me:$LINENO: checking build system type" >&5
1366 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1367 if test "${ac_cv_build+set}" = set; then
1368   echo $ECHO_N "(cached) $ECHO_C" >&6
1369 else
1370   ac_cv_build_alias=$build_alias
1371 test -z "$ac_cv_build_alias" &&
1372   ac_cv_build_alias=`$ac_config_guess`
1373 test -z "$ac_cv_build_alias" &&
1374   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1375 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1376    { (exit 1); exit 1; }; }
1377 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1378   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1379 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1380    { (exit 1); exit 1; }; }
1381
1382 fi
1383 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1384 echo "${ECHO_T}$ac_cv_build" >&6
1385 build=$ac_cv_build
1386 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1387 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1388 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1389
1390
1391  case ${build_alias} in
1392   "") build_noncanonical=${build} ;;
1393   *) build_noncanonical=${build_alias} ;;
1394 esac
1395
1396  case ${host_alias} in
1397   "") host_noncanonical=${build_noncanonical} ;;
1398   *) host_noncanonical=${host_alias} ;;
1399 esac
1400
1401  case ${target_alias} in
1402   "") target_noncanonical=${host_noncanonical} ;;
1403   *) target_noncanonical=${target_alias} ;;
1404 esac
1405
1406
1407 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1408 # have matching libraries, they should use host libraries: Makefile.tpl
1409 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1410 # However, they still use the build modules, because the corresponding
1411 # host modules (e.g. bison) are only built for the host when bootstrap
1412 # finishes. So:
1413 # - build_subdir is where we find build modules, and never changes.
1414 # - build_libsubdir is where we find build libraries, and can be overridden.
1415
1416 # Prefix 'build-' so this never conflicts with target_subdir.
1417 build_subdir="build-${build_noncanonical}"
1418
1419 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1420 if test "${with_build_libsubdir+set}" = set; then
1421   withval="$with_build_libsubdir"
1422   build_libsubdir="$withval"
1423 else
1424   build_libsubdir="$build_subdir"
1425 fi;
1426 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1427 if ( test $srcdir = . && test -d gcc ) \
1428    || test -d $srcdir/../host-${host_noncanonical}; then
1429   host_subdir="host-${host_noncanonical}"
1430 else
1431   host_subdir=.
1432 fi
1433 # No prefix.
1434 target_subdir=${target_noncanonical}
1435
1436
1437 # -------
1438 # Options
1439 # -------
1440
1441 echo "$as_me:$LINENO: checking for --enable-version-specific-runtime-libs" >&5
1442 echo $ECHO_N "checking for --enable-version-specific-runtime-libs... $ECHO_C" >&6
1443 # Check whether --enable-version-specific-runtime-libs or --disable-version-specific-runtime-libs was given.
1444 if test "${enable_version_specific_runtime_libs+set}" = set; then
1445   enableval="$enable_version_specific_runtime_libs"
1446   case "$enableval" in
1447  yes) version_specific_libs=yes ;;
1448  no)  version_specific_libs=no ;;
1449  *)   { { echo "$as_me:$LINENO: error: Unknown argument to enable/disable version-specific libs" >&5
1450 echo "$as_me: error: Unknown argument to enable/disable version-specific libs" >&2;}
1451    { (exit 1); exit 1; }; };;
1452  esac
1453 else
1454   version_specific_libs=no
1455 fi;
1456 echo "$as_me:$LINENO: result: $version_specific_libs" >&5
1457 echo "${ECHO_T}$version_specific_libs" >&6
1458
1459
1460 # Gets build, host, target, *_vendor, *_cpu, *_os, etc.
1461 #
1462 # You will slowly go insane if you do not grok the following fact:  when
1463 # building this library, the top-level /target/ becomes the library's /host/.
1464 #
1465 # configure then causes --target to default to --host, exactly like any
1466 # other package using autoconf.  Therefore, 'target' and 'host' will
1467 # always be the same.  This makes sense both for native and cross compilers
1468 # just think about it for a little while.  :-)
1469 #
1470 # Also, if this library is being configured as part of a cross compiler, the
1471 # top-level configure script will pass the "real" host as $with_cross_host.
1472 #
1473 # Do not delete or change the following two lines.  For why, see
1474 # http://gcc.gnu.org/ml/libstdc++/2003-07/msg00451.html
1475 echo "$as_me:$LINENO: checking host system type" >&5
1476 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1477 if test "${ac_cv_host+set}" = set; then
1478   echo $ECHO_N "(cached) $ECHO_C" >&6
1479 else
1480   ac_cv_host_alias=$host_alias
1481 test -z "$ac_cv_host_alias" &&
1482   ac_cv_host_alias=$ac_cv_build_alias
1483 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1484   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1485 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1486    { (exit 1); exit 1; }; }
1487
1488 fi
1489 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1490 echo "${ECHO_T}$ac_cv_host" >&6
1491 host=$ac_cv_host
1492 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1493 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1494 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1495
1496
1497 echo "$as_me:$LINENO: checking target system type" >&5
1498 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1499 if test "${ac_cv_target+set}" = set; then
1500   echo $ECHO_N "(cached) $ECHO_C" >&6
1501 else
1502   ac_cv_target_alias=$target_alias
1503 test "x$ac_cv_target_alias" = "x" &&
1504   ac_cv_target_alias=$ac_cv_host_alias
1505 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1506   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1507 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1508    { (exit 1); exit 1; }; }
1509
1510 fi
1511 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1512 echo "${ECHO_T}$ac_cv_target" >&6
1513 target=$ac_cv_target
1514 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1515 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1516 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1517
1518
1519 # The aliases save the names the user supplied, while $host etc.
1520 # will get canonicalized.
1521 test -n "$target_alias" &&
1522   test "$program_prefix$program_suffix$program_transform_name" = \
1523     NONENONEs,x,x, &&
1524   program_prefix=${target_alias}-
1525 target_alias=${target_alias-$host_alias}
1526
1527 # Sets up automake.  Must come after AC_CANONICAL_SYSTEM.  Each of the
1528 # following is magically included in AUTOMAKE_OPTIONS in each Makefile.am.
1529 #  1.9.6:  minimum required version
1530 #  no-define:  PACKAGE and VERSION will not be #define'd in config.h (a bunch
1531 #              of other PACKAGE_* variables will, however, and there's nothing
1532 #              we can do about that; they come from AC_INIT).
1533 #  foreign:  we don't follow the normal rules for GNU packages (no COPYING
1534 #            file in the top srcdir, etc, etc), so stop complaining.
1535 #  -Wall:  turns on all automake warnings...
1536 #  -Wno-portability:  ...except this one, since GNU make is required.
1537 am__api_version="1.9"
1538 # Find a good install program.  We prefer a C program (faster),
1539 # so one script is as good as another.  But avoid the broken or
1540 # incompatible versions:
1541 # SysV /etc/install, /usr/sbin/install
1542 # SunOS /usr/etc/install
1543 # IRIX /sbin/install
1544 # AIX /bin/install
1545 # AmigaOS /C/install, which installs bootblocks on floppy discs
1546 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1547 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1548 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1549 # OS/2's system install, which has a completely different semantic
1550 # ./install, which can be erroneously created by make from ./install.sh.
1551 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1552 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1553 if test -z "$INSTALL"; then
1554 if test "${ac_cv_path_install+set}" = set; then
1555   echo $ECHO_N "(cached) $ECHO_C" >&6
1556 else
1557   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1558 for as_dir in $PATH
1559 do
1560   IFS=$as_save_IFS
1561   test -z "$as_dir" && as_dir=.
1562   # Account for people who put trailing slashes in PATH elements.
1563 case $as_dir/ in
1564   ./ | .// | /cC/* | \
1565   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1566   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1567   /usr/ucb/* ) ;;
1568   *)
1569     # OSF1 and SCO ODT 3.0 have their own names for install.
1570     # Don't use installbsd from OSF since it installs stuff as root
1571     # by default.
1572     for ac_prog in ginstall scoinst install; do
1573       for ac_exec_ext in '' $ac_executable_extensions; do
1574         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1575           if test $ac_prog = install &&
1576             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1577             # AIX install.  It has an incompatible calling convention.
1578             :
1579           elif test $ac_prog = install &&
1580             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1581             # program-specific install script used by HP pwplus--don't use.
1582             :
1583           else
1584             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1585             break 3
1586           fi
1587         fi
1588       done
1589     done
1590     ;;
1591 esac
1592 done
1593
1594
1595 fi
1596   if test "${ac_cv_path_install+set}" = set; then
1597     INSTALL=$ac_cv_path_install
1598   else
1599     # As a last resort, use the slow shell script.  We don't cache a
1600     # path for INSTALL within a source directory, because that will
1601     # break other packages using the cache if that directory is
1602     # removed, or if the path is relative.
1603     INSTALL=$ac_install_sh
1604   fi
1605 fi
1606 echo "$as_me:$LINENO: result: $INSTALL" >&5
1607 echo "${ECHO_T}$INSTALL" >&6
1608
1609 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1610 # It thinks the first close brace ends the variable substitution.
1611 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1612
1613 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1614
1615 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1616
1617 echo "$as_me:$LINENO: checking whether build environment is sane" >&5
1618 echo $ECHO_N "checking whether build environment is sane... $ECHO_C" >&6
1619 # Just in case
1620 sleep 1
1621 echo timestamp > conftest.file
1622 # Do `set' in a subshell so we don't clobber the current shell's
1623 # arguments.  Must try -L first in case configure is actually a
1624 # symlink; some systems play weird games with the mod time of symlinks
1625 # (eg FreeBSD returns the mod time of the symlink's containing
1626 # directory).
1627 if (
1628    set X `ls -Lt $srcdir/configure conftest.file 2> /dev/null`
1629    if test "$*" = "X"; then
1630       # -L didn't work.
1631       set X `ls -t $srcdir/configure conftest.file`
1632    fi
1633    rm -f conftest.file
1634    if test "$*" != "X $srcdir/configure conftest.file" \
1635       && test "$*" != "X conftest.file $srcdir/configure"; then
1636
1637       # If neither matched, then we have a broken ls.  This can happen
1638       # if, for instance, CONFIG_SHELL is bash and it inherits a
1639       # broken ls alias from the environment.  This has actually
1640       # happened.  Such a system could not be considered "sane".
1641       { { echo "$as_me:$LINENO: error: ls -t appears to fail.  Make sure there is not a broken
1642 alias in your environment" >&5
1643 echo "$as_me: error: ls -t appears to fail.  Make sure there is not a broken
1644 alias in your environment" >&2;}
1645    { (exit 1); exit 1; }; }
1646    fi
1647
1648    test "$2" = conftest.file
1649    )
1650 then
1651    # Ok.
1652    :
1653 else
1654    { { echo "$as_me:$LINENO: error: newly created file is older than distributed files!
1655 Check your system clock" >&5
1656 echo "$as_me: error: newly created file is older than distributed files!
1657 Check your system clock" >&2;}
1658    { (exit 1); exit 1; }; }
1659 fi
1660 echo "$as_me:$LINENO: result: yes" >&5
1661 echo "${ECHO_T}yes" >&6
1662 test "$program_prefix" != NONE &&
1663   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1664 # Use a double $ so make ignores it.
1665 test "$program_suffix" != NONE &&
1666   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1667 # Double any \ or $.  echo might interpret backslashes.
1668 # By default was `s,x,x', remove it if useless.
1669 cat <<\_ACEOF >conftest.sed
1670 s/[\\$]/&&/g;s/;s,x,x,$//
1671 _ACEOF
1672 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1673 rm conftest.sed
1674
1675 # expand $ac_aux_dir to an absolute path
1676 am_aux_dir=`cd $ac_aux_dir && pwd`
1677
1678 test x"${MISSING+set}" = xset || MISSING="\${SHELL} $am_aux_dir/missing"
1679 # Use eval to expand $SHELL
1680 if eval "$MISSING --run true"; then
1681   am_missing_run="$MISSING --run "
1682 else
1683   am_missing_run=
1684   { echo "$as_me:$LINENO: WARNING: \`missing' script is too old or missing" >&5
1685 echo "$as_me: WARNING: \`missing' script is too old or missing" >&2;}
1686 fi
1687
1688 if mkdir -p --version . >/dev/null 2>&1 && test ! -d ./--version; then
1689   # We used to keeping the `.' as first argument, in order to
1690   # allow $(mkdir_p) to be used without argument.  As in
1691   #   $(mkdir_p) $(somedir)
1692   # where $(somedir) is conditionally defined.  However this is wrong
1693   # for two reasons:
1694   #  1. if the package is installed by a user who cannot write `.'
1695   #     make install will fail,
1696   #  2. the above comment should most certainly read
1697   #     $(mkdir_p) $(DESTDIR)$(somedir)
1698   #     so it does not work when $(somedir) is undefined and
1699   #     $(DESTDIR) is not.
1700   #  To support the latter case, we have to write
1701   #     test -z "$(somedir)" || $(mkdir_p) $(DESTDIR)$(somedir),
1702   #  so the `.' trick is pointless.
1703   mkdir_p='mkdir -p --'
1704 else
1705   # On NextStep and OpenStep, the `mkdir' command does not
1706   # recognize any option.  It will interpret all options as
1707   # directories to create, and then abort because `.' already
1708   # exists.
1709   for d in ./-p ./--version;
1710   do
1711     test -d $d && rmdir $d
1712   done
1713   # $(mkinstalldirs) is defined by Automake if mkinstalldirs exists.
1714   if test -f "$ac_aux_dir/mkinstalldirs"; then
1715     mkdir_p='$(mkinstalldirs)'
1716   else
1717     mkdir_p='$(install_sh) -d'
1718   fi
1719 fi
1720
1721 for ac_prog in gawk mawk nawk awk
1722 do
1723   # Extract the first word of "$ac_prog", so it can be a program name with args.
1724 set dummy $ac_prog; ac_word=$2
1725 echo "$as_me:$LINENO: checking for $ac_word" >&5
1726 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1727 if test "${ac_cv_prog_AWK+set}" = set; then
1728   echo $ECHO_N "(cached) $ECHO_C" >&6
1729 else
1730   if test -n "$AWK"; then
1731   ac_cv_prog_AWK="$AWK" # Let the user override the test.
1732 else
1733 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1734 for as_dir in $PATH
1735 do
1736   IFS=$as_save_IFS
1737   test -z "$as_dir" && as_dir=.
1738   for ac_exec_ext in '' $ac_executable_extensions; do
1739   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1740     ac_cv_prog_AWK="$ac_prog"
1741     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1742     break 2
1743   fi
1744 done
1745 done
1746
1747 fi
1748 fi
1749 AWK=$ac_cv_prog_AWK
1750 if test -n "$AWK"; then
1751   echo "$as_me:$LINENO: result: $AWK" >&5
1752 echo "${ECHO_T}$AWK" >&6
1753 else
1754   echo "$as_me:$LINENO: result: no" >&5
1755 echo "${ECHO_T}no" >&6
1756 fi
1757
1758   test -n "$AWK" && break
1759 done
1760
1761 echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
1762 echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
1763 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
1764 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
1765   echo $ECHO_N "(cached) $ECHO_C" >&6
1766 else
1767   cat >conftest.make <<\_ACEOF
1768 all:
1769         @echo 'ac_maketemp="$(MAKE)"'
1770 _ACEOF
1771 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
1772 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
1773 if test -n "$ac_maketemp"; then
1774   eval ac_cv_prog_make_${ac_make}_set=yes
1775 else
1776   eval ac_cv_prog_make_${ac_make}_set=no
1777 fi
1778 rm -f conftest.make
1779 fi
1780 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
1781   echo "$as_me:$LINENO: result: yes" >&5
1782 echo "${ECHO_T}yes" >&6
1783   SET_MAKE=
1784 else
1785   echo "$as_me:$LINENO: result: no" >&5
1786 echo "${ECHO_T}no" >&6
1787   SET_MAKE="MAKE=${MAKE-make}"
1788 fi
1789
1790 rm -rf .tst 2>/dev/null
1791 mkdir .tst 2>/dev/null
1792 if test -d .tst; then
1793   am__leading_dot=.
1794 else
1795   am__leading_dot=_
1796 fi
1797 rmdir .tst 2>/dev/null
1798
1799 # test to see if srcdir already configured
1800 if test "`cd $srcdir && pwd`" != "`pwd`" &&
1801    test -f $srcdir/config.status; then
1802   { { echo "$as_me:$LINENO: error: source directory already configured; run \"make distclean\" there first" >&5
1803 echo "$as_me: error: source directory already configured; run \"make distclean\" there first" >&2;}
1804    { (exit 1); exit 1; }; }
1805 fi
1806
1807 # test whether we have cygpath
1808 if test -z "$CYGPATH_W"; then
1809   if (cygpath --version) >/dev/null 2>/dev/null; then
1810     CYGPATH_W='cygpath -w'
1811   else
1812     CYGPATH_W=echo
1813   fi
1814 fi
1815
1816
1817 # Define the identity of the package.
1818  PACKAGE='libgfortran'
1819  VERSION='0.3'
1820
1821
1822 # Some tools Automake needs.
1823
1824 ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}
1825
1826
1827 AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}
1828
1829
1830 AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}
1831
1832
1833 AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}
1834
1835
1836 MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
1837
1838 install_sh=${install_sh-"$am_aux_dir/install-sh"}
1839
1840 # Installed binaries are usually stripped using `strip' when the user
1841 # run `make install-strip'.  However `strip' might not be the right
1842 # tool to use in cross-compilation environments, therefore Automake
1843 # will honor the `STRIP' environment variable to overrule this program.
1844 if test "$cross_compiling" != no; then
1845   if test -n "$ac_tool_prefix"; then
1846   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
1847 set dummy ${ac_tool_prefix}strip; ac_word=$2
1848 echo "$as_me:$LINENO: checking for $ac_word" >&5
1849 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1850 if test "${ac_cv_prog_STRIP+set}" = set; then
1851   echo $ECHO_N "(cached) $ECHO_C" >&6
1852 else
1853   if test -n "$STRIP"; then
1854   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
1855 else
1856 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1857 for as_dir in $PATH
1858 do
1859   IFS=$as_save_IFS
1860   test -z "$as_dir" && as_dir=.
1861   for ac_exec_ext in '' $ac_executable_extensions; do
1862   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1863     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
1864     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1865     break 2
1866   fi
1867 done
1868 done
1869
1870 fi
1871 fi
1872 STRIP=$ac_cv_prog_STRIP
1873 if test -n "$STRIP"; then
1874   echo "$as_me:$LINENO: result: $STRIP" >&5
1875 echo "${ECHO_T}$STRIP" >&6
1876 else
1877   echo "$as_me:$LINENO: result: no" >&5
1878 echo "${ECHO_T}no" >&6
1879 fi
1880
1881 fi
1882 if test -z "$ac_cv_prog_STRIP"; then
1883   ac_ct_STRIP=$STRIP
1884   # Extract the first word of "strip", so it can be a program name with args.
1885 set dummy strip; ac_word=$2
1886 echo "$as_me:$LINENO: checking for $ac_word" >&5
1887 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1888 if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
1889   echo $ECHO_N "(cached) $ECHO_C" >&6
1890 else
1891   if test -n "$ac_ct_STRIP"; then
1892   ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
1893 else
1894 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1895 for as_dir in $PATH
1896 do
1897   IFS=$as_save_IFS
1898   test -z "$as_dir" && as_dir=.
1899   for ac_exec_ext in '' $ac_executable_extensions; do
1900   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1901     ac_cv_prog_ac_ct_STRIP="strip"
1902     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1903     break 2
1904   fi
1905 done
1906 done
1907
1908   test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
1909 fi
1910 fi
1911 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
1912 if test -n "$ac_ct_STRIP"; then
1913   echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
1914 echo "${ECHO_T}$ac_ct_STRIP" >&6
1915 else
1916   echo "$as_me:$LINENO: result: no" >&5
1917 echo "${ECHO_T}no" >&6
1918 fi
1919
1920   STRIP=$ac_ct_STRIP
1921 else
1922   STRIP="$ac_cv_prog_STRIP"
1923 fi
1924
1925 fi
1926 INSTALL_STRIP_PROGRAM="\${SHELL} \$(install_sh) -c -s"
1927
1928 # We need awk for the "check" target.  The system "awk" is bad on
1929 # some platforms.
1930 # Always define AMTAR for backward compatibility.
1931
1932 AMTAR=${AMTAR-"${am_missing_run}tar"}
1933
1934 am__tar='${AMTAR} chof - "$$tardir"'; am__untar='${AMTAR} xf -'
1935
1936
1937
1938
1939
1940
1941 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
1942 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
1943     # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
1944 if test "${enable_maintainer_mode+set}" = set; then
1945   enableval="$enable_maintainer_mode"
1946   USE_MAINTAINER_MODE=$enableval
1947 else
1948   USE_MAINTAINER_MODE=no
1949 fi;
1950   echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
1951 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
1952
1953
1954 if test $USE_MAINTAINER_MODE = yes; then
1955   MAINTAINER_MODE_TRUE=
1956   MAINTAINER_MODE_FALSE='#'
1957 else
1958   MAINTAINER_MODE_TRUE='#'
1959   MAINTAINER_MODE_FALSE=
1960 fi
1961
1962   MAINT=$MAINTAINER_MODE_TRUE
1963
1964
1965 # Default to --enable-multilib
1966 # Check whether --enable-multilib or --disable-multilib was given.
1967 if test "${enable_multilib+set}" = set; then
1968   enableval="$enable_multilib"
1969   case "$enableval" in
1970   yes) multilib=yes ;;
1971   no)  multilib=no ;;
1972   *)   { { echo "$as_me:$LINENO: error: bad value $enableval for multilib option" >&5
1973 echo "$as_me: error: bad value $enableval for multilib option" >&2;}
1974    { (exit 1); exit 1; }; } ;;
1975  esac
1976 else
1977   multilib=yes
1978 fi;
1979
1980 # We may get other options which we leave undocumented:
1981 # --with-target-subdir, --with-multisrctop, --with-multisubdir
1982 # See config-ml.in if you want the gory details.
1983
1984 if test "$srcdir" = "."; then
1985   if test "$with_target_subdir" != "."; then
1986     multi_basedir="$srcdir/$with_multisrctop../.."
1987   else
1988     multi_basedir="$srcdir/$with_multisrctop.."
1989   fi
1990 else
1991   multi_basedir="$srcdir/.."
1992 fi
1993
1994
1995 # Even if the default multilib is not a cross compilation,
1996 # it may be that some of the other multilibs are.
1997 if test $cross_compiling = no && test $multilib = yes \
1998    && test "x${with_multisubdir}" != x ; then
1999    cross_compiling=maybe
2000 fi
2001
2002           ac_config_commands="$ac_config_commands default-1"
2003
2004
2005 # Handy for debugging:
2006 #AC_MSG_NOTICE($build / $host / $target / $host_alias / $target_alias); sleep 5
2007
2008 # Are we being configured with some form of cross compiler?
2009 # NB: We don't actually need to know this just now, but when, say, a test
2010 #     suite is included, we'll have to know.
2011 if test "$build" != "$host"; then
2012   LIBGFOR_IS_NATIVE=false
2013
2014 else
2015   LIBGFOR_IS_NATIVE=true
2016 fi
2017
2018 # Calculate toolexeclibdir
2019 # Also toolexecdir, though it's only used in toolexeclibdir
2020 case ${version_specific_libs} in
2021   yes)
2022     # Need the gcc compiler version to know where to install libraries
2023     # and header files if --enable-version-specific-runtime-libs option
2024     # is selected.
2025     toolexecdir='$(libdir)/gcc/$(target_alias)'
2026     toolexeclibdir='$(toolexecdir)/$(gcc_version)$(MULTISUBDIR)'
2027     ;;
2028   no)
2029     if test -n "$with_cross_host" &&
2030        test x"$with_cross_host" != x"no"; then
2031       # Install a library built with a cross compiler in tooldir, not libdir.
2032       toolexecdir='$(exec_prefix)/$(target_alias)'
2033       toolexeclibdir='$(toolexecdir)/lib'
2034     else
2035       toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
2036       toolexeclibdir='$(libdir)'
2037     fi
2038     multi_os_directory=`$CC -print-multi-os-directory`
2039     case $multi_os_directory in
2040       .) ;; # Avoid trailing /.
2041       *) toolexeclibdir=$toolexeclibdir/$multi_os_directory ;;
2042     esac
2043     ;;
2044 esac
2045
2046
2047
2048 # Check the compiler.
2049 # The same as in boehm-gc and libstdc++. Have to borrow it from there.
2050 # We must force CC to /not/ be precious variables; otherwise
2051 # the wrong, non-multilib-adjusted value will be used in multilibs.
2052 # As a side effect, we have to subst CFLAGS ourselves.
2053
2054
2055
2056 ac_ext=c
2057 ac_cpp='$CPP $CPPFLAGS'
2058 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2059 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2060 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2061 if test -n "$ac_tool_prefix"; then
2062   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2063 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2064 echo "$as_me:$LINENO: checking for $ac_word" >&5
2065 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2066 if test "${ac_cv_prog_CC+set}" = set; then
2067   echo $ECHO_N "(cached) $ECHO_C" >&6
2068 else
2069   if test -n "$CC"; then
2070   ac_cv_prog_CC="$CC" # Let the user override the test.
2071 else
2072 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2073 for as_dir in $PATH
2074 do
2075   IFS=$as_save_IFS
2076   test -z "$as_dir" && as_dir=.
2077   for ac_exec_ext in '' $ac_executable_extensions; do
2078   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2079     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2080     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2081     break 2
2082   fi
2083 done
2084 done
2085
2086 fi
2087 fi
2088 CC=$ac_cv_prog_CC
2089 if test -n "$CC"; then
2090   echo "$as_me:$LINENO: result: $CC" >&5
2091 echo "${ECHO_T}$CC" >&6
2092 else
2093   echo "$as_me:$LINENO: result: no" >&5
2094 echo "${ECHO_T}no" >&6
2095 fi
2096
2097 fi
2098 if test -z "$ac_cv_prog_CC"; then
2099   ac_ct_CC=$CC
2100   # Extract the first word of "gcc", so it can be a program name with args.
2101 set dummy gcc; ac_word=$2
2102 echo "$as_me:$LINENO: checking for $ac_word" >&5
2103 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2104 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2105   echo $ECHO_N "(cached) $ECHO_C" >&6
2106 else
2107   if test -n "$ac_ct_CC"; then
2108   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2109 else
2110 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2111 for as_dir in $PATH
2112 do
2113   IFS=$as_save_IFS
2114   test -z "$as_dir" && as_dir=.
2115   for ac_exec_ext in '' $ac_executable_extensions; do
2116   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2117     ac_cv_prog_ac_ct_CC="gcc"
2118     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2119     break 2
2120   fi
2121 done
2122 done
2123
2124 fi
2125 fi
2126 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2127 if test -n "$ac_ct_CC"; then
2128   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2129 echo "${ECHO_T}$ac_ct_CC" >&6
2130 else
2131   echo "$as_me:$LINENO: result: no" >&5
2132 echo "${ECHO_T}no" >&6
2133 fi
2134
2135   CC=$ac_ct_CC
2136 else
2137   CC="$ac_cv_prog_CC"
2138 fi
2139
2140 if test -z "$CC"; then
2141   if test -n "$ac_tool_prefix"; then
2142   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2143 set dummy ${ac_tool_prefix}cc; ac_word=$2
2144 echo "$as_me:$LINENO: checking for $ac_word" >&5
2145 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2146 if test "${ac_cv_prog_CC+set}" = set; then
2147   echo $ECHO_N "(cached) $ECHO_C" >&6
2148 else
2149   if test -n "$CC"; then
2150   ac_cv_prog_CC="$CC" # Let the user override the test.
2151 else
2152 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2153 for as_dir in $PATH
2154 do
2155   IFS=$as_save_IFS
2156   test -z "$as_dir" && as_dir=.
2157   for ac_exec_ext in '' $ac_executable_extensions; do
2158   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2159     ac_cv_prog_CC="${ac_tool_prefix}cc"
2160     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2161     break 2
2162   fi
2163 done
2164 done
2165
2166 fi
2167 fi
2168 CC=$ac_cv_prog_CC
2169 if test -n "$CC"; then
2170   echo "$as_me:$LINENO: result: $CC" >&5
2171 echo "${ECHO_T}$CC" >&6
2172 else
2173   echo "$as_me:$LINENO: result: no" >&5
2174 echo "${ECHO_T}no" >&6
2175 fi
2176
2177 fi
2178 if test -z "$ac_cv_prog_CC"; then
2179   ac_ct_CC=$CC
2180   # Extract the first word of "cc", so it can be a program name with args.
2181 set dummy cc; ac_word=$2
2182 echo "$as_me:$LINENO: checking for $ac_word" >&5
2183 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2184 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2185   echo $ECHO_N "(cached) $ECHO_C" >&6
2186 else
2187   if test -n "$ac_ct_CC"; then
2188   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2189 else
2190 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2191 for as_dir in $PATH
2192 do
2193   IFS=$as_save_IFS
2194   test -z "$as_dir" && as_dir=.
2195   for ac_exec_ext in '' $ac_executable_extensions; do
2196   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2197     ac_cv_prog_ac_ct_CC="cc"
2198     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2199     break 2
2200   fi
2201 done
2202 done
2203
2204 fi
2205 fi
2206 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2207 if test -n "$ac_ct_CC"; then
2208   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2209 echo "${ECHO_T}$ac_ct_CC" >&6
2210 else
2211   echo "$as_me:$LINENO: result: no" >&5
2212 echo "${ECHO_T}no" >&6
2213 fi
2214
2215   CC=$ac_ct_CC
2216 else
2217   CC="$ac_cv_prog_CC"
2218 fi
2219
2220 fi
2221 if test -z "$CC"; then
2222   # Extract the first word of "cc", so it can be a program name with args.
2223 set dummy cc; ac_word=$2
2224 echo "$as_me:$LINENO: checking for $ac_word" >&5
2225 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2226 if test "${ac_cv_prog_CC+set}" = set; then
2227   echo $ECHO_N "(cached) $ECHO_C" >&6
2228 else
2229   if test -n "$CC"; then
2230   ac_cv_prog_CC="$CC" # Let the user override the test.
2231 else
2232   ac_prog_rejected=no
2233 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2234 for as_dir in $PATH
2235 do
2236   IFS=$as_save_IFS
2237   test -z "$as_dir" && as_dir=.
2238   for ac_exec_ext in '' $ac_executable_extensions; do
2239   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2240     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2241        ac_prog_rejected=yes
2242        continue
2243      fi
2244     ac_cv_prog_CC="cc"
2245     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2246     break 2
2247   fi
2248 done
2249 done
2250
2251 if test $ac_prog_rejected = yes; then
2252   # We found a bogon in the path, so make sure we never use it.
2253   set dummy $ac_cv_prog_CC
2254   shift
2255   if test $# != 0; then
2256     # We chose a different compiler from the bogus one.
2257     # However, it has the same basename, so the bogon will be chosen
2258     # first if we set CC to just the basename; use the full file name.
2259     shift
2260     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
2261   fi
2262 fi
2263 fi
2264 fi
2265 CC=$ac_cv_prog_CC
2266 if test -n "$CC"; then
2267   echo "$as_me:$LINENO: result: $CC" >&5
2268 echo "${ECHO_T}$CC" >&6
2269 else
2270   echo "$as_me:$LINENO: result: no" >&5
2271 echo "${ECHO_T}no" >&6
2272 fi
2273
2274 fi
2275 if test -z "$CC"; then
2276   if test -n "$ac_tool_prefix"; then
2277   for ac_prog in cl
2278   do
2279     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2280 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2281 echo "$as_me:$LINENO: checking for $ac_word" >&5
2282 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2283 if test "${ac_cv_prog_CC+set}" = set; then
2284   echo $ECHO_N "(cached) $ECHO_C" >&6
2285 else
2286   if test -n "$CC"; then
2287   ac_cv_prog_CC="$CC" # Let the user override the test.
2288 else
2289 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2290 for as_dir in $PATH
2291 do
2292   IFS=$as_save_IFS
2293   test -z "$as_dir" && as_dir=.
2294   for ac_exec_ext in '' $ac_executable_extensions; do
2295   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2296     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2297     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2298     break 2
2299   fi
2300 done
2301 done
2302
2303 fi
2304 fi
2305 CC=$ac_cv_prog_CC
2306 if test -n "$CC"; then
2307   echo "$as_me:$LINENO: result: $CC" >&5
2308 echo "${ECHO_T}$CC" >&6
2309 else
2310   echo "$as_me:$LINENO: result: no" >&5
2311 echo "${ECHO_T}no" >&6
2312 fi
2313
2314     test -n "$CC" && break
2315   done
2316 fi
2317 if test -z "$CC"; then
2318   ac_ct_CC=$CC
2319   for ac_prog in cl
2320 do
2321   # Extract the first word of "$ac_prog", so it can be a program name with args.
2322 set dummy $ac_prog; ac_word=$2
2323 echo "$as_me:$LINENO: checking for $ac_word" >&5
2324 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2325 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2326   echo $ECHO_N "(cached) $ECHO_C" >&6
2327 else
2328   if test -n "$ac_ct_CC"; then
2329   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2330 else
2331 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2332 for as_dir in $PATH
2333 do
2334   IFS=$as_save_IFS
2335   test -z "$as_dir" && as_dir=.
2336   for ac_exec_ext in '' $ac_executable_extensions; do
2337   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2338     ac_cv_prog_ac_ct_CC="$ac_prog"
2339     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2340     break 2
2341   fi
2342 done
2343 done
2344
2345 fi
2346 fi
2347 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2348 if test -n "$ac_ct_CC"; then
2349   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2350 echo "${ECHO_T}$ac_ct_CC" >&6
2351 else
2352   echo "$as_me:$LINENO: result: no" >&5
2353 echo "${ECHO_T}no" >&6
2354 fi
2355
2356   test -n "$ac_ct_CC" && break
2357 done
2358
2359   CC=$ac_ct_CC
2360 fi
2361
2362 fi
2363
2364
2365 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2366 See \`config.log' for more details." >&5
2367 echo "$as_me: error: no acceptable C compiler found in \$PATH
2368 See \`config.log' for more details." >&2;}
2369    { (exit 1); exit 1; }; }
2370
2371 # Provide some information about the compiler.
2372 echo "$as_me:$LINENO:" \
2373      "checking for C compiler version" >&5
2374 ac_compiler=`set X $ac_compile; echo $2`
2375 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2376   (eval $ac_compiler --version </dev/null >&5) 2>&5
2377   ac_status=$?
2378   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2379   (exit $ac_status); }
2380 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2381   (eval $ac_compiler -v </dev/null >&5) 2>&5
2382   ac_status=$?
2383   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2384   (exit $ac_status); }
2385 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2386   (eval $ac_compiler -V </dev/null >&5) 2>&5
2387   ac_status=$?
2388   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2389   (exit $ac_status); }
2390
2391 cat >conftest.$ac_ext <<_ACEOF
2392 /* confdefs.h.  */
2393 _ACEOF
2394 cat confdefs.h >>conftest.$ac_ext
2395 cat >>conftest.$ac_ext <<_ACEOF
2396 /* end confdefs.h.  */
2397
2398 int
2399 main ()
2400 {
2401
2402   ;
2403   return 0;
2404 }
2405 _ACEOF
2406 # FIXME: Cleanup?
2407 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
2408   (eval $ac_link) 2>&5
2409   ac_status=$?
2410   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2411   (exit $ac_status); }; then
2412   gcc_no_link=no
2413 else
2414   gcc_no_link=yes
2415 fi
2416
2417 if test x$gcc_no_link = xyes; then
2418   # Setting cross_compile will disable run tests; it will
2419   # also disable AC_CHECK_FILE but that's generally
2420   # correct if we can't link.
2421   cross_compiling=yes
2422   EXEEXT=
2423 else
2424   cat >conftest.$ac_ext <<_ACEOF
2425 /* confdefs.h.  */
2426 _ACEOF
2427 cat confdefs.h >>conftest.$ac_ext
2428 cat >>conftest.$ac_ext <<_ACEOF
2429 /* end confdefs.h.  */
2430
2431 int
2432 main ()
2433 {
2434
2435   ;
2436   return 0;
2437 }
2438 _ACEOF
2439 ac_clean_files_save=$ac_clean_files
2440 ac_clean_files="$ac_clean_files a.out a.exe b.out"
2441 # Try to create an executable without -o first, disregard a.out.
2442 # It will help us diagnose broken compilers, and finding out an intuition
2443 # of exeext.
2444 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
2445 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
2446 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
2447 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
2448   (eval $ac_link_default) 2>&5
2449   ac_status=$?
2450   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2451   (exit $ac_status); }; then
2452   # Find the output, starting from the most likely.  This scheme is
2453 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
2454 # resort.
2455
2456 # Be careful to initialize this variable, since it used to be cached.
2457 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
2458 ac_cv_exeext=
2459 # b.out is created by i960 compilers.
2460 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
2461 do
2462   test -f "$ac_file" || continue
2463   case $ac_file in
2464     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
2465         ;;
2466     conftest.$ac_ext )
2467         # This is the source file.
2468         ;;
2469     [ab].out )
2470         # We found the default executable, but exeext='' is most
2471         # certainly right.
2472         break;;
2473     *.* )
2474         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
2475         # FIXME: I believe we export ac_cv_exeext for Libtool,
2476         # but it would be cool to find out if it's true.  Does anybody
2477         # maintain Libtool? --akim.
2478         export ac_cv_exeext
2479         break;;
2480     * )
2481         break;;
2482   esac
2483 done
2484 else
2485   echo "$as_me: failed program was:" >&5
2486 sed 's/^/| /' conftest.$ac_ext >&5
2487
2488 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
2489 See \`config.log' for more details." >&5
2490 echo "$as_me: error: C compiler cannot create executables
2491 See \`config.log' for more details." >&2;}
2492    { (exit 77); exit 77; }; }
2493 fi
2494
2495 ac_exeext=$ac_cv_exeext
2496 echo "$as_me:$LINENO: result: $ac_file" >&5
2497 echo "${ECHO_T}$ac_file" >&6
2498
2499 # Check the compiler produces executables we can run.  If not, either
2500 # the compiler is broken, or we cross compile.
2501 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
2502 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
2503 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
2504 # If not cross compiling, check that we can run a simple program.
2505 if test "$cross_compiling" != yes; then
2506   if { ac_try='./$ac_file'
2507   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2508   (eval $ac_try) 2>&5
2509   ac_status=$?
2510   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2511   (exit $ac_status); }; }; then
2512     cross_compiling=no
2513   else
2514     if test "$cross_compiling" = maybe; then
2515         cross_compiling=yes
2516     else
2517         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
2518 If you meant to cross compile, use \`--host'.
2519 See \`config.log' for more details." >&5
2520 echo "$as_me: error: cannot run C compiled programs.
2521 If you meant to cross compile, use \`--host'.
2522 See \`config.log' for more details." >&2;}
2523    { (exit 1); exit 1; }; }
2524     fi
2525   fi
2526 fi
2527 echo "$as_me:$LINENO: result: yes" >&5
2528 echo "${ECHO_T}yes" >&6
2529
2530 rm -f a.out a.exe conftest$ac_cv_exeext b.out
2531 ac_clean_files=$ac_clean_files_save
2532 # Check the compiler produces executables we can run.  If not, either
2533 # the compiler is broken, or we cross compile.
2534 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
2535 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
2536 echo "$as_me:$LINENO: result: $cross_compiling" >&5
2537 echo "${ECHO_T}$cross_compiling" >&6
2538
2539 echo "$as_me:$LINENO: checking for suffix of executables" >&5
2540 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
2541 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
2542   (eval $ac_link) 2>&5
2543   ac_status=$?
2544   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2545   (exit $ac_status); }; then
2546   # If both `conftest.exe' and `conftest' are `present' (well, observable)
2547 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
2548 # work properly (i.e., refer to `conftest.exe'), while it won't with
2549 # `rm'.
2550 for ac_file in conftest.exe conftest conftest.*; do
2551   test -f "$ac_file" || continue
2552   case $ac_file in
2553     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
2554     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
2555           export ac_cv_exeext
2556           break;;
2557     * ) break;;
2558   esac
2559 done
2560 else
2561   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
2562 See \`config.log' for more details." >&5
2563 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
2564 See \`config.log' for more details." >&2;}
2565    { (exit 1); exit 1; }; }
2566 fi
2567
2568 rm -f conftest$ac_cv_exeext
2569 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
2570 echo "${ECHO_T}$ac_cv_exeext" >&6
2571
2572 rm -f conftest.$ac_ext
2573 EXEEXT=$ac_cv_exeext
2574 ac_exeext=$EXEEXT
2575 fi
2576 echo "$as_me:$LINENO: checking for suffix of object files" >&5
2577 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
2578 if test "${ac_cv_objext+set}" = set; then
2579   echo $ECHO_N "(cached) $ECHO_C" >&6
2580 else
2581   cat >conftest.$ac_ext <<_ACEOF
2582 /* confdefs.h.  */
2583 _ACEOF
2584 cat confdefs.h >>conftest.$ac_ext
2585 cat >>conftest.$ac_ext <<_ACEOF
2586 /* end confdefs.h.  */
2587
2588 int
2589 main ()
2590 {
2591
2592   ;
2593   return 0;
2594 }
2595 _ACEOF
2596 rm -f conftest.o conftest.obj
2597 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2598   (eval $ac_compile) 2>&5
2599   ac_status=$?
2600   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2601   (exit $ac_status); }; then
2602   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
2603   case $ac_file in
2604     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
2605     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
2606        break;;
2607   esac
2608 done
2609 else
2610   echo "$as_me: failed program was:" >&5
2611 sed 's/^/| /' conftest.$ac_ext >&5
2612
2613 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
2614 See \`config.log' for more details." >&5
2615 echo "$as_me: error: cannot compute suffix of object files: cannot compile
2616 See \`config.log' for more details." >&2;}
2617    { (exit 1); exit 1; }; }
2618 fi
2619
2620 rm -f conftest.$ac_cv_objext conftest.$ac_ext
2621 fi
2622 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
2623 echo "${ECHO_T}$ac_cv_objext" >&6
2624 OBJEXT=$ac_cv_objext
2625 ac_objext=$OBJEXT
2626 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2627 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2628 if test "${ac_cv_c_compiler_gnu+set}" = set; then
2629   echo $ECHO_N "(cached) $ECHO_C" >&6
2630 else
2631   cat >conftest.$ac_ext <<_ACEOF
2632 /* confdefs.h.  */
2633 _ACEOF
2634 cat confdefs.h >>conftest.$ac_ext
2635 cat >>conftest.$ac_ext <<_ACEOF
2636 /* end confdefs.h.  */
2637
2638 int
2639 main ()
2640 {
2641 #ifndef __GNUC__
2642        choke me
2643 #endif
2644
2645   ;
2646   return 0;
2647 }
2648 _ACEOF
2649 rm -f conftest.$ac_objext
2650 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2651   (eval $ac_compile) 2>conftest.er1
2652   ac_status=$?
2653   grep -v '^ *+' conftest.er1 >conftest.err
2654   rm -f conftest.er1
2655   cat conftest.err >&5
2656   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2657   (exit $ac_status); } &&
2658          { ac_try='test -z "$ac_c_werror_flag"
2659                          || test ! -s conftest.err'
2660   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2661   (eval $ac_try) 2>&5
2662   ac_status=$?
2663   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2664   (exit $ac_status); }; } &&
2665          { ac_try='test -s conftest.$ac_objext'
2666   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2667   (eval $ac_try) 2>&5
2668   ac_status=$?
2669   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2670   (exit $ac_status); }; }; then
2671   ac_compiler_gnu=yes
2672 else
2673   echo "$as_me: failed program was:" >&5
2674 sed 's/^/| /' conftest.$ac_ext >&5
2675
2676 ac_compiler_gnu=no
2677 fi
2678 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2679 ac_cv_c_compiler_gnu=$ac_compiler_gnu
2680
2681 fi
2682 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2683 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2684 GCC=`test $ac_compiler_gnu = yes && echo yes`
2685 ac_test_CFLAGS=${CFLAGS+set}
2686 ac_save_CFLAGS=$CFLAGS
2687 CFLAGS="-g"
2688 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2689 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2690 if test "${ac_cv_prog_cc_g+set}" = set; then
2691   echo $ECHO_N "(cached) $ECHO_C" >&6
2692 else
2693   cat >conftest.$ac_ext <<_ACEOF
2694 /* confdefs.h.  */
2695 _ACEOF
2696 cat confdefs.h >>conftest.$ac_ext
2697 cat >>conftest.$ac_ext <<_ACEOF
2698 /* end confdefs.h.  */
2699
2700 int
2701 main ()
2702 {
2703
2704   ;
2705   return 0;
2706 }
2707 _ACEOF
2708 rm -f conftest.$ac_objext
2709 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2710   (eval $ac_compile) 2>conftest.er1
2711   ac_status=$?
2712   grep -v '^ *+' conftest.er1 >conftest.err
2713   rm -f conftest.er1
2714   cat conftest.err >&5
2715   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2716   (exit $ac_status); } &&
2717          { ac_try='test -z "$ac_c_werror_flag"
2718                          || test ! -s conftest.err'
2719   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2720   (eval $ac_try) 2>&5
2721   ac_status=$?
2722   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2723   (exit $ac_status); }; } &&
2724          { ac_try='test -s conftest.$ac_objext'
2725   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2726   (eval $ac_try) 2>&5
2727   ac_status=$?
2728   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2729   (exit $ac_status); }; }; then
2730   ac_cv_prog_cc_g=yes
2731 else
2732   echo "$as_me: failed program was:" >&5
2733 sed 's/^/| /' conftest.$ac_ext >&5
2734
2735 ac_cv_prog_cc_g=no
2736 fi
2737 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2738 fi
2739 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2740 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2741 if test "$ac_test_CFLAGS" = set; then
2742   CFLAGS=$ac_save_CFLAGS
2743 elif test $ac_cv_prog_cc_g = yes; then
2744   if test "$GCC" = yes; then
2745     CFLAGS="-g -O2"
2746   else
2747     CFLAGS="-g"
2748   fi
2749 else
2750   if test "$GCC" = yes; then
2751     CFLAGS="-O2"
2752   else
2753     CFLAGS=
2754   fi
2755 fi
2756 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2757 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2758 if test "${ac_cv_prog_cc_stdc+set}" = set; then
2759   echo $ECHO_N "(cached) $ECHO_C" >&6
2760 else
2761   ac_cv_prog_cc_stdc=no
2762 ac_save_CC=$CC
2763 cat >conftest.$ac_ext <<_ACEOF
2764 /* confdefs.h.  */
2765 _ACEOF
2766 cat confdefs.h >>conftest.$ac_ext
2767 cat >>conftest.$ac_ext <<_ACEOF
2768 /* end confdefs.h.  */
2769 #include <stdarg.h>
2770 #include <stdio.h>
2771 #include <sys/types.h>
2772 #include <sys/stat.h>
2773 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2774 struct buf { int x; };
2775 FILE * (*rcsopen) (struct buf *, struct stat *, int);
2776 static char *e (p, i)
2777      char **p;
2778      int i;
2779 {
2780   return p[i];
2781 }
2782 static char *f (char * (*g) (char **, int), char **p, ...)
2783 {
2784   char *s;
2785   va_list v;
2786   va_start (v,p);
2787   s = g (p, va_arg (v,int));
2788   va_end (v);
2789   return s;
2790 }
2791
2792 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2793    function prototypes and stuff, but not '\xHH' hex character constants.
2794    These don't provoke an error unfortunately, instead are silently treated
2795    as 'x'.  The following induces an error, until -std1 is added to get
2796    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2797    array size at least.  It's necessary to write '\x00'==0 to get something
2798    that's true only with -std1.  */
2799 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2800
2801 int test (int i, double x);
2802 struct s1 {int (*f) (int a);};
2803 struct s2 {int (*f) (double a);};
2804 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2805 int argc;
2806 char **argv;
2807 int
2808 main ()
2809 {
2810 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2811   ;
2812   return 0;
2813 }
2814 _ACEOF
2815 # Don't try gcc -ansi; that turns off useful extensions and
2816 # breaks some systems' header files.
2817 # AIX                   -qlanglvl=ansi
2818 # Ultrix and OSF/1      -std1
2819 # HP-UX 10.20 and later -Ae
2820 # HP-UX older versions  -Aa -D_HPUX_SOURCE
2821 # SVR4                  -Xc -D__EXTENSIONS__
2822 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2823 do
2824   CC="$ac_save_CC $ac_arg"
2825   rm -f conftest.$ac_objext
2826 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2827   (eval $ac_compile) 2>conftest.er1
2828   ac_status=$?
2829   grep -v '^ *+' conftest.er1 >conftest.err
2830   rm -f conftest.er1
2831   cat conftest.err >&5
2832   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2833   (exit $ac_status); } &&
2834          { ac_try='test -z "$ac_c_werror_flag"
2835                          || test ! -s conftest.err'
2836   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2837   (eval $ac_try) 2>&5
2838   ac_status=$?
2839   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2840   (exit $ac_status); }; } &&
2841          { ac_try='test -s conftest.$ac_objext'
2842   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2843   (eval $ac_try) 2>&5
2844   ac_status=$?
2845   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2846   (exit $ac_status); }; }; then
2847   ac_cv_prog_cc_stdc=$ac_arg
2848 break
2849 else
2850   echo "$as_me: failed program was:" >&5
2851 sed 's/^/| /' conftest.$ac_ext >&5
2852
2853 fi
2854 rm -f conftest.err conftest.$ac_objext
2855 done
2856 rm -f conftest.$ac_ext conftest.$ac_objext
2857 CC=$ac_save_CC
2858
2859 fi
2860
2861 case "x$ac_cv_prog_cc_stdc" in
2862   x|xno)
2863     echo "$as_me:$LINENO: result: none needed" >&5
2864 echo "${ECHO_T}none needed" >&6 ;;
2865   *)
2866     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2867 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2868     CC="$CC $ac_cv_prog_cc_stdc" ;;
2869 esac
2870
2871 # Some people use a C++ compiler to compile C.  Since we use `exit',
2872 # in C++ we need to declare it.  In case someone uses the same compiler
2873 # for both compiling C and C++ we need to have the C++ compiler decide
2874 # the declaration of exit, since it's the most demanding environment.
2875 cat >conftest.$ac_ext <<_ACEOF
2876 #ifndef __cplusplus
2877   choke me
2878 #endif
2879 _ACEOF
2880 rm -f conftest.$ac_objext
2881 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2882   (eval $ac_compile) 2>conftest.er1
2883   ac_status=$?
2884   grep -v '^ *+' conftest.er1 >conftest.err
2885   rm -f conftest.er1
2886   cat conftest.err >&5
2887   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2888   (exit $ac_status); } &&
2889          { ac_try='test -z "$ac_c_werror_flag"
2890                          || test ! -s conftest.err'
2891   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2892   (eval $ac_try) 2>&5
2893   ac_status=$?
2894   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2895   (exit $ac_status); }; } &&
2896          { ac_try='test -s conftest.$ac_objext'
2897   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2898   (eval $ac_try) 2>&5
2899   ac_status=$?
2900   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2901   (exit $ac_status); }; }; then
2902   for ac_declaration in \
2903    '' \
2904    'extern "C" void std::exit (int) throw (); using std::exit;' \
2905    'extern "C" void std::exit (int); using std::exit;' \
2906    'extern "C" void exit (int) throw ();' \
2907    'extern "C" void exit (int);' \
2908    'void exit (int);'
2909 do
2910   cat >conftest.$ac_ext <<_ACEOF
2911 /* confdefs.h.  */
2912 _ACEOF
2913 cat confdefs.h >>conftest.$ac_ext
2914 cat >>conftest.$ac_ext <<_ACEOF
2915 /* end confdefs.h.  */
2916 $ac_declaration
2917 #include <stdlib.h>
2918 int
2919 main ()
2920 {
2921 exit (42);
2922   ;
2923   return 0;
2924 }
2925 _ACEOF
2926 rm -f conftest.$ac_objext
2927 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2928   (eval $ac_compile) 2>conftest.er1
2929   ac_status=$?
2930   grep -v '^ *+' conftest.er1 >conftest.err
2931   rm -f conftest.er1
2932   cat conftest.err >&5
2933   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2934   (exit $ac_status); } &&
2935          { ac_try='test -z "$ac_c_werror_flag"
2936                          || test ! -s conftest.err'
2937   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2938   (eval $ac_try) 2>&5
2939   ac_status=$?
2940   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2941   (exit $ac_status); }; } &&
2942          { ac_try='test -s conftest.$ac_objext'
2943   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2944   (eval $ac_try) 2>&5
2945   ac_status=$?
2946   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2947   (exit $ac_status); }; }; then
2948   :
2949 else
2950   echo "$as_me: failed program was:" >&5
2951 sed 's/^/| /' conftest.$ac_ext >&5
2952
2953 continue
2954 fi
2955 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2956   cat >conftest.$ac_ext <<_ACEOF
2957 /* confdefs.h.  */
2958 _ACEOF
2959 cat confdefs.h >>conftest.$ac_ext
2960 cat >>conftest.$ac_ext <<_ACEOF
2961 /* end confdefs.h.  */
2962 $ac_declaration
2963 int
2964 main ()
2965 {
2966 exit (42);
2967   ;
2968   return 0;
2969 }
2970 _ACEOF
2971 rm -f conftest.$ac_objext
2972 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2973   (eval $ac_compile) 2>conftest.er1
2974   ac_status=$?
2975   grep -v '^ *+' conftest.er1 >conftest.err
2976   rm -f conftest.er1
2977   cat conftest.err >&5
2978   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2979   (exit $ac_status); } &&
2980          { ac_try='test -z "$ac_c_werror_flag"
2981                          || test ! -s conftest.err'
2982   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2983   (eval $ac_try) 2>&5
2984   ac_status=$?
2985   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2986   (exit $ac_status); }; } &&
2987          { ac_try='test -s conftest.$ac_objext'
2988   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2989   (eval $ac_try) 2>&5
2990   ac_status=$?
2991   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2992   (exit $ac_status); }; }; then
2993   break
2994 else
2995   echo "$as_me: failed program was:" >&5
2996 sed 's/^/| /' conftest.$ac_ext >&5
2997
2998 fi
2999 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3000 done
3001 rm -f conftest*
3002 if test -n "$ac_declaration"; then
3003   echo '#ifdef __cplusplus' >>confdefs.h
3004   echo $ac_declaration      >>confdefs.h
3005   echo '#endif'             >>confdefs.h
3006 fi
3007
3008 else
3009   echo "$as_me: failed program was:" >&5
3010 sed 's/^/| /' conftest.$ac_ext >&5
3011
3012 fi
3013 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3014 ac_ext=c
3015 ac_cpp='$CPP $CPPFLAGS'
3016 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3017 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3018 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3019 DEPDIR="${am__leading_dot}deps"
3020
3021           ac_config_commands="$ac_config_commands depfiles"
3022
3023
3024 am_make=${MAKE-make}
3025 cat > confinc << 'END'
3026 am__doit:
3027         @echo done
3028 .PHONY: am__doit
3029 END
3030 # If we don't find an include directive, just comment out the code.
3031 echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
3032 echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6
3033 am__include="#"
3034 am__quote=
3035 _am_result=none
3036 # First try GNU make style include.
3037 echo "include confinc" > confmf
3038 # We grep out `Entering directory' and `Leaving directory'
3039 # messages which can occur if `w' ends up in MAKEFLAGS.
3040 # In particular we don't look at `^make:' because GNU make might
3041 # be invoked under some other name (usually "gmake"), in which
3042 # case it prints its new name instead of `make'.
3043 if test "`$am_make -s -f confmf 2> /dev/null | grep -v 'ing directory'`" = "done"; then
3044    am__include=include
3045    am__quote=
3046    _am_result=GNU
3047 fi
3048 # Now try BSD make style include.
3049 if test "$am__include" = "#"; then
3050    echo '.include "confinc"' > confmf
3051    if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then
3052       am__include=.include
3053       am__quote="\""
3054       _am_result=BSD
3055    fi
3056 fi
3057
3058
3059 echo "$as_me:$LINENO: result: $_am_result" >&5
3060 echo "${ECHO_T}$_am_result" >&6
3061 rm -f confinc confmf
3062
3063 # Check whether --enable-dependency-tracking or --disable-dependency-tracking was given.
3064 if test "${enable_dependency_tracking+set}" = set; then
3065   enableval="$enable_dependency_tracking"
3066
3067 fi;
3068 if test "x$enable_dependency_tracking" != xno; then
3069   am_depcomp="$ac_aux_dir/depcomp"
3070   AMDEPBACKSLASH='\'
3071 fi
3072
3073
3074 if test "x$enable_dependency_tracking" != xno; then
3075   AMDEP_TRUE=
3076   AMDEP_FALSE='#'
3077 else
3078   AMDEP_TRUE='#'
3079   AMDEP_FALSE=
3080 fi
3081
3082
3083
3084
3085 depcc="$CC"   am_compiler_list=
3086
3087 echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
3088 echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6
3089 if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then
3090   echo $ECHO_N "(cached) $ECHO_C" >&6
3091 else
3092   if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
3093   # We make a subdir and do the tests there.  Otherwise we can end up
3094   # making bogus files that we don't know about and never remove.  For
3095   # instance it was reported that on HP-UX the gcc test will end up
3096   # making a dummy file named `D' -- because `-MD' means `put the output
3097   # in D'.
3098   mkdir conftest.dir
3099   # Copy depcomp to subdir because otherwise we won't find it if we're
3100   # using a relative directory.
3101   cp "$am_depcomp" conftest.dir
3102   cd conftest.dir
3103   # We will build objects and dependencies in a subdirectory because
3104   # it helps to detect inapplicable dependency modes.  For instance
3105   # both Tru64's cc and ICC support -MD to output dependencies as a
3106   # side effect of compilation, but ICC will put the dependencies in
3107   # the current directory while Tru64 will put them in the object
3108   # directory.
3109   mkdir sub
3110
3111   am_cv_CC_dependencies_compiler_type=none
3112   if test "$am_compiler_list" = ""; then
3113      am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
3114   fi
3115   for depmode in $am_compiler_list; do
3116     # Setup a source with many dependencies, because some compilers
3117     # like to wrap large dependency lists on column 80 (with \), and
3118     # we should not choose a depcomp mode which is confused by this.
3119     #
3120     # We need to recreate these files for each test, as the compiler may
3121     # overwrite some of them when testing with obscure command lines.
3122     # This happens at least with the AIX C compiler.
3123     : > sub/conftest.c
3124     for i in 1 2 3 4 5 6; do
3125       echo '#include "conftst'$i'.h"' >> sub/conftest.c
3126       # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
3127       # Solaris 8's {/usr,}/bin/sh.
3128       touch sub/conftst$i.h
3129     done
3130     echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
3131
3132     case $depmode in
3133     nosideeffect)
3134       # after this tag, mechanisms are not by side-effect, so they'll
3135       # only be used when explicitly requested
3136       if test "x$enable_dependency_tracking" = xyes; then
3137         continue
3138       else
3139         break
3140       fi
3141       ;;
3142     none) break ;;
3143     esac
3144     # We check with `-c' and `-o' for the sake of the "dashmstdout"
3145     # mode.  It turns out that the SunPro C++ compiler does not properly
3146     # handle `-M -o', and we need to detect this.
3147     if depmode=$depmode \
3148        source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \
3149        depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
3150        $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \
3151          >/dev/null 2>conftest.err &&
3152        grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
3153        grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&
3154        ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
3155       # icc doesn't choke on unknown options, it will just issue warnings
3156       # or remarks (even with -Werror).  So we grep stderr for any message
3157       # that says an option was ignored or not supported.
3158       # When given -MP, icc 7.0 and 7.1 complain thusly:
3159       #   icc: Command line warning: ignoring option '-M'; no argument required
3160       # The diagnosis changed in icc 8.0:
3161       #   icc: Command line remark: option '-MP' not supported
3162       if (grep 'ignoring option' conftest.err ||
3163           grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
3164         am_cv_CC_dependencies_compiler_type=$depmode
3165         break
3166       fi
3167     fi
3168   done
3169
3170   cd ..
3171   rm -rf conftest.dir
3172 else
3173   am_cv_CC_dependencies_compiler_type=none
3174 fi
3175
3176 fi
3177 echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5
3178 echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6
3179 CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
3180
3181
3182
3183 if
3184   test "x$enable_dependency_tracking" != xno \
3185   && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
3186   am__fastdepCC_TRUE=
3187   am__fastdepCC_FALSE='#'
3188 else
3189   am__fastdepCC_TRUE='#'
3190   am__fastdepCC_FALSE=
3191 fi
3192
3193
3194
3195
3196 # Add -Wall -fno-repack-arrays -fno-underscoring if we are using GCC.
3197 if test "x$GCC" = "xyes"; then
3198   AM_FCFLAGS="-I . -Wall -fno-repack-arrays -fno-underscoring"
3199   ## We like to use C99 routines when available.  This makes sure that
3200   ## __STDC_VERSION__ is set such that libc includes make them available.
3201   AM_CFLAGS="-std=gnu99 -Wall -Wstrict-prototypes -Wmissing-prototypes -Wold-style-definition -Wextra -Wwrite-strings"
3202   ## Compile the following tests with the same system header contents
3203   ## that we'll encounter when compiling our own source files.
3204   CFLAGS="-std=gnu99 $CFLAGS"
3205 fi
3206
3207
3208
3209 # Find other programs we need.
3210 if test -n "$ac_tool_prefix"; then
3211   # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
3212 set dummy ${ac_tool_prefix}as; ac_word=$2
3213 echo "$as_me:$LINENO: checking for $ac_word" >&5
3214 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3215 if test "${ac_cv_prog_AS+set}" = set; then
3216   echo $ECHO_N "(cached) $ECHO_C" >&6
3217 else
3218   if test -n "$AS"; then
3219   ac_cv_prog_AS="$AS" # Let the user override the test.
3220 else
3221 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3222 for as_dir in $PATH
3223 do
3224   IFS=$as_save_IFS
3225   test -z "$as_dir" && as_dir=.
3226   for ac_exec_ext in '' $ac_executable_extensions; do
3227   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3228     ac_cv_prog_AS="${ac_tool_prefix}as"
3229     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3230     break 2
3231   fi
3232 done
3233 done
3234
3235 fi
3236 fi
3237 AS=$ac_cv_prog_AS
3238 if test -n "$AS"; then
3239   echo "$as_me:$LINENO: result: $AS" >&5
3240 echo "${ECHO_T}$AS" >&6
3241 else
3242   echo "$as_me:$LINENO: result: no" >&5
3243 echo "${ECHO_T}no" >&6
3244 fi
3245
3246 fi
3247 if test -z "$ac_cv_prog_AS"; then
3248   ac_ct_AS=$AS
3249   # Extract the first word of "as", so it can be a program name with args.
3250 set dummy as; ac_word=$2
3251 echo "$as_me:$LINENO: checking for $ac_word" >&5
3252 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3253 if test "${ac_cv_prog_ac_ct_AS+set}" = set; then
3254   echo $ECHO_N "(cached) $ECHO_C" >&6
3255 else
3256   if test -n "$ac_ct_AS"; then
3257   ac_cv_prog_ac_ct_AS="$ac_ct_AS" # Let the user override the test.
3258 else
3259 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3260 for as_dir in $PATH
3261 do
3262   IFS=$as_save_IFS
3263   test -z "$as_dir" && as_dir=.
3264   for ac_exec_ext in '' $ac_executable_extensions; do
3265   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3266     ac_cv_prog_ac_ct_AS="as"
3267     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3268     break 2
3269   fi
3270 done
3271 done
3272
3273 fi
3274 fi
3275 ac_ct_AS=$ac_cv_prog_ac_ct_AS
3276 if test -n "$ac_ct_AS"; then
3277   echo "$as_me:$LINENO: result: $ac_ct_AS" >&5
3278 echo "${ECHO_T}$ac_ct_AS" >&6
3279 else
3280   echo "$as_me:$LINENO: result: no" >&5
3281 echo "${ECHO_T}no" >&6
3282 fi
3283
3284   AS=$ac_ct_AS
3285 else
3286   AS="$ac_cv_prog_AS"
3287 fi
3288
3289 if test -n "$ac_tool_prefix"; then
3290   # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
3291 set dummy ${ac_tool_prefix}ar; ac_word=$2
3292 echo "$as_me:$LINENO: checking for $ac_word" >&5
3293 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3294 if test "${ac_cv_prog_AR+set}" = set; then
3295   echo $ECHO_N "(cached) $ECHO_C" >&6
3296 else
3297   if test -n "$AR"; then
3298   ac_cv_prog_AR="$AR" # Let the user override the test.
3299 else
3300 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3301 for as_dir in $PATH
3302 do
3303   IFS=$as_save_IFS
3304   test -z "$as_dir" && as_dir=.
3305   for ac_exec_ext in '' $ac_executable_extensions; do
3306   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3307     ac_cv_prog_AR="${ac_tool_prefix}ar"
3308     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3309     break 2
3310   fi
3311 done
3312 done
3313
3314 fi
3315 fi
3316 AR=$ac_cv_prog_AR
3317 if test -n "$AR"; then
3318   echo "$as_me:$LINENO: result: $AR" >&5
3319 echo "${ECHO_T}$AR" >&6
3320 else
3321   echo "$as_me:$LINENO: result: no" >&5
3322 echo "${ECHO_T}no" >&6
3323 fi
3324
3325 fi
3326 if test -z "$ac_cv_prog_AR"; then
3327   ac_ct_AR=$AR
3328   # Extract the first word of "ar", so it can be a program name with args.
3329 set dummy ar; ac_word=$2
3330 echo "$as_me:$LINENO: checking for $ac_word" >&5
3331 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3332 if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
3333   echo $ECHO_N "(cached) $ECHO_C" >&6
3334 else
3335   if test -n "$ac_ct_AR"; then
3336   ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
3337 else
3338 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3339 for as_dir in $PATH
3340 do
3341   IFS=$as_save_IFS
3342   test -z "$as_dir" && as_dir=.
3343   for ac_exec_ext in '' $ac_executable_extensions; do
3344   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3345     ac_cv_prog_ac_ct_AR="ar"
3346     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3347     break 2
3348   fi
3349 done
3350 done
3351
3352 fi
3353 fi
3354 ac_ct_AR=$ac_cv_prog_ac_ct_AR
3355 if test -n "$ac_ct_AR"; then
3356   echo "$as_me:$LINENO: result: $ac_ct_AR" >&5
3357 echo "${ECHO_T}$ac_ct_AR" >&6
3358 else
3359   echo "$as_me:$LINENO: result: no" >&5
3360 echo "${ECHO_T}no" >&6
3361 fi
3362
3363   AR=$ac_ct_AR
3364 else
3365   AR="$ac_cv_prog_AR"
3366 fi
3367
3368 if test -n "$ac_tool_prefix"; then
3369   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3370 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3371 echo "$as_me:$LINENO: checking for $ac_word" >&5
3372 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3373 if test "${ac_cv_prog_RANLIB+set}" = set; then
3374   echo $ECHO_N "(cached) $ECHO_C" >&6
3375 else
3376   if test -n "$RANLIB"; then
3377   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3378 else
3379 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3380 for as_dir in $PATH
3381 do
3382   IFS=$as_save_IFS
3383   test -z "$as_dir" && as_dir=.
3384   for ac_exec_ext in '' $ac_executable_extensions; do
3385   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3386     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3387     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3388     break 2
3389   fi
3390 done
3391 done
3392
3393 fi
3394 fi
3395 RANLIB=$ac_cv_prog_RANLIB
3396 if test -n "$RANLIB"; then
3397   echo "$as_me:$LINENO: result: $RANLIB" >&5
3398 echo "${ECHO_T}$RANLIB" >&6
3399 else
3400   echo "$as_me:$LINENO: result: no" >&5
3401 echo "${ECHO_T}no" >&6
3402 fi
3403
3404 fi
3405 if test -z "$ac_cv_prog_RANLIB"; then
3406   ac_ct_RANLIB=$RANLIB
3407   # Extract the first word of "ranlib", so it can be a program name with args.
3408 set dummy ranlib; ac_word=$2
3409 echo "$as_me:$LINENO: checking for $ac_word" >&5
3410 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3411 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3412   echo $ECHO_N "(cached) $ECHO_C" >&6
3413 else
3414   if test -n "$ac_ct_RANLIB"; then
3415   ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3416 else
3417 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3418 for as_dir in $PATH
3419 do
3420   IFS=$as_save_IFS
3421   test -z "$as_dir" && as_dir=.
3422   for ac_exec_ext in '' $ac_executable_extensions; do
3423   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3424     ac_cv_prog_ac_ct_RANLIB="ranlib"
3425     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3426     break 2
3427   fi
3428 done
3429 done
3430
3431   test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB="ranlib-not-found-in-path-error"
3432 fi
3433 fi
3434 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3435 if test -n "$ac_ct_RANLIB"; then
3436   echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3437 echo "${ECHO_T}$ac_ct_RANLIB" >&6
3438 else
3439   echo "$as_me:$LINENO: result: no" >&5
3440 echo "${ECHO_T}no" >&6
3441 fi
3442
3443   RANLIB=$ac_ct_RANLIB
3444 else
3445   RANLIB="$ac_cv_prog_RANLIB"
3446 fi
3447
3448 echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3449 echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3450 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3451 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3452   echo $ECHO_N "(cached) $ECHO_C" >&6
3453 else
3454   cat >conftest.make <<\_ACEOF
3455 all:
3456         @echo 'ac_maketemp="$(MAKE)"'
3457 _ACEOF
3458 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3459 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3460 if test -n "$ac_maketemp"; then
3461   eval ac_cv_prog_make_${ac_make}_set=yes
3462 else
3463   eval ac_cv_prog_make_${ac_make}_set=no
3464 fi
3465 rm -f conftest.make
3466 fi
3467 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3468   echo "$as_me:$LINENO: result: yes" >&5
3469 echo "${ECHO_T}yes" >&6
3470   SET_MAKE=
3471 else
3472   echo "$as_me:$LINENO: result: no" >&5
3473 echo "${ECHO_T}no" >&6
3474   SET_MAKE="MAKE=${MAKE-make}"
3475 fi
3476
3477 # Find a good install program.  We prefer a C program (faster),
3478 # so one script is as good as another.  But avoid the broken or
3479 # incompatible versions:
3480 # SysV /etc/install, /usr/sbin/install
3481 # SunOS /usr/etc/install
3482 # IRIX /sbin/install
3483 # AIX /bin/install
3484 # AmigaOS /C/install, which installs bootblocks on floppy discs
3485 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3486 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3487 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3488 # OS/2's system install, which has a completely different semantic
3489 # ./install, which can be erroneously created by make from ./install.sh.
3490 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3491 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3492 if test -z "$INSTALL"; then
3493 if test "${ac_cv_path_install+set}" = set; then
3494   echo $ECHO_N "(cached) $ECHO_C" >&6
3495 else
3496   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3497 for as_dir in $PATH
3498 do
3499   IFS=$as_save_IFS
3500   test -z "$as_dir" && as_dir=.
3501   # Account for people who put trailing slashes in PATH elements.
3502 case $as_dir/ in
3503   ./ | .// | /cC/* | \
3504   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3505   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3506   /usr/ucb/* ) ;;
3507   *)
3508     # OSF1 and SCO ODT 3.0 have their own names for install.
3509     # Don't use installbsd from OSF since it installs stuff as root
3510     # by default.
3511     for ac_prog in ginstall scoinst install; do
3512       for ac_exec_ext in '' $ac_executable_extensions; do
3513         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3514           if test $ac_prog = install &&
3515             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3516             # AIX install.  It has an incompatible calling convention.
3517             :
3518           elif test $ac_prog = install &&
3519             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3520             # program-specific install script used by HP pwplus--don't use.
3521             :
3522           else
3523             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3524             break 3
3525           fi
3526         fi
3527       done
3528     done
3529     ;;
3530 esac
3531 done
3532
3533
3534 fi
3535   if test "${ac_cv_path_install+set}" = set; then
3536     INSTALL=$ac_cv_path_install
3537   else
3538     # As a last resort, use the slow shell script.  We don't cache a
3539     # path for INSTALL within a source directory, because that will
3540     # break other packages using the cache if that directory is
3541     # removed, or if the path is relative.
3542     INSTALL=$ac_install_sh
3543   fi
3544 fi
3545 echo "$as_me:$LINENO: result: $INSTALL" >&5
3546 echo "${ECHO_T}$INSTALL" >&6
3547
3548 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3549 # It thinks the first close brace ends the variable substitution.
3550 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3551
3552 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3553
3554 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3555
3556
3557 # Configure libtool
3558 #AC_MSG_NOTICE([====== Starting libtool configuration])
3559
3560 # Check whether --enable-shared or --disable-shared was given.
3561 if test "${enable_shared+set}" = set; then
3562   enableval="$enable_shared"
3563   p=${PACKAGE-default}
3564 case $enableval in
3565 yes) enable_shared=yes ;;
3566 no) enable_shared=no ;;
3567 *)
3568   enable_shared=no
3569   # Look at the argument we got.  We use all the common list separators.
3570   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3571   for pkg in $enableval; do
3572     if test "X$pkg" = "X$p"; then
3573       enable_shared=yes
3574     fi
3575   done
3576   IFS="$ac_save_ifs"
3577   ;;
3578 esac
3579 else
3580   enable_shared=yes
3581 fi;
3582 # Check whether --enable-static or --disable-static was given.
3583 if test "${enable_static+set}" = set; then
3584   enableval="$enable_static"
3585   p=${PACKAGE-default}
3586 case $enableval in
3587 yes) enable_static=yes ;;
3588 no) enable_static=no ;;
3589 *)
3590   enable_static=no
3591   # Look at the argument we got.  We use all the common list separators.
3592   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3593   for pkg in $enableval; do
3594     if test "X$pkg" = "X$p"; then
3595       enable_static=yes
3596     fi
3597   done
3598   IFS="$ac_save_ifs"
3599   ;;
3600 esac
3601 else
3602   enable_static=yes
3603 fi;
3604 # Check whether --enable-fast-install or --disable-fast-install was given.
3605 if test "${enable_fast_install+set}" = set; then
3606   enableval="$enable_fast_install"
3607   p=${PACKAGE-default}
3608 case $enableval in
3609 yes) enable_fast_install=yes ;;
3610 no) enable_fast_install=no ;;
3611 *)
3612   enable_fast_install=no
3613   # Look at the argument we got.  We use all the common list separators.
3614   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3615   for pkg in $enableval; do
3616     if test "X$pkg" = "X$p"; then
3617       enable_fast_install=yes
3618     fi
3619   done
3620   IFS="$ac_save_ifs"
3621   ;;
3622 esac
3623 else
3624   enable_fast_install=yes
3625 fi;
3626
3627 # Check whether --with-gnu-ld or --without-gnu-ld was given.
3628 if test "${with_gnu_ld+set}" = set; then
3629   withval="$with_gnu_ld"
3630   test "$withval" = no || with_gnu_ld=yes
3631 else
3632   with_gnu_ld=no
3633 fi;
3634 ac_prog=ld
3635 if test "$GCC" = yes; then
3636   # Check if gcc -print-prog-name=ld gives a path.
3637   echo "$as_me:$LINENO: checking for ld used by GCC" >&5
3638 echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6
3639   case $host in
3640   *-*-mingw*)
3641     # gcc leaves a trailing carriage return which upsets mingw
3642     ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
3643   *)
3644     ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
3645   esac
3646   case $ac_prog in
3647     # Accept absolute paths.
3648     [\\/]* | [A-Za-z]:[\\/]*)
3649       re_direlt='/[^/][^/]*/\.\./'
3650       # Canonicalize the path of ld
3651       ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
3652       while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
3653         ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
3654       done
3655       test -z "$LD" && LD="$ac_prog"
3656       ;;
3657   "")
3658     # If it fails, then pretend we aren't using GCC.
3659     ac_prog=ld
3660     ;;
3661   *)
3662     # If it is relative, then search for the first ld in PATH.
3663     with_gnu_ld=unknown
3664     ;;
3665   esac
3666 elif test "$with_gnu_ld" = yes; then
3667   echo "$as_me:$LINENO: checking for GNU ld" >&5
3668 echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6
3669 else
3670   echo "$as_me:$LINENO: checking for non-GNU ld" >&5
3671 echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6
3672 fi
3673 if test "${lt_cv_path_LD+set}" = set; then
3674   echo $ECHO_N "(cached) $ECHO_C" >&6
3675 else
3676   if test -z "$LD"; then
3677   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
3678   for ac_dir in $PATH; do
3679     test -z "$ac_dir" && ac_dir=.
3680     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
3681       lt_cv_path_LD="$ac_dir/$ac_prog"
3682       # Check to see if the program is GNU ld.  I'd rather use --version,
3683       # but apparently some GNU ld's only accept -v.
3684       # Break only if it was the GNU/non-GNU ld that we prefer.
3685       if "$lt_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
3686         test "$with_gnu_ld" != no && break
3687       else
3688         test "$with_gnu_ld" != yes && break
3689       fi
3690     fi
3691   done
3692   IFS="$ac_save_ifs"
3693 else
3694   lt_cv_path_LD="$LD" # Let the user override the test with a path.
3695 fi
3696 fi
3697
3698 LD="$lt_cv_path_LD"
3699 if test -n "$LD"; then
3700   echo "$as_me:$LINENO: result: $LD" >&5
3701 echo "${ECHO_T}$LD" >&6
3702 else
3703   echo "$as_me:$LINENO: result: no" >&5
3704 echo "${ECHO_T}no" >&6
3705 fi
3706 test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5
3707 echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}
3708    { (exit 1); exit 1; }; }
3709 echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
3710 echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6
3711 if test "${lt_cv_prog_gnu_ld+set}" = set; then
3712   echo $ECHO_N "(cached) $ECHO_C" >&6
3713 else
3714   # I'd rather use --version here, but apparently some GNU ld's only accept -v.
3715 if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
3716   lt_cv_prog_gnu_ld=yes
3717 else
3718   lt_cv_prog_gnu_ld=no
3719 fi
3720 fi
3721 echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
3722 echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6
3723 with_gnu_ld=$lt_cv_prog_gnu_ld
3724
3725
3726 echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
3727 echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6
3728 if test "${lt_cv_ld_reload_flag+set}" = set; then
3729   echo $ECHO_N "(cached) $ECHO_C" >&6
3730 else
3731   lt_cv_ld_reload_flag='-r'
3732 fi
3733 echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
3734 echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6
3735 reload_flag=$lt_cv_ld_reload_flag
3736 test -n "$reload_flag" && reload_flag=" $reload_flag"
3737
3738 echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
3739 echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6
3740 if test "${lt_cv_path_NM+set}" = set; then
3741   echo $ECHO_N "(cached) $ECHO_C" >&6
3742 else
3743   if test -n "$NM"; then
3744   # Let the user override the test.
3745   lt_cv_path_NM="$NM"
3746 else
3747   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
3748   for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
3749     test -z "$ac_dir" && ac_dir=.
3750     tmp_nm=$ac_dir/${ac_tool_prefix}nm
3751     if test -f $tmp_nm || test -f $tmp_nm$ac_exeext ; then
3752       # Check to see if the nm accepts a BSD-compat flag.
3753       # Adding the `sed 1q' prevents false positives on HP-UX, which says:
3754       #   nm: unknown option "B" ignored
3755       # Tru64's nm complains that /dev/null is an invalid object file
3756       if ($tmp_nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep '(/dev/null|Invalid file or object type)' >/dev/null; then
3757         lt_cv_path_NM="$tmp_nm -B"
3758         break
3759       elif ($tmp_nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
3760         lt_cv_path_NM="$tmp_nm -p"
3761         break
3762       else
3763         lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
3764         continue # so that we can try to find one that supports BSD flags
3765       fi
3766     fi
3767   done
3768   IFS="$ac_save_ifs"
3769   test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm
3770 fi
3771 fi
3772
3773 NM="$lt_cv_path_NM"
3774 echo "$as_me:$LINENO: result: $NM" >&5
3775 echo "${ECHO_T}$NM" >&6
3776
3777 echo "$as_me:$LINENO: checking whether ln -s works" >&5
3778 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3779 LN_S=$as_ln_s
3780 if test "$LN_S" = "ln -s"; then
3781   echo "$as_me:$LINENO: result: yes" >&5
3782 echo "${ECHO_T}yes" >&6
3783 else
3784   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3785 echo "${ECHO_T}no, using $LN_S" >&6
3786 fi
3787
3788 echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5
3789 echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6
3790 if test "${lt_cv_deplibs_check_method+set}" = set; then
3791   echo $ECHO_N "(cached) $ECHO_C" >&6
3792 else
3793   lt_cv_file_magic_cmd='$MAGIC_CMD'
3794 lt_cv_file_magic_test_file=
3795 lt_cv_deplibs_check_method='unknown'
3796 # Need to set the preceding variable on all platforms that support
3797 # interlibrary dependencies.
3798 # 'none' -- dependencies not supported.
3799 # `unknown' -- same as none, but documents that we really don't know.
3800 # 'pass_all' -- all dependencies passed with no checks.
3801 # 'test_compile' -- check by making test program.
3802 # 'file_magic [regex]' -- check by looking for files in library path
3803 # which responds to the $file_magic_cmd with a given egrep regex.
3804 # If you have `file' or equivalent on your system and you're not sure
3805 # whether `pass_all' will *always* work, you probably want this one.
3806
3807 case $host_os in
3808 aix*)
3809   lt_cv_deplibs_check_method=pass_all
3810   ;;
3811
3812 beos*)
3813   lt_cv_deplibs_check_method=pass_all
3814   ;;
3815
3816 bsdi4*)
3817   lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
3818   lt_cv_file_magic_cmd='/usr/bin/file -L'
3819   lt_cv_file_magic_test_file=/shlib/libc.so
3820   ;;
3821
3822 cygwin* | mingw* |pw32*)
3823   lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
3824   lt_cv_file_magic_cmd='$OBJDUMP -f'
3825   ;;
3826
3827 darwin* | rhapsody*)
3828   # this will be overwritten by pass_all, but leave it in just in case
3829   lt_cv_deplibs_check_method='file_magic Mach-O dynamically linked shared library'
3830   lt_cv_file_magic_cmd='/usr/bin/file -L'
3831   case "$host_os" in
3832   rhapsody* | darwin1.012)
3833     lt_cv_file_magic_test_file='/System/Library/Frameworks/System.framework/System'
3834     ;;
3835   *) # Darwin 1.3 on
3836     lt_cv_file_magic_test_file='/usr/lib/libSystem.dylib'
3837     ;;
3838   esac
3839   lt_cv_deplibs_check_method=pass_all
3840   ;;
3841
3842 freebsd* | kfreebsd*-gnu)
3843   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
3844     case $host_cpu in
3845     i*86 )
3846       # Not sure whether the presence of OpenBSD here was a mistake.
3847       # Let's accept both of them until this is cleared up.
3848       lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[3-9]86 (compact )?demand paged shared library'
3849       lt_cv_file_magic_cmd=/usr/bin/file
3850       lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
3851       ;;
3852     esac
3853   else
3854     lt_cv_deplibs_check_method=pass_all
3855   fi
3856   ;;
3857
3858 gnu*)
3859   lt_cv_deplibs_check_method=pass_all
3860   ;;
3861
3862 hpux10.20*|hpux11*)
3863   case $host_cpu in
3864   hppa*)
3865     lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library'
3866     lt_cv_file_magic_cmd=/usr/bin/file
3867     lt_cv_file_magic_test_file=/usr/lib/libc.sl
3868     ;;
3869   ia64*)
3870     lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
3871     lt_cv_file_magic_cmd=/usr/bin/file
3872     lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
3873     ;;
3874   esac
3875   ;;
3876
3877 irix5* | irix6*)
3878   case $host_os in
3879   irix5*)
3880     # this will be overridden with pass_all, but let us keep it just in case
3881     lt_cv_deplibs_check_method="file_magic ELF 32-bit MSB dynamic lib MIPS - version 1"
3882     ;;
3883   *)
3884     case $LD in
3885     *-32|*"-32 ") libmagic=32-bit;;
3886     *-n32|*"-n32 ") libmagic=N32;;
3887     *-64|*"-64 ") libmagic=64-bit;;
3888     *) libmagic=never-match;;
3889     esac
3890     # this will be overridden with pass_all, but let us keep it just in case
3891     lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[1234] dynamic lib MIPS - version 1"
3892     ;;
3893   esac
3894   lt_cv_file_magic_test_file=`echo /lib${libsuff}/libc.so*`
3895   lt_cv_deplibs_check_method=pass_all
3896   ;;
3897
3898 # This must be Linux ELF.
3899 linux-gnu*)
3900   lt_cv_deplibs_check_method=pass_all
3901   ;;
3902
3903 netbsd* | knetbsd*-gnu)
3904   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
3905     lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so\.[0-9]+\.[0-9]+$'
3906   else
3907     lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so$'
3908   fi
3909   ;;
3910
3911 newsos6)
3912   lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'
3913   lt_cv_file_magic_cmd=/usr/bin/file
3914   lt_cv_file_magic_test_file=/usr/lib/libnls.so
3915   ;;
3916
3917 osf3* | osf4* | osf5*)
3918   # this will be overridden with pass_all, but let us keep it just in case
3919   lt_cv_deplibs_check_method='file_magic COFF format alpha shared library'
3920   lt_cv_file_magic_test_file=/shlib/libc.so
3921   lt_cv_deplibs_check_method=pass_all
3922   ;;
3923
3924 sco3.2v5*)
3925   lt_cv_deplibs_check_method=pass_all
3926   ;;
3927
3928 solaris*)
3929   lt_cv_deplibs_check_method=pass_all
3930   lt_cv_file_magic_test_file=/lib/libc.so
3931   ;;
3932
3933 sysv5uw[78]* | sysv4*uw2*)
3934   lt_cv_deplibs_check_method=pass_all
3935   ;;
3936
3937 sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
3938   case $host_vendor in
3939   ncr)
3940     lt_cv_deplibs_check_method=pass_all
3941     ;;
3942   motorola)
3943     lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'
3944     lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
3945     ;;
3946   esac
3947   ;;
3948 esac
3949
3950 fi
3951 echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
3952 echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6
3953 file_magic_cmd=$lt_cv_file_magic_cmd
3954 deplibs_check_method=$lt_cv_deplibs_check_method
3955
3956
3957
3958
3959
3960 # Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
3961
3962 # find the maximum length of command line arguments
3963 echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
3964 echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6
3965 if test "${lt_cv_sys_max_cmd_len+set}" = set; then
3966   echo $ECHO_N "(cached) $ECHO_C" >&6
3967 else
3968     i=0
3969   teststring="ABCD"
3970
3971   case $build_os in
3972   msdosdjgpp*)
3973     # On DJGPP, this test can blow up pretty badly due to problems in libc
3974     # (any single argument exceeding 2000 bytes causes a buffer overrun
3975     # during glob expansion).  Even if it were fixed, the result of this
3976     # check would be larger than it should be.
3977     lt_cv_sys_max_cmd_len=12288;    # 12K is about right
3978     ;;
3979
3980   cygwin* | mingw*)
3981     # On Win9x/ME, this test blows up -- it succeeds, but takes
3982     # about 5 minutes as the teststring grows exponentially.
3983     # Worse, since 9x/ME are not pre-emptively multitasking,
3984     # you end up with a "frozen" computer, even though with patience
3985     # the test eventually succeeds (with a max line length of 256k).
3986     # Instead, let's just punt: use the minimum linelength reported by
3987     # all of the supported platforms: 8192 (on NT/2K/XP).
3988     lt_cv_sys_max_cmd_len=8192;
3989     ;;
3990
3991   amigaos*)
3992     # On AmigaOS with pdksh, this test takes hours, literally.
3993     # So we just punt and use a minimum line length of 8192.
3994     lt_cv_sys_max_cmd_len=8192;
3995     ;;
3996
3997   netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
3998     # This has been around since 386BSD, at least.  Likely further.
3999     if test -x /sbin/sysctl; then
4000       lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
4001     elif test -x /usr/sbin/sysctl; then
4002       lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
4003     else
4004       lt_cv_sys_max_cmd_len=65536 # usable default for *BSD
4005     fi
4006     # And add a safety zone
4007     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
4008     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
4009     ;;
4010   esac
4011
4012 fi
4013
4014 if test -n "$lt_cv_sys_max_cmd_len" ; then
4015   echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
4016 echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6
4017 else
4018   echo "$as_me:$LINENO: result: none" >&5
4019 echo "${ECHO_T}none" >&6
4020 fi
4021
4022
4023 # Only perform the check for file, if the check method requires it
4024 case $deplibs_check_method in
4025 file_magic*)
4026   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
4027     echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
4028 echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6
4029 if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
4030   echo $ECHO_N "(cached) $ECHO_C" >&6
4031 else
4032   case $MAGIC_CMD in
4033   /*)
4034   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
4035   ;;
4036   ?:/*)
4037   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
4038   ;;
4039   *)
4040   ac_save_MAGIC_CMD="$MAGIC_CMD"
4041   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4042   ac_dummy="/usr/bin:$PATH"
4043   for ac_dir in $ac_dummy; do
4044     test -z "$ac_dir" && ac_dir=.
4045     if test -f $ac_dir/${ac_tool_prefix}file; then
4046       lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
4047       if test -n "$file_magic_test_file"; then
4048         case $deplibs_check_method in
4049         "file_magic "*)
4050           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
4051           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
4052           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
4053             egrep "$file_magic_regex" > /dev/null; then
4054             :
4055           else
4056             cat <<EOF 1>&2
4057
4058 *** Warning: the command libtool uses to detect shared libraries,
4059 *** $file_magic_cmd, produces output that libtool cannot recognize.
4060 *** The result is that libtool may fail to recognize shared libraries
4061 *** as such.  This will affect the creation of libtool libraries that
4062 *** depend on shared libraries, but programs linked with such libtool
4063 *** libraries will work regardless of this problem.  Nevertheless, you
4064 *** may want to report the problem to your system manager and/or to
4065 *** bug-libtool@gnu.org
4066
4067 EOF
4068           fi ;;
4069         esac
4070       fi
4071       break
4072     fi
4073   done
4074   IFS="$ac_save_ifs"
4075   MAGIC_CMD="$ac_save_MAGIC_CMD"
4076   ;;
4077 esac
4078 fi
4079
4080 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
4081 if test -n "$MAGIC_CMD"; then
4082   echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
4083 echo "${ECHO_T}$MAGIC_CMD" >&6
4084 else
4085   echo "$as_me:$LINENO: result: no" >&5
4086 echo "${ECHO_T}no" >&6
4087 fi
4088
4089 if test -z "$lt_cv_path_MAGIC_CMD"; then
4090   if test -n "$ac_tool_prefix"; then
4091     echo "$as_me:$LINENO: checking for file" >&5
4092 echo $ECHO_N "checking for file... $ECHO_C" >&6
4093 if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
4094   echo $ECHO_N "(cached) $ECHO_C" >&6
4095 else
4096   case $MAGIC_CMD in
4097   /*)
4098   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
4099   ;;
4100   ?:/*)
4101   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
4102   ;;
4103   *)
4104   ac_save_MAGIC_CMD="$MAGIC_CMD"
4105   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4106   ac_dummy="/usr/bin:$PATH"
4107   for ac_dir in $ac_dummy; do
4108     test -z "$ac_dir" && ac_dir=.
4109     if test -f $ac_dir/file; then
4110       lt_cv_path_MAGIC_CMD="$ac_dir/file"
4111       if test -n "$file_magic_test_file"; then
4112         case $deplibs_check_method in
4113         "file_magic "*)
4114           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
4115           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
4116           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
4117             egrep "$file_magic_regex" > /dev/null; then
4118             :
4119           else
4120             cat <<EOF 1>&2
4121
4122 *** Warning: the command libtool uses to detect shared libraries,
4123 *** $file_magic_cmd, produces output that libtool cannot recognize.
4124 *** The result is that libtool may fail to recognize shared libraries
4125 *** as such.  This will affect the creation of libtool libraries that
4126 *** depend on shared libraries, but programs linked with such libtool
4127 *** libraries will work regardless of this problem.  Nevertheless, you
4128 *** may want to report the problem to your system manager and/or to
4129 *** bug-libtool@gnu.org
4130
4131 EOF
4132           fi ;;
4133         esac
4134       fi
4135       break
4136     fi
4137   done
4138   IFS="$ac_save_ifs"
4139   MAGIC_CMD="$ac_save_MAGIC_CMD"
4140   ;;
4141 esac
4142 fi
4143
4144 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
4145 if test -n "$MAGIC_CMD"; then
4146   echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
4147 echo "${ECHO_T}$MAGIC_CMD" >&6
4148 else
4149   echo "$as_me:$LINENO: result: no" >&5
4150 echo "${ECHO_T}no" >&6
4151 fi
4152
4153   else
4154     MAGIC_CMD=:
4155   fi
4156 fi
4157
4158   fi
4159   ;;
4160 esac
4161
4162 if test -n "$ac_tool_prefix"; then
4163   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
4164 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
4165 echo "$as_me:$LINENO: checking for $ac_word" >&5
4166 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4167 if test "${ac_cv_prog_RANLIB+set}" = set; then
4168   echo $ECHO_N "(cached) $ECHO_C" >&6
4169 else
4170   if test -n "$RANLIB"; then
4171   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
4172 else
4173 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4174 for as_dir in $PATH
4175 do
4176   IFS=$as_save_IFS
4177   test -z "$as_dir" && as_dir=.
4178   for ac_exec_ext in '' $ac_executable_extensions; do
4179   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4180     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
4181     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4182     break 2
4183   fi
4184 done
4185 done
4186
4187 fi
4188 fi
4189 RANLIB=$ac_cv_prog_RANLIB
4190 if test -n "$RANLIB"; then
4191   echo "$as_me:$LINENO: result: $RANLIB" >&5
4192 echo "${ECHO_T}$RANLIB" >&6
4193 else
4194   echo "$as_me:$LINENO: result: no" >&5
4195 echo "${ECHO_T}no" >&6
4196 fi
4197
4198 fi
4199 if test -z "$ac_cv_prog_RANLIB"; then
4200   ac_ct_RANLIB=$RANLIB
4201   # Extract the first word of "ranlib", so it can be a program name with args.
4202 set dummy ranlib; ac_word=$2
4203 echo "$as_me:$LINENO: checking for $ac_word" >&5
4204 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4205 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
4206   echo $ECHO_N "(cached) $ECHO_C" >&6
4207 else
4208   if test -n "$ac_ct_RANLIB"; then
4209   ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
4210 else
4211 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4212 for as_dir in $PATH
4213 do
4214   IFS=$as_save_IFS
4215   test -z "$as_dir" && as_dir=.
4216   for ac_exec_ext in '' $ac_executable_extensions; do
4217   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4218     ac_cv_prog_ac_ct_RANLIB="ranlib"
4219     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4220     break 2
4221   fi
4222 done
4223 done
4224
4225   test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
4226 fi
4227 fi
4228 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
4229 if test -n "$ac_ct_RANLIB"; then
4230   echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
4231 echo "${ECHO_T}$ac_ct_RANLIB" >&6
4232 else
4233   echo "$as_me:$LINENO: result: no" >&5
4234 echo "${ECHO_T}no" >&6
4235 fi
4236
4237   RANLIB=$ac_ct_RANLIB
4238 else
4239   RANLIB="$ac_cv_prog_RANLIB"
4240 fi
4241
4242 if test -n "$ac_tool_prefix"; then
4243   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
4244 set dummy ${ac_tool_prefix}strip; ac_word=$2
4245 echo "$as_me:$LINENO: checking for $ac_word" >&5
4246 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4247 if test "${ac_cv_prog_STRIP+set}" = set; then
4248   echo $ECHO_N "(cached) $ECHO_C" >&6
4249 else
4250   if test -n "$STRIP"; then
4251   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
4252 else
4253 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4254 for as_dir in $PATH
4255 do
4256   IFS=$as_save_IFS
4257   test -z "$as_dir" && as_dir=.
4258   for ac_exec_ext in '' $ac_executable_extensions; do
4259   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4260     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
4261     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4262     break 2
4263   fi
4264 done
4265 done
4266
4267 fi
4268 fi
4269 STRIP=$ac_cv_prog_STRIP
4270 if test -n "$STRIP"; then
4271   echo "$as_me:$LINENO: result: $STRIP" >&5
4272 echo "${ECHO_T}$STRIP" >&6
4273 else
4274   echo "$as_me:$LINENO: result: no" >&5
4275 echo "${ECHO_T}no" >&6
4276 fi
4277
4278 fi
4279 if test -z "$ac_cv_prog_STRIP"; then
4280   ac_ct_STRIP=$STRIP
4281   # Extract the first word of "strip", so it can be a program name with args.
4282 set dummy strip; ac_word=$2
4283 echo "$as_me:$LINENO: checking for $ac_word" >&5
4284 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4285 if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
4286   echo $ECHO_N "(cached) $ECHO_C" >&6
4287 else
4288   if test -n "$ac_ct_STRIP"; then
4289   ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
4290 else
4291 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4292 for as_dir in $PATH
4293 do
4294   IFS=$as_save_IFS
4295   test -z "$as_dir" && as_dir=.
4296   for ac_exec_ext in '' $ac_executable_extensions; do
4297   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4298     ac_cv_prog_ac_ct_STRIP="strip"
4299     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4300     break 2
4301   fi
4302 done
4303 done
4304
4305   test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
4306 fi
4307 fi
4308 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
4309 if test -n "$ac_ct_STRIP"; then
4310   echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
4311 echo "${ECHO_T}$ac_ct_STRIP" >&6
4312 else
4313   echo "$as_me:$LINENO: result: no" >&5
4314 echo "${ECHO_T}no" >&6
4315 fi
4316
4317   STRIP=$ac_ct_STRIP
4318 else
4319   STRIP="$ac_cv_prog_STRIP"
4320 fi
4321
4322
4323 # Check for any special flags to pass to ltconfig.
4324 libtool_flags="--cache-file=$cache_file"
4325 test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
4326 test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
4327 test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
4328 test "$GCC" = yes && libtool_flags="$libtool_flags --with-gcc"
4329 test "$lt_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
4330
4331
4332 # Check whether --enable-libtool-lock or --disable-libtool-lock was given.
4333 if test "${enable_libtool_lock+set}" = set; then
4334   enableval="$enable_libtool_lock"
4335
4336 fi;
4337 test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
4338 test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
4339
4340
4341 # Check whether --with-pic or --without-pic was given.
4342 if test "${with_pic+set}" = set; then
4343   withval="$with_pic"
4344   pic_mode="$withval"
4345 else
4346   pic_mode=default
4347 fi;
4348 test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic"
4349 test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
4350
4351 # Some flags need to be propagated to the compiler or linker for good
4352 # libtool support.
4353 case $host in
4354 *-*-irix6*)
4355   # Find out which ABI we are using.
4356   echo '#line 4356 "configure"' > conftest.$ac_ext
4357   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4358   (eval $ac_compile) 2>&5
4359   ac_status=$?
4360   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4361   (exit $ac_status); }; then
4362    if test "$lt_cv_prog_gnu_ld" = yes; then
4363     case `/usr/bin/file conftest.$ac_objext` in
4364     *32-bit*)
4365       LD="${LD-ld} -melf32bsmip"
4366       ;;
4367     *N32*)
4368       LD="${LD-ld} -melf32bmipn32"
4369       ;;
4370     *64-bit*)
4371       LD="${LD-ld} -melf64bmip"
4372       ;;
4373     esac
4374    else
4375     case `/usr/bin/file conftest.$ac_objext` in
4376     *32-bit*)
4377       LD="${LD-ld} -32"
4378       ;;
4379     *N32*)
4380       LD="${LD-ld} -n32"
4381       ;;
4382     *64-bit*)
4383       LD="${LD-ld} -64"
4384       ;;
4385     esac
4386    fi
4387   fi
4388   rm -rf conftest*
4389   ;;
4390
4391 ia64-*-hpux*)
4392   # Find out which ABI we are using.
4393   echo 'int i;' > conftest.$ac_ext
4394   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4395   (eval $ac_compile) 2>&5
4396   ac_status=$?
4397   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4398   (exit $ac_status); }; then
4399     case "`/usr/bin/file conftest.o`" in
4400     *ELF-32*)
4401       HPUX_IA64_MODE="32"
4402       ;;
4403     *ELF-64*)
4404       HPUX_IA64_MODE="64"
4405       ;;
4406     esac
4407   fi
4408   rm -rf conftest*
4409   ;;
4410
4411 x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*)
4412   # Find out which ABI we are using.
4413   echo 'int i;' > conftest.$ac_ext
4414   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4415   (eval $ac_compile) 2>&5
4416   ac_status=$?
4417   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4418   (exit $ac_status); }; then
4419     case "`/usr/bin/file conftest.o`" in
4420     *32-bit*)
4421       case $host in
4422         x86_64-*linux*)
4423           LD="${LD-ld} -m elf_i386"
4424           ;;
4425         ppc64-*linux*|powerpc64-*linux*)
4426           LD="${LD-ld} -m elf32ppclinux"
4427           ;;
4428         s390x-*linux*)
4429           LD="${LD-ld} -m elf_s390"
4430           ;;
4431         sparc64-*linux*)
4432           LD="${LD-ld} -m elf32_sparc"
4433           ;;
4434       esac
4435       ;;
4436     *64-bit*)
4437       case $host in
4438         x86_64-*linux*)
4439           LD="${LD-ld} -m elf_x86_64"
4440           ;;
4441         ppc*-*linux*|powerpc*-*linux*)
4442           LD="${LD-ld} -m elf64ppc"
4443           ;;
4444         s390*-*linux*)
4445           LD="${LD-ld} -m elf64_s390"
4446           ;;
4447         sparc*-*linux*)
4448           LD="${LD-ld} -m elf64_sparc"
4449           ;;
4450       esac
4451       ;;
4452     esac
4453   fi
4454   rm -rf conftest*
4455   ;;
4456
4457 *-*-sco3.2v5*)
4458   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
4459   SAVE_CFLAGS="$CFLAGS"
4460   CFLAGS="$CFLAGS -belf"
4461   echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
4462 echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6
4463 if test "${lt_cv_cc_needs_belf+set}" = set; then
4464   echo $ECHO_N "(cached) $ECHO_C" >&6
4465 else
4466
4467
4468      ac_ext=c
4469 ac_cpp='$CPP $CPPFLAGS'
4470 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4471 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4472 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4473
4474      if test x$gcc_no_link = xyes; then
4475   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
4476 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
4477    { (exit 1); exit 1; }; }
4478 fi
4479 cat >conftest.$ac_ext <<_ACEOF
4480 /* confdefs.h.  */
4481 _ACEOF
4482 cat confdefs.h >>conftest.$ac_ext
4483 cat >>conftest.$ac_ext <<_ACEOF
4484 /* end confdefs.h.  */
4485
4486 int
4487 main ()
4488 {
4489
4490   ;
4491   return 0;
4492 }
4493 _ACEOF
4494 rm -f conftest.$ac_objext conftest$ac_exeext
4495 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4496   (eval $ac_link) 2>conftest.er1
4497   ac_status=$?
4498   grep -v '^ *+' conftest.er1 >conftest.err
4499   rm -f conftest.er1
4500   cat conftest.err >&5
4501   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4502   (exit $ac_status); } &&
4503          { ac_try='test -z "$ac_c_werror_flag"
4504                          || test ! -s conftest.err'
4505   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4506   (eval $ac_try) 2>&5
4507   ac_status=$?
4508   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4509   (exit $ac_status); }; } &&
4510          { ac_try='test -s conftest$ac_exeext'
4511   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4512   (eval $ac_try) 2>&5
4513   ac_status=$?
4514   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4515   (exit $ac_status); }; }; then
4516   lt_cv_cc_needs_belf=yes
4517 else
4518   echo "$as_me: failed program was:" >&5
4519 sed 's/^/| /' conftest.$ac_ext >&5
4520
4521 lt_cv_cc_needs_belf=no
4522 fi
4523 rm -f conftest.err conftest.$ac_objext \
4524       conftest$ac_exeext conftest.$ac_ext
4525      ac_ext=c
4526 ac_cpp='$CPP $CPPFLAGS'
4527 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4528 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4529 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4530
4531 fi
4532 echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
4533 echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6
4534   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
4535     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
4536     CFLAGS="$SAVE_CFLAGS"
4537   fi
4538   ;;
4539
4540
4541 esac
4542
4543
4544 # Save cache, so that ltconfig can load it
4545 cat >confcache <<\_ACEOF
4546 # This file is a shell script that caches the results of configure
4547 # tests run on this system so they can be shared between configure
4548 # scripts and configure runs, see configure's option --config-cache.
4549 # It is not useful on other systems.  If it contains results you don't
4550 # want to keep, you may remove or edit it.
4551 #
4552 # config.status only pays attention to the cache file if you give it
4553 # the --recheck option to rerun configure.
4554 #
4555 # `ac_cv_env_foo' variables (set or unset) will be overridden when
4556 # loading this file, other *unset* `ac_cv_foo' will be assigned the
4557 # following values.
4558
4559 _ACEOF
4560
4561 # The following way of writing the cache mishandles newlines in values,
4562 # but we know of no workaround that is simple, portable, and efficient.
4563 # So, don't put newlines in cache variables' values.
4564 # Ultrix sh set writes to stderr and can't be redirected directly,
4565 # and sets the high bit in the cache file unless we assign to the vars.
4566 {
4567   (set) 2>&1 |
4568     case `(ac_space=' '; set | grep ac_space) 2>&1` in
4569     *ac_space=\ *)
4570       # `set' does not quote correctly, so add quotes (double-quote
4571       # substitution turns \\\\ into \\, and sed turns \\ into \).
4572       sed -n \
4573         "s/'/'\\\\''/g;
4574           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
4575       ;;
4576     *)
4577       # `set' quotes correctly as required by POSIX, so do not add quotes.
4578       sed -n \
4579         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
4580       ;;
4581     esac;
4582 } |
4583   sed '
4584      t clear
4585      : clear
4586      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
4587      t end
4588      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
4589      : end' >>confcache
4590 if diff $cache_file confcache >/dev/null 2>&1; then :; else
4591   if test -w $cache_file; then
4592     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
4593     cat confcache >$cache_file
4594   else
4595     echo "not updating unwritable cache $cache_file"
4596   fi
4597 fi
4598 rm -f confcache
4599
4600 # Actually configure libtool.  ac_aux_dir is where install-sh is found.
4601 AR="$AR" LTCC="$CC" CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
4602 MAGIC_CMD="$MAGIC_CMD" LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
4603 LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \
4604 AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \
4605 objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \
4606 deplibs_check_method="$deplibs_check_method" file_magic_cmd="$file_magic_cmd" \
4607 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
4608 $libtool_flags --no-verify --build="$build" $ac_aux_dir/ltmain.sh $host \
4609 || { { echo "$as_me:$LINENO: error: libtool configure failed" >&5
4610 echo "$as_me: error: libtool configure failed" >&2;}
4611    { (exit 1); exit 1; }; }
4612
4613 # Reload cache, that may have been modified by ltconfig
4614 if test -r "$cache_file"; then
4615   # Some versions of bash will fail to source /dev/null (special
4616   # files actually), so we avoid doing that.
4617   if test -f "$cache_file"; then
4618     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
4619 echo "$as_me: loading cache $cache_file" >&6;}
4620     case $cache_file in
4621       [\\/]* | ?:[\\/]* ) . $cache_file;;
4622       *)                      . ./$cache_file;;
4623     esac
4624   fi
4625 else
4626   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
4627 echo "$as_me: creating cache $cache_file" >&6;}
4628   >$cache_file
4629 fi
4630
4631
4632 # This can be used to rebuild libtool when needed
4633 LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh $ac_aux_dir/ltcf-c.sh"
4634
4635 # Always use our own libtool.
4636 LIBTOOL='$(SHELL) $(top_builddir)/libtool'
4637
4638 # Redirect the config.log output again, so that the ltconfig log is not
4639 # clobbered by the next message.
4640 exec 5>>./config.log
4641
4642
4643
4644
4645
4646
4647
4648
4649 #AC_MSG_NOTICE([====== Finished libtool configuration]) ; sleep 10
4650
4651 # We need gfortran to compile parts of the library
4652 #AC_PROG_FC(gfortran)
4653 FC="$GFORTRAN"
4654 ac_ext=${FC_SRCEXT-f}
4655 ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4656 ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4657 ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4658 if test -n "$ac_tool_prefix"; then
4659   for ac_prog in gfortran
4660   do
4661     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4662 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4663 echo "$as_me:$LINENO: checking for $ac_word" >&5
4664 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4665 if test "${ac_cv_prog_FC+set}" = set; then
4666   echo $ECHO_N "(cached) $ECHO_C" >&6
4667 else
4668   if test -n "$FC"; then
4669   ac_cv_prog_FC="$FC" # Let the user override the test.
4670 else
4671 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4672 for as_dir in $PATH
4673 do
4674   IFS=$as_save_IFS
4675   test -z "$as_dir" && as_dir=.
4676   for ac_exec_ext in '' $ac_executable_extensions; do
4677   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4678     ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
4679     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4680     break 2
4681   fi
4682 done
4683 done
4684
4685 fi
4686 fi
4687 FC=$ac_cv_prog_FC
4688 if test -n "$FC"; then
4689   echo "$as_me:$LINENO: result: $FC" >&5
4690 echo "${ECHO_T}$FC" >&6
4691 else
4692   echo "$as_me:$LINENO: result: no" >&5
4693 echo "${ECHO_T}no" >&6
4694 fi
4695
4696     test -n "$FC" && break
4697   done
4698 fi
4699 if test -z "$FC"; then
4700   ac_ct_FC=$FC
4701   for ac_prog in gfortran
4702 do
4703   # Extract the first word of "$ac_prog", so it can be a program name with args.
4704 set dummy $ac_prog; ac_word=$2
4705 echo "$as_me:$LINENO: checking for $ac_word" >&5
4706 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4707 if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
4708   echo $ECHO_N "(cached) $ECHO_C" >&6
4709 else
4710   if test -n "$ac_ct_FC"; then
4711   ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
4712 else
4713 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4714 for as_dir in $PATH
4715 do
4716   IFS=$as_save_IFS
4717   test -z "$as_dir" && as_dir=.
4718   for ac_exec_ext in '' $ac_executable_extensions; do
4719   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4720     ac_cv_prog_ac_ct_FC="$ac_prog"
4721     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4722     break 2
4723   fi
4724 done
4725 done
4726
4727 fi
4728 fi
4729 ac_ct_FC=$ac_cv_prog_ac_ct_FC
4730 if test -n "$ac_ct_FC"; then
4731   echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
4732 echo "${ECHO_T}$ac_ct_FC" >&6
4733 else
4734   echo "$as_me:$LINENO: result: no" >&5
4735 echo "${ECHO_T}no" >&6
4736 fi
4737
4738   test -n "$ac_ct_FC" && break
4739 done
4740
4741   FC=$ac_ct_FC
4742 fi
4743
4744
4745 # Provide some information about the compiler.
4746 echo "$as_me:4746:" \
4747      "checking for Fortran compiler version" >&5
4748 ac_compiler=`set X $ac_compile; echo $2`
4749 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
4750   (eval $ac_compiler --version </dev/null >&5) 2>&5
4751   ac_status=$?
4752   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4753   (exit $ac_status); }
4754 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
4755   (eval $ac_compiler -v </dev/null >&5) 2>&5
4756   ac_status=$?
4757   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4758   (exit $ac_status); }
4759 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
4760   (eval $ac_compiler -V </dev/null >&5) 2>&5
4761   ac_status=$?
4762   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4763   (exit $ac_status); }
4764 rm -f a.out
4765
4766 # If we don't use `.F' as extension, the preprocessor is not run on the
4767 # input file.  (Note that this only needs to work for GNU compilers.)
4768 ac_save_ext=$ac_ext
4769 ac_ext=F
4770 echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
4771 echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
4772 if test "${ac_cv_fc_compiler_gnu+set}" = set; then
4773   echo $ECHO_N "(cached) $ECHO_C" >&6
4774 else
4775   cat >conftest.$ac_ext <<_ACEOF
4776       program main
4777 #ifndef __GNUC__
4778        choke me
4779 #endif
4780
4781       end
4782 _ACEOF
4783 rm -f conftest.$ac_objext
4784 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4785   (eval $ac_compile) 2>conftest.er1
4786   ac_status=$?
4787   grep -v '^ *+' conftest.er1 >conftest.err
4788   rm -f conftest.er1
4789   cat conftest.err >&5
4790   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4791   (exit $ac_status); } &&
4792          { ac_try='test -z "$ac_fc_werror_flag"
4793                          || test ! -s conftest.err'
4794   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4795   (eval $ac_try) 2>&5
4796   ac_status=$?
4797   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4798   (exit $ac_status); }; } &&
4799          { ac_try='test -s conftest.$ac_objext'
4800   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4801   (eval $ac_try) 2>&5
4802   ac_status=$?
4803   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4804   (exit $ac_status); }; }; then
4805   ac_compiler_gnu=yes
4806 else
4807   echo "$as_me: failed program was:" >&5
4808 sed 's/^/| /' conftest.$ac_ext >&5
4809
4810 ac_compiler_gnu=no
4811 fi
4812 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4813 ac_cv_fc_compiler_gnu=$ac_compiler_gnu
4814
4815 fi
4816 echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
4817 echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
4818 ac_ext=$ac_save_ext
4819 ac_test_FFLAGS=${FCFLAGS+set}
4820 ac_save_FFLAGS=$FCFLAGS
4821 FCFLAGS=
4822 echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
4823 echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
4824 if test "${ac_cv_prog_fc_g+set}" = set; then
4825   echo $ECHO_N "(cached) $ECHO_C" >&6
4826 else
4827   FCFLAGS=-g
4828 cat >conftest.$ac_ext <<_ACEOF
4829       program main
4830
4831       end
4832 _ACEOF
4833 rm -f conftest.$ac_objext
4834 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4835   (eval $ac_compile) 2>conftest.er1
4836   ac_status=$?
4837   grep -v '^ *+' conftest.er1 >conftest.err
4838   rm -f conftest.er1
4839   cat conftest.err >&5
4840   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4841   (exit $ac_status); } &&
4842          { ac_try='test -z "$ac_fc_werror_flag"
4843                          || test ! -s conftest.err'
4844   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4845   (eval $ac_try) 2>&5
4846   ac_status=$?
4847   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4848   (exit $ac_status); }; } &&
4849          { ac_try='test -s conftest.$ac_objext'
4850   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4851   (eval $ac_try) 2>&5
4852   ac_status=$?
4853   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4854   (exit $ac_status); }; }; then
4855   ac_cv_prog_fc_g=yes
4856 else
4857   echo "$as_me: failed program was:" >&5
4858 sed 's/^/| /' conftest.$ac_ext >&5
4859
4860 ac_cv_prog_fc_g=no
4861 fi
4862 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4863
4864 fi
4865 echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
4866 echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
4867 if test "$ac_test_FFLAGS" = set; then
4868   FCFLAGS=$ac_save_FFLAGS
4869 elif test $ac_cv_prog_fc_g = yes; then
4870   if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4871     FCFLAGS="-g -O2"
4872   else
4873     FCFLAGS="-g"
4874   fi
4875 else
4876   if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4877     FCFLAGS="-O2"
4878   else
4879     FCFLAGS=
4880   fi
4881 fi
4882
4883 ac_ext=c
4884 ac_cpp='$CPP $CPPFLAGS'
4885 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4886 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4887 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4888
4889
4890 # extra LD Flags which are required for targets
4891 case "${host}" in
4892   *-darwin*)
4893     # Darwin needs -single_module when linking libgfortran
4894     extra_ldflags_libgfortran=-Wl,-single_module
4895     ;;
4896 esac
4897
4898
4899 # We need a working compiler at that point, otherwise give a clear
4900 # error message and bail out.
4901
4902
4903 echo "$as_me:$LINENO: checking whether the GNU Fortran compiler is working" >&5
4904 echo $ECHO_N "checking whether the GNU Fortran compiler is working... $ECHO_C" >&6
4905 ac_ext=${FC_SRCEXT-f}
4906 ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4907 ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4908 ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4909
4910 cat >conftest.$ac_ext <<_ACEOF
4911
4912       program foo
4913       real, parameter :: bar = sin (12.34 / 2.5)
4914       end program foo
4915 _ACEOF
4916 rm -f conftest.$ac_objext
4917 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4918   (eval $ac_compile) 2>conftest.er1
4919   ac_status=$?
4920   grep -v '^ *+' conftest.er1 >conftest.err
4921   rm -f conftest.er1
4922   cat conftest.err >&5
4923   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4924   (exit $ac_status); } &&
4925          { ac_try='test -z "$ac_fc_werror_flag"
4926                          || test ! -s conftest.err'
4927   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4928   (eval $ac_try) 2>&5
4929   ac_status=$?
4930   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4931   (exit $ac_status); }; } &&
4932          { ac_try='test -s conftest.$ac_objext'
4933   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4934   (eval $ac_try) 2>&5
4935   ac_status=$?
4936   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4937   (exit $ac_status); }; }; then
4938   echo "$as_me:$LINENO: result: yes" >&5
4939 echo "${ECHO_T}yes" >&6
4940 else
4941   echo "$as_me: failed program was:" >&5
4942 sed 's/^/| /' conftest.$ac_ext >&5
4943
4944 echo "$as_me:$LINENO: result: no" >&5
4945 echo "${ECHO_T}no" >&6
4946      { { echo "$as_me:$LINENO: error: GNU Fortran is not working; please report a bug in http://gcc.gnu.org/bugzilla, attaching $PWD/config.log" >&5
4947 echo "$as_me: error: GNU Fortran is not working; please report a bug in http://gcc.gnu.org/bugzilla, attaching $PWD/config.log" >&2;}
4948    { (exit 1); exit 1; }; }
4949
4950 fi
4951 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4952 ac_ext=c
4953 ac_cpp='$CPP $CPPFLAGS'
4954 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4955 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4956 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4957
4958
4959
4960 # Check whether --enable-largefile or --disable-largefile was given.
4961 if test "${enable_largefile+set}" = set; then
4962   enableval="$enable_largefile"
4963
4964 fi;
4965 if test "$enable_largefile" != no; then
4966
4967   echo "$as_me:$LINENO: checking for special C compiler options needed for large files" >&5
4968 echo $ECHO_N "checking for special C compiler options needed for large files... $ECHO_C" >&6
4969 if test "${ac_cv_sys_largefile_CC+set}" = set; then
4970   echo $ECHO_N "(cached) $ECHO_C" >&6
4971 else
4972   ac_cv_sys_largefile_CC=no
4973      if test "$GCC" != yes; then
4974        ac_save_CC=$CC
4975        while :; do
4976          # IRIX 6.2 and later do not support large files by default,
4977          # so use the C compiler's -n32 option if that helps.
4978          cat >conftest.$ac_ext <<_ACEOF
4979 /* confdefs.h.  */
4980 _ACEOF
4981 cat confdefs.h >>conftest.$ac_ext
4982 cat >>conftest.$ac_ext <<_ACEOF
4983 /* end confdefs.h.  */
4984 #include <sys/types.h>
4985  /* Check that off_t can represent 2**63 - 1 correctly.
4986     We can't simply define LARGE_OFF_T to be 9223372036854775807,
4987     since some C++ compilers masquerading as C compilers
4988     incorrectly reject 9223372036854775807.  */
4989 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4990   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4991                        && LARGE_OFF_T % 2147483647 == 1)
4992                       ? 1 : -1];
4993 int
4994 main ()
4995 {
4996
4997   ;
4998   return 0;
4999 }
5000 _ACEOF
5001          rm -f conftest.$ac_objext
5002 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5003   (eval $ac_compile) 2>conftest.er1
5004   ac_status=$?
5005   grep -v '^ *+' conftest.er1 >conftest.err
5006   rm -f conftest.er1
5007   cat conftest.err >&5
5008   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5009   (exit $ac_status); } &&
5010          { ac_try='test -z "$ac_c_werror_flag"
5011                          || test ! -s conftest.err'
5012   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5013   (eval $ac_try) 2>&5
5014   ac_status=$?
5015   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5016   (exit $ac_status); }; } &&
5017          { ac_try='test -s conftest.$ac_objext'
5018   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5019   (eval $ac_try) 2>&5
5020   ac_status=$?
5021   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5022   (exit $ac_status); }; }; then
5023   break
5024 else
5025   echo "$as_me: failed program was:" >&5
5026 sed 's/^/| /' conftest.$ac_ext >&5
5027
5028 fi
5029 rm -f conftest.err conftest.$ac_objext
5030          CC="$CC -n32"
5031          rm -f conftest.$ac_objext
5032 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5033   (eval $ac_compile) 2>conftest.er1
5034   ac_status=$?
5035   grep -v '^ *+' conftest.er1 >conftest.err
5036   rm -f conftest.er1
5037   cat conftest.err >&5
5038   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5039   (exit $ac_status); } &&
5040          { ac_try='test -z "$ac_c_werror_flag"
5041                          || test ! -s conftest.err'
5042   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5043   (eval $ac_try) 2>&5
5044   ac_status=$?
5045   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5046   (exit $ac_status); }; } &&
5047          { ac_try='test -s conftest.$ac_objext'
5048   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5049   (eval $ac_try) 2>&5
5050   ac_status=$?
5051   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5052   (exit $ac_status); }; }; then
5053   ac_cv_sys_largefile_CC=' -n32'; break
5054 else
5055   echo "$as_me: failed program was:" >&5
5056 sed 's/^/| /' conftest.$ac_ext >&5
5057
5058 fi
5059 rm -f conftest.err conftest.$ac_objext
5060          break
5061        done
5062        CC=$ac_save_CC
5063        rm -f conftest.$ac_ext
5064     fi
5065 fi
5066 echo "$as_me:$LINENO: result: $ac_cv_sys_largefile_CC" >&5
5067 echo "${ECHO_T}$ac_cv_sys_largefile_CC" >&6
5068   if test "$ac_cv_sys_largefile_CC" != no; then
5069     CC=$CC$ac_cv_sys_largefile_CC
5070   fi
5071
5072   echo "$as_me:$LINENO: checking for _FILE_OFFSET_BITS value needed for large files" >&5
5073 echo $ECHO_N "checking for _FILE_OFFSET_BITS value needed for large files... $ECHO_C" >&6
5074 if test "${ac_cv_sys_file_offset_bits+set}" = set; then
5075   echo $ECHO_N "(cached) $ECHO_C" >&6
5076 else
5077   while :; do
5078   ac_cv_sys_file_offset_bits=no
5079   cat >conftest.$ac_ext <<_ACEOF
5080 /* confdefs.h.  */
5081 _ACEOF
5082 cat confdefs.h >>conftest.$ac_ext
5083 cat >>conftest.$ac_ext <<_ACEOF
5084 /* end confdefs.h.  */
5085 #include <sys/types.h>
5086  /* Check that off_t can represent 2**63 - 1 correctly.
5087     We can't simply define LARGE_OFF_T to be 9223372036854775807,
5088     since some C++ compilers masquerading as C compilers
5089     incorrectly reject 9223372036854775807.  */
5090 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5091   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5092                        && LARGE_OFF_T % 2147483647 == 1)
5093                       ? 1 : -1];
5094 int
5095 main ()
5096 {
5097
5098   ;
5099   return 0;
5100 }
5101 _ACEOF
5102 rm -f conftest.$ac_objext
5103 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5104   (eval $ac_compile) 2>conftest.er1
5105   ac_status=$?
5106   grep -v '^ *+' conftest.er1 >conftest.err
5107   rm -f conftest.er1
5108   cat conftest.err >&5
5109   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5110   (exit $ac_status); } &&
5111          { ac_try='test -z "$ac_c_werror_flag"
5112                          || test ! -s conftest.err'
5113   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5114   (eval $ac_try) 2>&5
5115   ac_status=$?
5116   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5117   (exit $ac_status); }; } &&
5118          { ac_try='test -s conftest.$ac_objext'
5119   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5120   (eval $ac_try) 2>&5
5121   ac_status=$?
5122   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5123   (exit $ac_status); }; }; then
5124   break
5125 else
5126   echo "$as_me: failed program was:" >&5
5127 sed 's/^/| /' conftest.$ac_ext >&5
5128
5129 fi
5130 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5131   cat >conftest.$ac_ext <<_ACEOF
5132 /* confdefs.h.  */
5133 _ACEOF
5134 cat confdefs.h >>conftest.$ac_ext
5135 cat >>conftest.$ac_ext <<_ACEOF
5136 /* end confdefs.h.  */
5137 #define _FILE_OFFSET_BITS 64
5138 #include <sys/types.h>
5139  /* Check that off_t can represent 2**63 - 1 correctly.
5140     We can't simply define LARGE_OFF_T to be 9223372036854775807,
5141     since some C++ compilers masquerading as C compilers
5142     incorrectly reject 9223372036854775807.  */
5143 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5144   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5145                        && LARGE_OFF_T % 2147483647 == 1)
5146                       ? 1 : -1];
5147 int
5148 main ()
5149 {
5150
5151   ;
5152   return 0;
5153 }
5154 _ACEOF
5155 rm -f conftest.$ac_objext
5156 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5157   (eval $ac_compile) 2>conftest.er1
5158   ac_status=$?
5159   grep -v '^ *+' conftest.er1 >conftest.err
5160   rm -f conftest.er1
5161   cat conftest.err >&5
5162   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5163   (exit $ac_status); } &&
5164          { ac_try='test -z "$ac_c_werror_flag"
5165                          || test ! -s conftest.err'
5166   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5167   (eval $ac_try) 2>&5
5168   ac_status=$?
5169   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5170   (exit $ac_status); }; } &&
5171          { ac_try='test -s conftest.$ac_objext'
5172   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5173   (eval $ac_try) 2>&5
5174   ac_status=$?
5175   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5176   (exit $ac_status); }; }; then
5177   ac_cv_sys_file_offset_bits=64; break
5178 else
5179   echo "$as_me: failed program was:" >&5
5180 sed 's/^/| /' conftest.$ac_ext >&5
5181
5182 fi
5183 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5184   break
5185 done
5186 fi
5187 echo "$as_me:$LINENO: result: $ac_cv_sys_file_offset_bits" >&5
5188 echo "${ECHO_T}$ac_cv_sys_file_offset_bits" >&6
5189 if test "$ac_cv_sys_file_offset_bits" != no; then
5190
5191 cat >>confdefs.h <<_ACEOF
5192 #define _FILE_OFFSET_BITS $ac_cv_sys_file_offset_bits
5193 _ACEOF
5194
5195 fi
5196 rm -f conftest*
5197   echo "$as_me:$LINENO: checking for _LARGE_FILES value needed for large files" >&5
5198 echo $ECHO_N "checking for _LARGE_FILES value needed for large files... $ECHO_C" >&6
5199 if test "${ac_cv_sys_large_files+set}" = set; then
5200   echo $ECHO_N "(cached) $ECHO_C" >&6
5201 else
5202   while :; do
5203   ac_cv_sys_large_files=no
5204   cat >conftest.$ac_ext <<_ACEOF
5205 /* confdefs.h.  */
5206 _ACEOF
5207 cat confdefs.h >>conftest.$ac_ext
5208 cat >>conftest.$ac_ext <<_ACEOF
5209 /* end confdefs.h.  */
5210 #include <sys/types.h>
5211  /* Check that off_t can represent 2**63 - 1 correctly.
5212     We can't simply define LARGE_OFF_T to be 9223372036854775807,
5213     since some C++ compilers masquerading as C compilers
5214     incorrectly reject 9223372036854775807.  */
5215 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5216   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5217                        && LARGE_OFF_T % 2147483647 == 1)
5218                       ? 1 : -1];
5219 int
5220 main ()
5221 {
5222
5223   ;
5224   return 0;
5225 }
5226 _ACEOF
5227 rm -f conftest.$ac_objext
5228 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5229   (eval $ac_compile) 2>conftest.er1
5230   ac_status=$?
5231   grep -v '^ *+' conftest.er1 >conftest.err
5232   rm -f conftest.er1
5233   cat conftest.err >&5
5234   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5235   (exit $ac_status); } &&
5236          { ac_try='test -z "$ac_c_werror_flag"
5237                          || test ! -s conftest.err'
5238   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5239   (eval $ac_try) 2>&5
5240   ac_status=$?
5241   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5242   (exit $ac_status); }; } &&
5243          { ac_try='test -s conftest.$ac_objext'
5244   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5245   (eval $ac_try) 2>&5
5246   ac_status=$?
5247   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5248   (exit $ac_status); }; }; then
5249   break
5250 else
5251   echo "$as_me: failed program was:" >&5
5252 sed 's/^/| /' conftest.$ac_ext >&5
5253
5254 fi
5255 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5256   cat >conftest.$ac_ext <<_ACEOF
5257 /* confdefs.h.  */
5258 _ACEOF
5259 cat confdefs.h >>conftest.$ac_ext
5260 cat >>conftest.$ac_ext <<_ACEOF
5261 /* end confdefs.h.  */
5262 #define _LARGE_FILES 1
5263 #include <sys/types.h>
5264  /* Check that off_t can represent 2**63 - 1 correctly.
5265     We can't simply define LARGE_OFF_T to be 9223372036854775807,
5266     since some C++ compilers masquerading as C compilers
5267     incorrectly reject 9223372036854775807.  */
5268 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5269   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5270                        && LARGE_OFF_T % 2147483647 == 1)
5271                       ? 1 : -1];
5272 int
5273 main ()
5274 {
5275
5276   ;
5277   return 0;
5278 }
5279 _ACEOF
5280 rm -f conftest.$ac_objext
5281 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5282   (eval $ac_compile) 2>conftest.er1
5283   ac_status=$?
5284   grep -v '^ *+' conftest.er1 >conftest.err
5285   rm -f conftest.er1
5286   cat conftest.err >&5
5287   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5288   (exit $ac_status); } &&
5289          { ac_try='test -z "$ac_c_werror_flag"
5290                          || test ! -s conftest.err'
5291   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5292   (eval $ac_try) 2>&5
5293   ac_status=$?
5294   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5295   (exit $ac_status); }; } &&
5296          { ac_try='test -s conftest.$ac_objext'
5297   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5298   (eval $ac_try) 2>&5
5299   ac_status=$?
5300   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5301   (exit $ac_status); }; }; then
5302   ac_cv_sys_large_files=1; break
5303 else
5304   echo "$as_me: failed program was:" >&5
5305 sed 's/^/| /' conftest.$ac_ext >&5
5306
5307 fi
5308 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5309   break
5310 done
5311 fi
5312 echo "$as_me:$LINENO: result: $ac_cv_sys_large_files" >&5
5313 echo "${ECHO_T}$ac_cv_sys_large_files" >&6
5314 if test "$ac_cv_sys_large_files" != no; then
5315
5316 cat >>confdefs.h <<_ACEOF
5317 #define _LARGE_FILES $ac_cv_sys_large_files
5318 _ACEOF
5319
5320 fi
5321 rm -f conftest*
5322 fi
5323
5324 ac_ext=c
5325 ac_cpp='$CPP $CPPFLAGS'
5326 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5327 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5328 ac_compiler_gnu=$ac_cv_c_compiler_gnu
5329 echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
5330 echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
5331 # On Suns, sometimes $CPP names a directory.
5332 if test -n "$CPP" && test -d "$CPP"; then
5333   CPP=
5334 fi
5335 if test -z "$CPP"; then
5336   if test "${ac_cv_prog_CPP+set}" = set; then
5337   echo $ECHO_N "(cached) $ECHO_C" >&6
5338 else
5339       # Double quotes because CPP needs to be expanded
5340     for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
5341     do
5342       ac_preproc_ok=false
5343 for ac_c_preproc_warn_flag in '' yes
5344 do
5345   # Use a header file that comes with gcc, so configuring glibc
5346   # with a fresh cross-compiler works.
5347   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5348   # <limits.h> exists even on freestanding compilers.
5349   # On the NeXT, cc -E runs the code through the compiler's parser,
5350   # not just through cpp. "Syntax error" is here to catch this case.
5351   cat >conftest.$ac_ext <<_ACEOF
5352 /* confdefs.h.  */
5353 _ACEOF
5354 cat confdefs.h >>conftest.$ac_ext
5355 cat >>conftest.$ac_ext <<_ACEOF
5356 /* end confdefs.h.  */
5357 #ifdef __STDC__
5358 # include <limits.h>
5359 #else
5360 # include <assert.h>
5361 #endif
5362                      Syntax error
5363 _ACEOF
5364 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5365   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5366   ac_status=$?
5367   grep -v '^ *+' conftest.er1 >conftest.err
5368   rm -f conftest.er1
5369   cat conftest.err >&5
5370   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5371   (exit $ac_status); } >/dev/null; then
5372   if test -s conftest.err; then
5373     ac_cpp_err=$ac_c_preproc_warn_flag
5374     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5375   else
5376     ac_cpp_err=
5377   fi
5378 else
5379   ac_cpp_err=yes
5380 fi
5381 if test -z "$ac_cpp_err"; then
5382   :
5383 else
5384   echo "$as_me: failed program was:" >&5
5385 sed 's/^/| /' conftest.$ac_ext >&5
5386
5387   # Broken: fails on valid input.
5388 continue
5389 fi
5390 rm -f conftest.err conftest.$ac_ext
5391
5392   # OK, works on sane cases.  Now check whether non-existent headers
5393   # can be detected and how.
5394   cat >conftest.$ac_ext <<_ACEOF
5395 /* confdefs.h.  */
5396 _ACEOF
5397 cat confdefs.h >>conftest.$ac_ext
5398 cat >>conftest.$ac_ext <<_ACEOF
5399 /* end confdefs.h.  */
5400 #include <ac_nonexistent.h>
5401 _ACEOF
5402 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5403   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5404   ac_status=$?
5405   grep -v '^ *+' conftest.er1 >conftest.err
5406   rm -f conftest.er1
5407   cat conftest.err >&5
5408   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5409   (exit $ac_status); } >/dev/null; then
5410   if test -s conftest.err; then
5411     ac_cpp_err=$ac_c_preproc_warn_flag
5412     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5413   else
5414     ac_cpp_err=
5415   fi
5416 else
5417   ac_cpp_err=yes
5418 fi
5419 if test -z "$ac_cpp_err"; then
5420   # Broken: success on invalid input.
5421 continue
5422 else
5423   echo "$as_me: failed program was:" >&5
5424 sed 's/^/| /' conftest.$ac_ext >&5
5425
5426   # Passes both tests.
5427 ac_preproc_ok=:
5428 break
5429 fi
5430 rm -f conftest.err conftest.$ac_ext
5431
5432 done
5433 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5434 rm -f conftest.err conftest.$ac_ext
5435 if $ac_preproc_ok; then
5436   break
5437 fi
5438
5439     done
5440     ac_cv_prog_CPP=$CPP
5441
5442 fi
5443   CPP=$ac_cv_prog_CPP
5444 else
5445   ac_cv_prog_CPP=$CPP
5446 fi
5447 echo "$as_me:$LINENO: result: $CPP" >&5
5448 echo "${ECHO_T}$CPP" >&6
5449 ac_preproc_ok=false
5450 for ac_c_preproc_warn_flag in '' yes
5451 do
5452   # Use a header file that comes with gcc, so configuring glibc
5453   # with a fresh cross-compiler works.
5454   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5455   # <limits.h> exists even on freestanding compilers.
5456   # On the NeXT, cc -E runs the code through the compiler's parser,
5457   # not just through cpp. "Syntax error" is here to catch this case.
5458   cat >conftest.$ac_ext <<_ACEOF
5459 /* confdefs.h.  */
5460 _ACEOF
5461 cat confdefs.h >>conftest.$ac_ext
5462 cat >>conftest.$ac_ext <<_ACEOF
5463 /* end confdefs.h.  */
5464 #ifdef __STDC__
5465 # include <limits.h>
5466 #else
5467 # include <assert.h>
5468 #endif
5469                      Syntax error
5470 _ACEOF
5471 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5472   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5473   ac_status=$?
5474   grep -v '^ *+' conftest.er1 >conftest.err
5475   rm -f conftest.er1
5476   cat conftest.err >&5
5477   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5478   (exit $ac_status); } >/dev/null; then
5479   if test -s conftest.err; then
5480     ac_cpp_err=$ac_c_preproc_warn_flag
5481     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5482   else
5483     ac_cpp_err=
5484   fi
5485 else
5486   ac_cpp_err=yes
5487 fi
5488 if test -z "$ac_cpp_err"; then
5489   :
5490 else
5491   echo "$as_me: failed program was:" >&5
5492 sed 's/^/| /' conftest.$ac_ext >&5
5493
5494   # Broken: fails on valid input.
5495 continue
5496 fi
5497 rm -f conftest.err conftest.$ac_ext
5498
5499   # OK, works on sane cases.  Now check whether non-existent headers
5500   # can be detected and how.
5501   cat >conftest.$ac_ext <<_ACEOF
5502 /* confdefs.h.  */
5503 _ACEOF
5504 cat confdefs.h >>conftest.$ac_ext
5505 cat >>conftest.$ac_ext <<_ACEOF
5506 /* end confdefs.h.  */
5507 #include <ac_nonexistent.h>
5508 _ACEOF
5509 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5510   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5511   ac_status=$?
5512   grep -v '^ *+' conftest.er1 >conftest.err
5513   rm -f conftest.er1
5514   cat conftest.err >&5
5515   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5516   (exit $ac_status); } >/dev/null; then
5517   if test -s conftest.err; then
5518     ac_cpp_err=$ac_c_preproc_warn_flag
5519     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5520   else
5521     ac_cpp_err=
5522   fi
5523 else
5524   ac_cpp_err=yes
5525 fi
5526 if test -z "$ac_cpp_err"; then
5527   # Broken: success on invalid input.
5528 continue
5529 else
5530   echo "$as_me: failed program was:" >&5
5531 sed 's/^/| /' conftest.$ac_ext >&5
5532
5533   # Passes both tests.
5534 ac_preproc_ok=:
5535 break
5536 fi
5537 rm -f conftest.err conftest.$ac_ext
5538
5539 done
5540 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5541 rm -f conftest.err conftest.$ac_ext
5542 if $ac_preproc_ok; then
5543   :
5544 else
5545   { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
5546 See \`config.log' for more details." >&5
5547 echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
5548 See \`config.log' for more details." >&2;}
5549    { (exit 1); exit 1; }; }
5550 fi
5551
5552 ac_ext=c
5553 ac_cpp='$CPP $CPPFLAGS'
5554 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5555 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5556 ac_compiler_gnu=$ac_cv_c_compiler_gnu
5557
5558
5559 echo "$as_me:$LINENO: checking for egrep" >&5
5560 echo $ECHO_N "checking for egrep... $ECHO_C" >&6
5561 if test "${ac_cv_prog_egrep+set}" = set; then
5562   echo $ECHO_N "(cached) $ECHO_C" >&6
5563 else
5564   if echo a | (grep -E '(a|b)') >/dev/null 2>&1
5565     then ac_cv_prog_egrep='grep -E'
5566     else ac_cv_prog_egrep='egrep'
5567     fi
5568 fi
5569 echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
5570 echo "${ECHO_T}$ac_cv_prog_egrep" >&6
5571  EGREP=$ac_cv_prog_egrep
5572
5573
5574 echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5575 echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5576 if test "${ac_cv_header_stdc+set}" = set; then
5577   echo $ECHO_N "(cached) $ECHO_C" >&6
5578 else
5579   cat >conftest.$ac_ext <<_ACEOF
5580 /* confdefs.h.  */
5581 _ACEOF
5582 cat confdefs.h >>conftest.$ac_ext
5583 cat >>conftest.$ac_ext <<_ACEOF
5584 /* end confdefs.h.  */
5585 #include <stdlib.h>
5586 #include <stdarg.h>
5587 #include <string.h>
5588 #include <float.h>
5589
5590 int
5591 main ()
5592 {
5593
5594   ;
5595   return 0;
5596 }
5597 _ACEOF
5598 rm -f conftest.$ac_objext
5599 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5600   (eval $ac_compile) 2>conftest.er1
5601   ac_status=$?
5602   grep -v '^ *+' conftest.er1 >conftest.err
5603   rm -f conftest.er1
5604   cat conftest.err >&5
5605   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5606   (exit $ac_status); } &&
5607          { ac_try='test -z "$ac_c_werror_flag"
5608                          || test ! -s conftest.err'
5609   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5610   (eval $ac_try) 2>&5
5611   ac_status=$?
5612   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5613   (exit $ac_status); }; } &&
5614          { ac_try='test -s conftest.$ac_objext'
5615   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5616   (eval $ac_try) 2>&5
5617   ac_status=$?
5618   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5619   (exit $ac_status); }; }; then
5620   ac_cv_header_stdc=yes
5621 else
5622   echo "$as_me: failed program was:" >&5
5623 sed 's/^/| /' conftest.$ac_ext >&5
5624
5625 ac_cv_header_stdc=no
5626 fi
5627 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5628
5629 if test $ac_cv_header_stdc = yes; then
5630   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5631   cat >conftest.$ac_ext <<_ACEOF
5632 /* confdefs.h.  */
5633 _ACEOF
5634 cat confdefs.h >>conftest.$ac_ext
5635 cat >>conftest.$ac_ext <<_ACEOF
5636 /* end confdefs.h.  */
5637 #include <string.h>
5638
5639 _ACEOF
5640 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5641   $EGREP "memchr" >/dev/null 2>&1; then
5642   :
5643 else
5644   ac_cv_header_stdc=no
5645 fi
5646 rm -f conftest*
5647
5648 fi
5649
5650 if test $ac_cv_header_stdc = yes; then
5651   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5652   cat >conftest.$ac_ext <<_ACEOF
5653 /* confdefs.h.  */
5654 _ACEOF
5655 cat confdefs.h >>conftest.$ac_ext
5656 cat >>conftest.$ac_ext <<_ACEOF
5657 /* end confdefs.h.  */
5658 #include <stdlib.h>
5659
5660 _ACEOF
5661 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5662   $EGREP "free" >/dev/null 2>&1; then
5663   :
5664 else
5665   ac_cv_header_stdc=no
5666 fi
5667 rm -f conftest*
5668
5669 fi
5670
5671 if test $ac_cv_header_stdc = yes; then
5672   # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5673   if test "$cross_compiling" = yes; then
5674   :
5675 else
5676   cat >conftest.$ac_ext <<_ACEOF
5677 /* confdefs.h.  */
5678 _ACEOF
5679 cat confdefs.h >>conftest.$ac_ext
5680 cat >>conftest.$ac_ext <<_ACEOF
5681 /* end confdefs.h.  */
5682 #include <ctype.h>
5683 #if ((' ' & 0x0FF) == 0x020)
5684 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5685 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5686 #else
5687 # define ISLOWER(c) \
5688                    (('a' <= (c) && (c) <= 'i') \
5689                      || ('j' <= (c) && (c) <= 'r') \
5690                      || ('s' <= (c) && (c) <= 'z'))
5691 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5692 #endif
5693
5694 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5695 int
5696 main ()
5697 {
5698   int i;
5699   for (i = 0; i < 256; i++)
5700     if (XOR (islower (i), ISLOWER (i))
5701         || toupper (i) != TOUPPER (i))
5702       exit(2);
5703   exit (0);
5704 }
5705 _ACEOF
5706 rm -f conftest$ac_exeext
5707 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5708   (eval $ac_link) 2>&5
5709   ac_status=$?
5710   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5711   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5712   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5713   (eval $ac_try) 2>&5
5714   ac_status=$?
5715   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5716   (exit $ac_status); }; }; then
5717   :
5718 else
5719   echo "$as_me: program exited with status $ac_status" >&5
5720 echo "$as_me: failed program was:" >&5
5721 sed 's/^/| /' conftest.$ac_ext >&5
5722
5723 ( exit $ac_status )
5724 ac_cv_header_stdc=no
5725 fi
5726 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5727 fi
5728 fi
5729 fi
5730 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5731 echo "${ECHO_T}$ac_cv_header_stdc" >&6
5732 if test $ac_cv_header_stdc = yes; then
5733
5734 cat >>confdefs.h <<\_ACEOF
5735 #define STDC_HEADERS 1
5736 _ACEOF
5737
5738 fi
5739
5740 # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5741
5742
5743
5744
5745
5746
5747
5748
5749
5750 for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5751                   inttypes.h stdint.h unistd.h
5752 do
5753 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5754 echo "$as_me:$LINENO: checking for $ac_header" >&5
5755 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5756 if eval "test \"\${$as_ac_Header+set}\" = set"; then
5757   echo $ECHO_N "(cached) $ECHO_C" >&6
5758 else
5759   cat >conftest.$ac_ext <<_ACEOF
5760 /* confdefs.h.  */
5761 _ACEOF
5762 cat confdefs.h >>conftest.$ac_ext
5763 cat >>conftest.$ac_ext <<_ACEOF
5764 /* end confdefs.h.  */
5765 $ac_includes_default
5766
5767 #include <$ac_header>
5768 _ACEOF
5769 rm -f conftest.$ac_objext
5770 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5771   (eval $ac_compile) 2>conftest.er1
5772   ac_status=$?
5773   grep -v '^ *+' conftest.er1 >conftest.err
5774   rm -f conftest.er1
5775   cat conftest.err >&5
5776   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5777   (exit $ac_status); } &&
5778          { ac_try='test -z "$ac_c_werror_flag"
5779                          || test ! -s conftest.err'
5780   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5781   (eval $ac_try) 2>&5
5782   ac_status=$?
5783   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5784   (exit $ac_status); }; } &&
5785          { ac_try='test -s conftest.$ac_objext'
5786   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5787   (eval $ac_try) 2>&5
5788   ac_status=$?
5789   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5790   (exit $ac_status); }; }; then
5791   eval "$as_ac_Header=yes"
5792 else
5793   echo "$as_me: failed program was:" >&5
5794 sed 's/^/| /' conftest.$ac_ext >&5
5795
5796 eval "$as_ac_Header=no"
5797 fi
5798 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5799 fi
5800 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5801 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5802 if test `eval echo '${'$as_ac_Header'}'` = yes; then
5803   cat >>confdefs.h <<_ACEOF
5804 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5805 _ACEOF
5806
5807 fi
5808
5809 done
5810
5811
5812 echo "$as_me:$LINENO: checking for off_t" >&5
5813 echo $ECHO_N "checking for off_t... $ECHO_C" >&6
5814 if test "${ac_cv_type_off_t+set}" = set; then
5815   echo $ECHO_N "(cached) $ECHO_C" >&6
5816 else
5817   cat >conftest.$ac_ext <<_ACEOF
5818 /* confdefs.h.  */
5819 _ACEOF
5820 cat confdefs.h >>conftest.$ac_ext
5821 cat >>conftest.$ac_ext <<_ACEOF
5822 /* end confdefs.h.  */
5823 $ac_includes_default
5824 int
5825 main ()
5826 {
5827 if ((off_t *) 0)
5828   return 0;
5829 if (sizeof (off_t))
5830   return 0;
5831   ;
5832   return 0;
5833 }
5834 _ACEOF
5835 rm -f conftest.$ac_objext
5836 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5837   (eval $ac_compile) 2>conftest.er1
5838   ac_status=$?
5839   grep -v '^ *+' conftest.er1 >conftest.err
5840   rm -f conftest.er1
5841   cat conftest.err >&5
5842   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5843   (exit $ac_status); } &&
5844          { ac_try='test -z "$ac_c_werror_flag"
5845                          || test ! -s conftest.err'
5846   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5847   (eval $ac_try) 2>&5
5848   ac_status=$?
5849   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5850   (exit $ac_status); }; } &&
5851          { ac_try='test -s conftest.$ac_objext'
5852   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5853   (eval $ac_try) 2>&5
5854   ac_status=$?
5855   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5856   (exit $ac_status); }; }; then
5857   ac_cv_type_off_t=yes
5858 else
5859   echo "$as_me: failed program was:" >&5
5860 sed 's/^/| /' conftest.$ac_ext >&5
5861
5862 ac_cv_type_off_t=no
5863 fi
5864 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5865 fi
5866 echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5
5867 echo "${ECHO_T}$ac_cv_type_off_t" >&6
5868 if test $ac_cv_type_off_t = yes; then
5869   :
5870 else
5871
5872 cat >>confdefs.h <<_ACEOF
5873 #define off_t long
5874 _ACEOF
5875
5876 fi
5877
5878
5879 # check header files
5880 echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5881 echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5882 if test "${ac_cv_header_stdc+set}" = set; then
5883   echo $ECHO_N "(cached) $ECHO_C" >&6
5884 else
5885   cat >conftest.$ac_ext <<_ACEOF
5886 /* confdefs.h.  */
5887 _ACEOF
5888 cat confdefs.h >>conftest.$ac_ext
5889 cat >>conftest.$ac_ext <<_ACEOF
5890 /* end confdefs.h.  */
5891 #include <stdlib.h>
5892 #include <stdarg.h>
5893 #include <string.h>
5894 #include <float.h>
5895
5896 int
5897 main ()
5898 {
5899
5900   ;
5901   return 0;
5902 }
5903 _ACEOF
5904 rm -f conftest.$ac_objext
5905 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5906   (eval $ac_compile) 2>conftest.er1
5907   ac_status=$?
5908   grep -v '^ *+' conftest.er1 >conftest.err
5909   rm -f conftest.er1
5910   cat conftest.err >&5
5911   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5912   (exit $ac_status); } &&
5913          { ac_try='test -z "$ac_c_werror_flag"
5914                          || test ! -s conftest.err'
5915   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5916   (eval $ac_try) 2>&5
5917   ac_status=$?
5918   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5919   (exit $ac_status); }; } &&
5920          { ac_try='test -s conftest.$ac_objext'
5921   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5922   (eval $ac_try) 2>&5
5923   ac_status=$?
5924   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5925   (exit $ac_status); }; }; then
5926   ac_cv_header_stdc=yes
5927 else
5928   echo "$as_me: failed program was:" >&5
5929 sed 's/^/| /' conftest.$ac_ext >&5
5930
5931 ac_cv_header_stdc=no
5932 fi
5933 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5934
5935 if test $ac_cv_header_stdc = yes; then
5936   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5937   cat >conftest.$ac_ext <<_ACEOF
5938 /* confdefs.h.  */
5939 _ACEOF
5940 cat confdefs.h >>conftest.$ac_ext
5941 cat >>conftest.$ac_ext <<_ACEOF
5942 /* end confdefs.h.  */
5943 #include <string.h>
5944
5945 _ACEOF
5946 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5947   $EGREP "memchr" >/dev/null 2>&1; then
5948   :
5949 else
5950   ac_cv_header_stdc=no
5951 fi
5952 rm -f conftest*
5953
5954 fi
5955
5956 if test $ac_cv_header_stdc = yes; then
5957   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5958   cat >conftest.$ac_ext <<_ACEOF
5959 /* confdefs.h.  */
5960 _ACEOF
5961 cat confdefs.h >>conftest.$ac_ext
5962 cat >>conftest.$ac_ext <<_ACEOF
5963 /* end confdefs.h.  */
5964 #include <stdlib.h>
5965
5966 _ACEOF
5967 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5968   $EGREP "free" >/dev/null 2>&1; then
5969   :
5970 else
5971   ac_cv_header_stdc=no
5972 fi
5973 rm -f conftest*
5974
5975 fi
5976
5977 if test $ac_cv_header_stdc = yes; then
5978   # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5979   if test "$cross_compiling" = yes; then
5980   :
5981 else
5982   cat >conftest.$ac_ext <<_ACEOF
5983 /* confdefs.h.  */
5984 _ACEOF
5985 cat confdefs.h >>conftest.$ac_ext
5986 cat >>conftest.$ac_ext <<_ACEOF
5987 /* end confdefs.h.  */
5988 #include <ctype.h>
5989 #if ((' ' & 0x0FF) == 0x020)
5990 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5991 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5992 #else
5993 # define ISLOWER(c) \
5994                    (('a' <= (c) && (c) <= 'i') \
5995                      || ('j' <= (c) && (c) <= 'r') \
5996                      || ('s' <= (c) && (c) <= 'z'))
5997 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5998 #endif
5999
6000 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
6001 int
6002 main ()
6003 {
6004   int i;
6005   for (i = 0; i < 256; i++)
6006     if (XOR (islower (i), ISLOWER (i))
6007         || toupper (i) != TOUPPER (i))
6008       exit(2);
6009   exit (0);
6010 }
6011 _ACEOF
6012 rm -f conftest$ac_exeext
6013 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6014   (eval $ac_link) 2>&5
6015   ac_status=$?
6016   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6017   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
6018   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6019   (eval $ac_try) 2>&5
6020   ac_status=$?
6021   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6022   (exit $ac_status); }; }; then
6023   :
6024 else
6025   echo "$as_me: program exited with status $ac_status" >&5
6026 echo "$as_me: failed program was:" >&5
6027 sed 's/^/| /' conftest.$ac_ext >&5
6028
6029 ( exit $ac_status )
6030 ac_cv_header_stdc=no
6031 fi
6032 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
6033 fi
6034 fi
6035 fi
6036 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
6037 echo "${ECHO_T}$ac_cv_header_stdc" >&6
6038 if test $ac_cv_header_stdc = yes; then
6039
6040 cat >>confdefs.h <<\_ACEOF
6041 #define STDC_HEADERS 1
6042 _ACEOF
6043
6044 fi
6045
6046 echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
6047 echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
6048 if test "${ac_cv_header_time+set}" = set; then
6049   echo $ECHO_N "(cached) $ECHO_C" >&6
6050 else
6051   cat >conftest.$ac_ext <<_ACEOF
6052 /* confdefs.h.  */
6053 _ACEOF
6054 cat confdefs.h >>conftest.$ac_ext
6055 cat >>conftest.$ac_ext <<_ACEOF
6056 /* end confdefs.h.  */
6057 #include <sys/types.h>
6058 #include <sys/time.h>
6059 #include <time.h>
6060
6061 int
6062 main ()
6063 {
6064 if ((struct tm *) 0)
6065 return 0;
6066   ;
6067   return 0;
6068 }
6069 _ACEOF
6070 rm -f conftest.$ac_objext
6071 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6072   (eval $ac_compile) 2>conftest.er1
6073   ac_status=$?
6074   grep -v '^ *+' conftest.er1 >conftest.err
6075   rm -f conftest.er1
6076   cat conftest.err >&5
6077   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6078   (exit $ac_status); } &&
6079          { ac_try='test -z "$ac_c_werror_flag"
6080                          || test ! -s conftest.err'
6081   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6082   (eval $ac_try) 2>&5
6083   ac_status=$?
6084   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6085   (exit $ac_status); }; } &&
6086          { ac_try='test -s conftest.$ac_objext'
6087   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6088   (eval $ac_try) 2>&5
6089   ac_status=$?
6090   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6091   (exit $ac_status); }; }; then
6092   ac_cv_header_time=yes
6093 else
6094   echo "$as_me: failed program was:" >&5
6095 sed 's/^/| /' conftest.$ac_ext >&5
6096
6097 ac_cv_header_time=no
6098 fi
6099 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6100 fi
6101 echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
6102 echo "${ECHO_T}$ac_cv_header_time" >&6
6103 if test $ac_cv_header_time = yes; then
6104
6105 cat >>confdefs.h <<\_ACEOF
6106 #define TIME_WITH_SYS_TIME 1
6107 _ACEOF
6108
6109 fi
6110
6111
6112
6113
6114
6115 for ac_header in stdlib.h string.h unistd.h signal.h
6116 do
6117 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6118 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6119   echo "$as_me:$LINENO: checking for $ac_header" >&5
6120 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6121 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6122   echo $ECHO_N "(cached) $ECHO_C" >&6
6123 fi
6124 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6125 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6126 else
6127   # Is the header compilable?
6128 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6129 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6130 cat >conftest.$ac_ext <<_ACEOF
6131 /* confdefs.h.  */
6132 _ACEOF
6133 cat confdefs.h >>conftest.$ac_ext
6134 cat >>conftest.$ac_ext <<_ACEOF
6135 /* end confdefs.h.  */
6136 $ac_includes_default
6137 #include <$ac_header>
6138 _ACEOF
6139 rm -f conftest.$ac_objext
6140 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6141   (eval $ac_compile) 2>conftest.er1
6142   ac_status=$?
6143   grep -v '^ *+' conftest.er1 >conftest.err
6144   rm -f conftest.er1
6145   cat conftest.err >&5
6146   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6147   (exit $ac_status); } &&
6148          { ac_try='test -z "$ac_c_werror_flag"
6149                          || test ! -s conftest.err'
6150   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6151   (eval $ac_try) 2>&5
6152   ac_status=$?
6153   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6154   (exit $ac_status); }; } &&
6155          { ac_try='test -s conftest.$ac_objext'
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); }; }; then
6161   ac_header_compiler=yes
6162 else
6163   echo "$as_me: failed program was:" >&5
6164 sed 's/^/| /' conftest.$ac_ext >&5
6165
6166 ac_header_compiler=no
6167 fi
6168 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6169 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6170 echo "${ECHO_T}$ac_header_compiler" >&6
6171
6172 # Is the header present?
6173 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6174 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6175 cat >conftest.$ac_ext <<_ACEOF
6176 /* confdefs.h.  */
6177 _ACEOF
6178 cat confdefs.h >>conftest.$ac_ext
6179 cat >>conftest.$ac_ext <<_ACEOF
6180 /* end confdefs.h.  */
6181 #include <$ac_header>
6182 _ACEOF
6183 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6184   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6185   ac_status=$?
6186   grep -v '^ *+' conftest.er1 >conftest.err
6187   rm -f conftest.er1
6188   cat conftest.err >&5
6189   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6190   (exit $ac_status); } >/dev/null; then
6191   if test -s conftest.err; then
6192     ac_cpp_err=$ac_c_preproc_warn_flag
6193     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6194   else
6195     ac_cpp_err=
6196   fi
6197 else
6198   ac_cpp_err=yes
6199 fi
6200 if test -z "$ac_cpp_err"; then
6201   ac_header_preproc=yes
6202 else
6203   echo "$as_me: failed program was:" >&5
6204 sed 's/^/| /' conftest.$ac_ext >&5
6205
6206   ac_header_preproc=no
6207 fi
6208 rm -f conftest.err conftest.$ac_ext
6209 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6210 echo "${ECHO_T}$ac_header_preproc" >&6
6211
6212 # So?  What about this header?
6213 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6214   yes:no: )
6215     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6216 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6217     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6218 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6219     ac_header_preproc=yes
6220     ;;
6221   no:yes:* )
6222     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6223 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6224     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6225 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6226     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6227 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6228     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6229 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6230     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6231 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6232     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6233 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6234     (
6235       cat <<\_ASBOX
6236 ## ------------------------------------------------------ ##
6237 ## Report this to the GNU Fortran Runtime Library lists.  ##
6238 ## ------------------------------------------------------ ##
6239 _ASBOX
6240     ) |
6241       sed "s/^/$as_me: WARNING:     /" >&2
6242     ;;
6243 esac
6244 echo "$as_me:$LINENO: checking for $ac_header" >&5
6245 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6246 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6247   echo $ECHO_N "(cached) $ECHO_C" >&6
6248 else
6249   eval "$as_ac_Header=\$ac_header_preproc"
6250 fi
6251 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6252 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6253
6254 fi
6255 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6256   cat >>confdefs.h <<_ACEOF
6257 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6258 _ACEOF
6259
6260 fi
6261
6262 done
6263
6264
6265
6266
6267
6268 for ac_header in time.h sys/time.h sys/times.h sys/resource.h
6269 do
6270 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6271 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6272   echo "$as_me:$LINENO: checking for $ac_header" >&5
6273 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6274 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6275   echo $ECHO_N "(cached) $ECHO_C" >&6
6276 fi
6277 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6278 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6279 else
6280   # Is the header compilable?
6281 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6282 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6283 cat >conftest.$ac_ext <<_ACEOF
6284 /* confdefs.h.  */
6285 _ACEOF
6286 cat confdefs.h >>conftest.$ac_ext
6287 cat >>conftest.$ac_ext <<_ACEOF
6288 /* end confdefs.h.  */
6289 $ac_includes_default
6290 #include <$ac_header>
6291 _ACEOF
6292 rm -f conftest.$ac_objext
6293 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6294   (eval $ac_compile) 2>conftest.er1
6295   ac_status=$?
6296   grep -v '^ *+' conftest.er1 >conftest.err
6297   rm -f conftest.er1
6298   cat conftest.err >&5
6299   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6300   (exit $ac_status); } &&
6301          { ac_try='test -z "$ac_c_werror_flag"
6302                          || test ! -s conftest.err'
6303   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6304   (eval $ac_try) 2>&5
6305   ac_status=$?
6306   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6307   (exit $ac_status); }; } &&
6308          { ac_try='test -s conftest.$ac_objext'
6309   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6310   (eval $ac_try) 2>&5
6311   ac_status=$?
6312   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6313   (exit $ac_status); }; }; then
6314   ac_header_compiler=yes
6315 else
6316   echo "$as_me: failed program was:" >&5
6317 sed 's/^/| /' conftest.$ac_ext >&5
6318
6319 ac_header_compiler=no
6320 fi
6321 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6322 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6323 echo "${ECHO_T}$ac_header_compiler" >&6
6324
6325 # Is the header present?
6326 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6327 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6328 cat >conftest.$ac_ext <<_ACEOF
6329 /* confdefs.h.  */
6330 _ACEOF
6331 cat confdefs.h >>conftest.$ac_ext
6332 cat >>conftest.$ac_ext <<_ACEOF
6333 /* end confdefs.h.  */
6334 #include <$ac_header>
6335 _ACEOF
6336 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6337   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6338   ac_status=$?
6339   grep -v '^ *+' conftest.er1 >conftest.err
6340   rm -f conftest.er1
6341   cat conftest.err >&5
6342   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6343   (exit $ac_status); } >/dev/null; then
6344   if test -s conftest.err; then
6345     ac_cpp_err=$ac_c_preproc_warn_flag
6346     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6347   else
6348     ac_cpp_err=
6349   fi
6350 else
6351   ac_cpp_err=yes
6352 fi
6353 if test -z "$ac_cpp_err"; then
6354   ac_header_preproc=yes
6355 else
6356   echo "$as_me: failed program was:" >&5
6357 sed 's/^/| /' conftest.$ac_ext >&5
6358
6359   ac_header_preproc=no
6360 fi
6361 rm -f conftest.err conftest.$ac_ext
6362 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6363 echo "${ECHO_T}$ac_header_preproc" >&6
6364
6365 # So?  What about this header?
6366 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6367   yes:no: )
6368     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6369 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6370     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6371 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6372     ac_header_preproc=yes
6373     ;;
6374   no:yes:* )
6375     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6376 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6377     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6378 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6379     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6380 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6381     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6382 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6383     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6384 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6385     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6386 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6387     (
6388       cat <<\_ASBOX
6389 ## ------------------------------------------------------ ##
6390 ## Report this to the GNU Fortran Runtime Library lists.  ##
6391 ## ------------------------------------------------------ ##
6392 _ASBOX
6393     ) |
6394       sed "s/^/$as_me: WARNING:     /" >&2
6395     ;;
6396 esac
6397 echo "$as_me:$LINENO: checking for $ac_header" >&5
6398 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6399 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6400   echo $ECHO_N "(cached) $ECHO_C" >&6
6401 else
6402   eval "$as_ac_Header=\$ac_header_preproc"
6403 fi
6404 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6405 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6406
6407 fi
6408 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6409   cat >>confdefs.h <<_ACEOF
6410 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6411 _ACEOF
6412
6413 fi
6414
6415 done
6416
6417
6418
6419
6420
6421
6422 for ac_header in sys/types.h sys/stat.h sys/wait.h floatingpoint.h ieeefp.h
6423 do
6424 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6425 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6426   echo "$as_me:$LINENO: checking for $ac_header" >&5
6427 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6428 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6429   echo $ECHO_N "(cached) $ECHO_C" >&6
6430 fi
6431 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6432 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6433 else
6434   # Is the header compilable?
6435 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6436 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6437 cat >conftest.$ac_ext <<_ACEOF
6438 /* confdefs.h.  */
6439 _ACEOF
6440 cat confdefs.h >>conftest.$ac_ext
6441 cat >>conftest.$ac_ext <<_ACEOF
6442 /* end confdefs.h.  */
6443 $ac_includes_default
6444 #include <$ac_header>
6445 _ACEOF
6446 rm -f conftest.$ac_objext
6447 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6448   (eval $ac_compile) 2>conftest.er1
6449   ac_status=$?
6450   grep -v '^ *+' conftest.er1 >conftest.err
6451   rm -f conftest.er1
6452   cat conftest.err >&5
6453   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6454   (exit $ac_status); } &&
6455          { ac_try='test -z "$ac_c_werror_flag"
6456                          || test ! -s conftest.err'
6457   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6458   (eval $ac_try) 2>&5
6459   ac_status=$?
6460   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6461   (exit $ac_status); }; } &&
6462          { ac_try='test -s conftest.$ac_objext'
6463   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6464   (eval $ac_try) 2>&5
6465   ac_status=$?
6466   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6467   (exit $ac_status); }; }; then
6468   ac_header_compiler=yes
6469 else
6470   echo "$as_me: failed program was:" >&5
6471 sed 's/^/| /' conftest.$ac_ext >&5
6472
6473 ac_header_compiler=no
6474 fi
6475 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6476 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6477 echo "${ECHO_T}$ac_header_compiler" >&6
6478
6479 # Is the header present?
6480 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6481 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6482 cat >conftest.$ac_ext <<_ACEOF
6483 /* confdefs.h.  */
6484 _ACEOF
6485 cat confdefs.h >>conftest.$ac_ext
6486 cat >>conftest.$ac_ext <<_ACEOF
6487 /* end confdefs.h.  */
6488 #include <$ac_header>
6489 _ACEOF
6490 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6491   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6492   ac_status=$?
6493   grep -v '^ *+' conftest.er1 >conftest.err
6494   rm -f conftest.er1
6495   cat conftest.err >&5
6496   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6497   (exit $ac_status); } >/dev/null; then
6498   if test -s conftest.err; then
6499     ac_cpp_err=$ac_c_preproc_warn_flag
6500     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6501   else
6502     ac_cpp_err=
6503   fi
6504 else
6505   ac_cpp_err=yes
6506 fi
6507 if test -z "$ac_cpp_err"; then
6508   ac_header_preproc=yes
6509 else
6510   echo "$as_me: failed program was:" >&5
6511 sed 's/^/| /' conftest.$ac_ext >&5
6512
6513   ac_header_preproc=no
6514 fi
6515 rm -f conftest.err conftest.$ac_ext
6516 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6517 echo "${ECHO_T}$ac_header_preproc" >&6
6518
6519 # So?  What about this header?
6520 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6521   yes:no: )
6522     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6523 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6524     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6525 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6526     ac_header_preproc=yes
6527     ;;
6528   no:yes:* )
6529     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6530 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6531     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6532 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6533     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6534 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6535     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6536 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6537     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6538 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6539     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6540 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6541     (
6542       cat <<\_ASBOX
6543 ## ------------------------------------------------------ ##
6544 ## Report this to the GNU Fortran Runtime Library lists.  ##
6545 ## ------------------------------------------------------ ##
6546 _ASBOX
6547     ) |
6548       sed "s/^/$as_me: WARNING:     /" >&2
6549     ;;
6550 esac
6551 echo "$as_me:$LINENO: checking for $ac_header" >&5
6552 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6553 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6554   echo $ECHO_N "(cached) $ECHO_C" >&6
6555 else
6556   eval "$as_ac_Header=\$ac_header_preproc"
6557 fi
6558 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6559 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6560
6561 fi
6562 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6563   cat >>confdefs.h <<_ACEOF
6564 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6565 _ACEOF
6566
6567 fi
6568
6569 done
6570
6571
6572
6573
6574
6575 for ac_header in fenv.h fptrap.h float.h execinfo.h
6576 do
6577 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6578 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6579   echo "$as_me:$LINENO: checking for $ac_header" >&5
6580 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6581 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6582   echo $ECHO_N "(cached) $ECHO_C" >&6
6583 fi
6584 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6585 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6586 else
6587   # Is the header compilable?
6588 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6589 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6590 cat >conftest.$ac_ext <<_ACEOF
6591 /* confdefs.h.  */
6592 _ACEOF
6593 cat confdefs.h >>conftest.$ac_ext
6594 cat >>conftest.$ac_ext <<_ACEOF
6595 /* end confdefs.h.  */
6596 $ac_includes_default
6597 #include <$ac_header>
6598 _ACEOF
6599 rm -f conftest.$ac_objext
6600 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6601   (eval $ac_compile) 2>conftest.er1
6602   ac_status=$?
6603   grep -v '^ *+' conftest.er1 >conftest.err
6604   rm -f conftest.er1
6605   cat conftest.err >&5
6606   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6607   (exit $ac_status); } &&
6608          { ac_try='test -z "$ac_c_werror_flag"
6609                          || test ! -s conftest.err'
6610   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6611   (eval $ac_try) 2>&5
6612   ac_status=$?
6613   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6614   (exit $ac_status); }; } &&
6615          { ac_try='test -s conftest.$ac_objext'
6616   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6617   (eval $ac_try) 2>&5
6618   ac_status=$?
6619   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6620   (exit $ac_status); }; }; then
6621   ac_header_compiler=yes
6622 else
6623   echo "$as_me: failed program was:" >&5
6624 sed 's/^/| /' conftest.$ac_ext >&5
6625
6626 ac_header_compiler=no
6627 fi
6628 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6629 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6630 echo "${ECHO_T}$ac_header_compiler" >&6
6631
6632 # Is the header present?
6633 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6634 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6635 cat >conftest.$ac_ext <<_ACEOF
6636 /* confdefs.h.  */
6637 _ACEOF
6638 cat confdefs.h >>conftest.$ac_ext
6639 cat >>conftest.$ac_ext <<_ACEOF
6640 /* end confdefs.h.  */
6641 #include <$ac_header>
6642 _ACEOF
6643 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6644   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6645   ac_status=$?
6646   grep -v '^ *+' conftest.er1 >conftest.err
6647   rm -f conftest.er1
6648   cat conftest.err >&5
6649   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6650   (exit $ac_status); } >/dev/null; then
6651   if test -s conftest.err; then
6652     ac_cpp_err=$ac_c_preproc_warn_flag
6653     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6654   else
6655     ac_cpp_err=
6656   fi
6657 else
6658   ac_cpp_err=yes
6659 fi
6660 if test -z "$ac_cpp_err"; then
6661   ac_header_preproc=yes
6662 else
6663   echo "$as_me: failed program was:" >&5
6664 sed 's/^/| /' conftest.$ac_ext >&5
6665
6666   ac_header_preproc=no
6667 fi
6668 rm -f conftest.err conftest.$ac_ext
6669 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6670 echo "${ECHO_T}$ac_header_preproc" >&6
6671
6672 # So?  What about this header?
6673 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6674   yes:no: )
6675     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6676 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6677     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6678 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6679     ac_header_preproc=yes
6680     ;;
6681   no:yes:* )
6682     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6683 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6684     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6685 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6686     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6687 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6688     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6689 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6690     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6691 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6692     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6693 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6694     (
6695       cat <<\_ASBOX
6696 ## ------------------------------------------------------ ##
6697 ## Report this to the GNU Fortran Runtime Library lists.  ##
6698 ## ------------------------------------------------------ ##
6699 _ASBOX
6700     ) |
6701       sed "s/^/$as_me: WARNING:     /" >&2
6702     ;;
6703 esac
6704 echo "$as_me:$LINENO: checking for $ac_header" >&5
6705 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6706 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6707   echo $ECHO_N "(cached) $ECHO_C" >&6
6708 else
6709   eval "$as_ac_Header=\$ac_header_preproc"
6710 fi
6711 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6712 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6713
6714 fi
6715 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6716   cat >>confdefs.h <<_ACEOF
6717 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6718 _ACEOF
6719
6720 fi
6721
6722 done
6723
6724 if test "${ac_cv_header_complex_h+set}" = set; then
6725   echo "$as_me:$LINENO: checking for complex.h" >&5
6726 echo $ECHO_N "checking for complex.h... $ECHO_C" >&6
6727 if test "${ac_cv_header_complex_h+set}" = set; then
6728   echo $ECHO_N "(cached) $ECHO_C" >&6
6729 fi
6730 echo "$as_me:$LINENO: result: $ac_cv_header_complex_h" >&5
6731 echo "${ECHO_T}$ac_cv_header_complex_h" >&6
6732 else
6733   # Is the header compilable?
6734 echo "$as_me:$LINENO: checking complex.h usability" >&5
6735 echo $ECHO_N "checking complex.h usability... $ECHO_C" >&6
6736 cat >conftest.$ac_ext <<_ACEOF
6737 /* confdefs.h.  */
6738 _ACEOF
6739 cat confdefs.h >>conftest.$ac_ext
6740 cat >>conftest.$ac_ext <<_ACEOF
6741 /* end confdefs.h.  */
6742 $ac_includes_default
6743 #include <complex.h>
6744 _ACEOF
6745 rm -f conftest.$ac_objext
6746 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6747   (eval $ac_compile) 2>conftest.er1
6748   ac_status=$?
6749   grep -v '^ *+' conftest.er1 >conftest.err
6750   rm -f conftest.er1
6751   cat conftest.err >&5
6752   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6753   (exit $ac_status); } &&
6754          { ac_try='test -z "$ac_c_werror_flag"
6755                          || test ! -s conftest.err'
6756   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6757   (eval $ac_try) 2>&5
6758   ac_status=$?
6759   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6760   (exit $ac_status); }; } &&
6761          { ac_try='test -s conftest.$ac_objext'
6762   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6763   (eval $ac_try) 2>&5
6764   ac_status=$?
6765   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6766   (exit $ac_status); }; }; then
6767   ac_header_compiler=yes
6768 else
6769   echo "$as_me: failed program was:" >&5
6770 sed 's/^/| /' conftest.$ac_ext >&5
6771
6772 ac_header_compiler=no
6773 fi
6774 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6775 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6776 echo "${ECHO_T}$ac_header_compiler" >&6
6777
6778 # Is the header present?
6779 echo "$as_me:$LINENO: checking complex.h presence" >&5
6780 echo $ECHO_N "checking complex.h presence... $ECHO_C" >&6
6781 cat >conftest.$ac_ext <<_ACEOF
6782 /* confdefs.h.  */
6783 _ACEOF
6784 cat confdefs.h >>conftest.$ac_ext
6785 cat >>conftest.$ac_ext <<_ACEOF
6786 /* end confdefs.h.  */
6787 #include <complex.h>
6788 _ACEOF
6789 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6790   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6791   ac_status=$?
6792   grep -v '^ *+' conftest.er1 >conftest.err
6793   rm -f conftest.er1
6794   cat conftest.err >&5
6795   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6796   (exit $ac_status); } >/dev/null; then
6797   if test -s conftest.err; then
6798     ac_cpp_err=$ac_c_preproc_warn_flag
6799     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6800   else
6801     ac_cpp_err=
6802   fi
6803 else
6804   ac_cpp_err=yes
6805 fi
6806 if test -z "$ac_cpp_err"; then
6807   ac_header_preproc=yes
6808 else
6809   echo "$as_me: failed program was:" >&5
6810 sed 's/^/| /' conftest.$ac_ext >&5
6811
6812   ac_header_preproc=no
6813 fi
6814 rm -f conftest.err conftest.$ac_ext
6815 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6816 echo "${ECHO_T}$ac_header_preproc" >&6
6817
6818 # So?  What about this header?
6819 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6820   yes:no: )
6821     { echo "$as_me:$LINENO: WARNING: complex.h: accepted by the compiler, rejected by the preprocessor!" >&5
6822 echo "$as_me: WARNING: complex.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6823     { echo "$as_me:$LINENO: WARNING: complex.h: proceeding with the compiler's result" >&5
6824 echo "$as_me: WARNING: complex.h: proceeding with the compiler's result" >&2;}
6825     ac_header_preproc=yes
6826     ;;
6827   no:yes:* )
6828     { echo "$as_me:$LINENO: WARNING: complex.h: present but cannot be compiled" >&5
6829 echo "$as_me: WARNING: complex.h: present but cannot be compiled" >&2;}
6830     { echo "$as_me:$LINENO: WARNING: complex.h:     check for missing prerequisite headers?" >&5
6831 echo "$as_me: WARNING: complex.h:     check for missing prerequisite headers?" >&2;}
6832     { echo "$as_me:$LINENO: WARNING: complex.h: see the Autoconf documentation" >&5
6833 echo "$as_me: WARNING: complex.h: see the Autoconf documentation" >&2;}
6834     { echo "$as_me:$LINENO: WARNING: complex.h:     section \"Present But Cannot Be Compiled\"" >&5
6835 echo "$as_me: WARNING: complex.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6836     { echo "$as_me:$LINENO: WARNING: complex.h: proceeding with the preprocessor's result" >&5
6837 echo "$as_me: WARNING: complex.h: proceeding with the preprocessor's result" >&2;}
6838     { echo "$as_me:$LINENO: WARNING: complex.h: in the future, the compiler will take precedence" >&5
6839 echo "$as_me: WARNING: complex.h: in the future, the compiler will take precedence" >&2;}
6840     (
6841       cat <<\_ASBOX
6842 ## ------------------------------------------------------ ##
6843 ## Report this to the GNU Fortran Runtime Library lists.  ##
6844 ## ------------------------------------------------------ ##
6845 _ASBOX
6846     ) |
6847       sed "s/^/$as_me: WARNING:     /" >&2
6848     ;;
6849 esac
6850 echo "$as_me:$LINENO: checking for complex.h" >&5
6851 echo $ECHO_N "checking for complex.h... $ECHO_C" >&6
6852 if test "${ac_cv_header_complex_h+set}" = set; then
6853   echo $ECHO_N "(cached) $ECHO_C" >&6
6854 else
6855   ac_cv_header_complex_h=$ac_header_preproc
6856 fi
6857 echo "$as_me:$LINENO: result: $ac_cv_header_complex_h" >&5
6858 echo "${ECHO_T}$ac_cv_header_complex_h" >&6
6859
6860 fi
6861 if test $ac_cv_header_complex_h = yes; then
6862
6863 cat >>confdefs.h <<\_ACEOF
6864 #define HAVE_COMPLEX_H 1
6865 _ACEOF
6866
6867 fi
6868
6869
6870
6871
6872 inttype_headers=`echo inttypes.h sys/inttypes.h  | sed -e 's/,/ /g'`
6873
6874 acx_cv_header_stdint=stddef.h
6875 acx_cv_header_stdint_kind="(already complete)"
6876 for i in stdint.h $inttype_headers; do
6877   unset ac_cv_type_uintptr_t
6878   unset ac_cv_type_uintmax_t
6879   unset ac_cv_type_int_least32_t
6880   unset ac_cv_type_int_fast32_t
6881   unset ac_cv_type_uint64_t
6882   echo $ECHO_N "looking for a compliant stdint.h in $i, $ECHO_C" >&6
6883   echo "$as_me:$LINENO: checking for uintmax_t" >&5
6884 echo $ECHO_N "checking for uintmax_t... $ECHO_C" >&6
6885 if test "${ac_cv_type_uintmax_t+set}" = set; then
6886   echo $ECHO_N "(cached) $ECHO_C" >&6
6887 else
6888   cat >conftest.$ac_ext <<_ACEOF
6889 /* confdefs.h.  */
6890 _ACEOF
6891 cat confdefs.h >>conftest.$ac_ext
6892 cat >>conftest.$ac_ext <<_ACEOF
6893 /* end confdefs.h.  */
6894 #include <sys/types.h>
6895 #include <$i>
6896
6897 int
6898 main ()
6899 {
6900 if ((uintmax_t *) 0)
6901   return 0;
6902 if (sizeof (uintmax_t))
6903   return 0;
6904   ;
6905   return 0;
6906 }
6907 _ACEOF
6908 rm -f conftest.$ac_objext
6909 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6910   (eval $ac_compile) 2>conftest.er1
6911   ac_status=$?
6912   grep -v '^ *+' conftest.er1 >conftest.err
6913   rm -f conftest.er1
6914   cat conftest.err >&5
6915   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6916   (exit $ac_status); } &&
6917          { ac_try='test -z "$ac_c_werror_flag"
6918                          || test ! -s conftest.err'
6919   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6920   (eval $ac_try) 2>&5
6921   ac_status=$?
6922   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6923   (exit $ac_status); }; } &&
6924          { ac_try='test -s conftest.$ac_objext'
6925   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6926   (eval $ac_try) 2>&5
6927   ac_status=$?
6928   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6929   (exit $ac_status); }; }; then
6930   ac_cv_type_uintmax_t=yes
6931 else
6932   echo "$as_me: failed program was:" >&5
6933 sed 's/^/| /' conftest.$ac_ext >&5
6934
6935 ac_cv_type_uintmax_t=no
6936 fi
6937 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6938 fi
6939 echo "$as_me:$LINENO: result: $ac_cv_type_uintmax_t" >&5
6940 echo "${ECHO_T}$ac_cv_type_uintmax_t" >&6
6941 if test $ac_cv_type_uintmax_t = yes; then
6942   acx_cv_header_stdint=$i
6943 else
6944   continue
6945 fi
6946
6947   echo "$as_me:$LINENO: checking for uintptr_t" >&5
6948 echo $ECHO_N "checking for uintptr_t... $ECHO_C" >&6
6949 if test "${ac_cv_type_uintptr_t+set}" = set; then
6950   echo $ECHO_N "(cached) $ECHO_C" >&6
6951 else
6952   cat >conftest.$ac_ext <<_ACEOF
6953 /* confdefs.h.  */
6954 _ACEOF
6955 cat confdefs.h >>conftest.$ac_ext
6956 cat >>conftest.$ac_ext <<_ACEOF
6957 /* end confdefs.h.  */
6958 #include <sys/types.h>
6959 #include <$i>
6960
6961 int
6962 main ()
6963 {
6964 if ((uintptr_t *) 0)
6965   return 0;
6966 if (sizeof (uintptr_t))
6967   return 0;
6968   ;
6969   return 0;
6970 }
6971 _ACEOF
6972 rm -f conftest.$ac_objext
6973 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6974   (eval $ac_compile) 2>conftest.er1
6975   ac_status=$?
6976   grep -v '^ *+' conftest.er1 >conftest.err
6977   rm -f conftest.er1
6978   cat conftest.err >&5
6979   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6980   (exit $ac_status); } &&
6981          { ac_try='test -z "$ac_c_werror_flag"
6982                          || test ! -s conftest.err'
6983   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6984   (eval $ac_try) 2>&5
6985   ac_status=$?
6986   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6987   (exit $ac_status); }; } &&
6988          { ac_try='test -s conftest.$ac_objext'
6989   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6990   (eval $ac_try) 2>&5
6991   ac_status=$?
6992   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6993   (exit $ac_status); }; }; then
6994   ac_cv_type_uintptr_t=yes
6995 else
6996   echo "$as_me: failed program was:" >&5
6997 sed 's/^/| /' conftest.$ac_ext >&5
6998
6999 ac_cv_type_uintptr_t=no
7000 fi
7001 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7002 fi
7003 echo "$as_me:$LINENO: result: $ac_cv_type_uintptr_t" >&5
7004 echo "${ECHO_T}$ac_cv_type_uintptr_t" >&6
7005 if test $ac_cv_type_uintptr_t = yes; then
7006   :
7007 else
7008   acx_cv_header_stdint_kind="(mostly complete)"
7009 fi
7010
7011   echo "$as_me:$LINENO: checking for int_least32_t" >&5
7012 echo $ECHO_N "checking for int_least32_t... $ECHO_C" >&6
7013 if test "${ac_cv_type_int_least32_t+set}" = set; then
7014   echo $ECHO_N "(cached) $ECHO_C" >&6
7015 else
7016   cat >conftest.$ac_ext <<_ACEOF
7017 /* confdefs.h.  */
7018 _ACEOF
7019 cat confdefs.h >>conftest.$ac_ext
7020 cat >>conftest.$ac_ext <<_ACEOF
7021 /* end confdefs.h.  */
7022 #include <sys/types.h>
7023 #include <$i>
7024
7025 int
7026 main ()
7027 {
7028 if ((int_least32_t *) 0)
7029   return 0;
7030 if (sizeof (int_least32_t))
7031   return 0;
7032   ;
7033   return 0;
7034 }
7035 _ACEOF
7036 rm -f conftest.$ac_objext
7037 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7038   (eval $ac_compile) 2>conftest.er1
7039   ac_status=$?
7040   grep -v '^ *+' conftest.er1 >conftest.err
7041   rm -f conftest.er1
7042   cat conftest.err >&5
7043   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7044   (exit $ac_status); } &&
7045          { ac_try='test -z "$ac_c_werror_flag"
7046                          || test ! -s conftest.err'
7047   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7048   (eval $ac_try) 2>&5
7049   ac_status=$?
7050   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7051   (exit $ac_status); }; } &&
7052          { ac_try='test -s conftest.$ac_objext'
7053   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7054   (eval $ac_try) 2>&5
7055   ac_status=$?
7056   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7057   (exit $ac_status); }; }; then
7058   ac_cv_type_int_least32_t=yes
7059 else
7060   echo "$as_me: failed program was:" >&5
7061 sed 's/^/| /' conftest.$ac_ext >&5
7062
7063 ac_cv_type_int_least32_t=no
7064 fi
7065 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7066 fi
7067 echo "$as_me:$LINENO: result: $ac_cv_type_int_least32_t" >&5
7068 echo "${ECHO_T}$ac_cv_type_int_least32_t" >&6
7069 if test $ac_cv_type_int_least32_t = yes; then
7070   :
7071 else
7072   acx_cv_header_stdint_kind="(mostly complete)"
7073 fi
7074
7075   echo "$as_me:$LINENO: checking for int_fast32_t" >&5
7076 echo $ECHO_N "checking for int_fast32_t... $ECHO_C" >&6
7077 if test "${ac_cv_type_int_fast32_t+set}" = set; then
7078   echo $ECHO_N "(cached) $ECHO_C" >&6
7079 else
7080   cat >conftest.$ac_ext <<_ACEOF
7081 /* confdefs.h.  */
7082 _ACEOF
7083 cat confdefs.h >>conftest.$ac_ext
7084 cat >>conftest.$ac_ext <<_ACEOF
7085 /* end confdefs.h.  */
7086 #include <sys/types.h>
7087 #include <$i>
7088
7089 int
7090 main ()
7091 {
7092 if ((int_fast32_t *) 0)
7093   return 0;
7094 if (sizeof (int_fast32_t))
7095   return 0;
7096   ;
7097   return 0;
7098 }
7099 _ACEOF
7100 rm -f conftest.$ac_objext
7101 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7102   (eval $ac_compile) 2>conftest.er1
7103   ac_status=$?
7104   grep -v '^ *+' conftest.er1 >conftest.err
7105   rm -f conftest.er1
7106   cat conftest.err >&5
7107   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7108   (exit $ac_status); } &&
7109          { ac_try='test -z "$ac_c_werror_flag"
7110                          || test ! -s conftest.err'
7111   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7112   (eval $ac_try) 2>&5
7113   ac_status=$?
7114   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7115   (exit $ac_status); }; } &&
7116          { ac_try='test -s conftest.$ac_objext'
7117   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7118   (eval $ac_try) 2>&5
7119   ac_status=$?
7120   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7121   (exit $ac_status); }; }; then
7122   ac_cv_type_int_fast32_t=yes
7123 else
7124   echo "$as_me: failed program was:" >&5
7125 sed 's/^/| /' conftest.$ac_ext >&5
7126
7127 ac_cv_type_int_fast32_t=no
7128 fi
7129 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7130 fi
7131 echo "$as_me:$LINENO: result: $ac_cv_type_int_fast32_t" >&5
7132 echo "${ECHO_T}$ac_cv_type_int_fast32_t" >&6
7133 if test $ac_cv_type_int_fast32_t = yes; then
7134   :
7135 else
7136   acx_cv_header_stdint_kind="(mostly complete)"
7137 fi
7138
7139   echo "$as_me:$LINENO: checking for uint64_t" >&5
7140 echo $ECHO_N "checking for uint64_t... $ECHO_C" >&6
7141 if test "${ac_cv_type_uint64_t+set}" = set; then
7142   echo $ECHO_N "(cached) $ECHO_C" >&6
7143 else
7144   cat >conftest.$ac_ext <<_ACEOF
7145 /* confdefs.h.  */
7146 _ACEOF
7147 cat confdefs.h >>conftest.$ac_ext
7148 cat >>conftest.$ac_ext <<_ACEOF
7149 /* end confdefs.h.  */
7150 #include <sys/types.h>
7151 #include <$i>
7152
7153 int
7154 main ()
7155 {
7156 if ((uint64_t *) 0)
7157   return 0;
7158 if (sizeof (uint64_t))
7159   return 0;
7160   ;
7161   return 0;
7162 }
7163 _ACEOF
7164 rm -f conftest.$ac_objext
7165 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7166   (eval $ac_compile) 2>conftest.er1
7167   ac_status=$?
7168   grep -v '^ *+' conftest.er1 >conftest.err
7169   rm -f conftest.er1
7170   cat conftest.err >&5
7171   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7172   (exit $ac_status); } &&
7173          { ac_try='test -z "$ac_c_werror_flag"
7174                          || test ! -s conftest.err'
7175   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7176   (eval $ac_try) 2>&5
7177   ac_status=$?
7178   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7179   (exit $ac_status); }; } &&
7180          { ac_try='test -s conftest.$ac_objext'
7181   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7182   (eval $ac_try) 2>&5
7183   ac_status=$?
7184   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7185   (exit $ac_status); }; }; then
7186   ac_cv_type_uint64_t=yes
7187 else
7188   echo "$as_me: failed program was:" >&5
7189 sed 's/^/| /' conftest.$ac_ext >&5
7190
7191 ac_cv_type_uint64_t=no
7192 fi
7193 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7194 fi
7195 echo "$as_me:$LINENO: result: $ac_cv_type_uint64_t" >&5
7196 echo "${ECHO_T}$ac_cv_type_uint64_t" >&6
7197 if test $ac_cv_type_uint64_t = yes; then
7198   :
7199 else
7200   acx_cv_header_stdint_kind="(lacks uint64_t)"
7201 fi
7202
7203   break
7204 done
7205 if test "$acx_cv_header_stdint" = stddef.h; then
7206   acx_cv_header_stdint_kind="(lacks uintmax_t)"
7207   for i in stdint.h $inttype_headers; do
7208     unset ac_cv_type_uintptr_t
7209     unset ac_cv_type_uint32_t
7210     unset ac_cv_type_uint64_t
7211     echo $ECHO_N "looking for an incomplete stdint.h in $i, $ECHO_C" >&6
7212     echo "$as_me:$LINENO: checking for uint32_t" >&5
7213 echo $ECHO_N "checking for uint32_t... $ECHO_C" >&6
7214 if test "${ac_cv_type_uint32_t+set}" = set; then
7215   echo $ECHO_N "(cached) $ECHO_C" >&6
7216 else
7217   cat >conftest.$ac_ext <<_ACEOF
7218 /* confdefs.h.  */
7219 _ACEOF
7220 cat confdefs.h >>conftest.$ac_ext
7221 cat >>conftest.$ac_ext <<_ACEOF
7222 /* end confdefs.h.  */
7223 #include <sys/types.h>
7224 #include <$i>
7225
7226 int
7227 main ()
7228 {
7229 if ((uint32_t *) 0)
7230   return 0;
7231 if (sizeof (uint32_t))
7232   return 0;
7233   ;
7234   return 0;
7235 }
7236 _ACEOF
7237 rm -f conftest.$ac_objext
7238 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7239   (eval $ac_compile) 2>conftest.er1
7240   ac_status=$?
7241   grep -v '^ *+' conftest.er1 >conftest.err
7242   rm -f conftest.er1
7243   cat conftest.err >&5
7244   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7245   (exit $ac_status); } &&
7246          { ac_try='test -z "$ac_c_werror_flag"
7247                          || test ! -s conftest.err'
7248   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7249   (eval $ac_try) 2>&5
7250   ac_status=$?
7251   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7252   (exit $ac_status); }; } &&
7253          { ac_try='test -s conftest.$ac_objext'
7254   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7255   (eval $ac_try) 2>&5
7256   ac_status=$?
7257   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7258   (exit $ac_status); }; }; then
7259   ac_cv_type_uint32_t=yes
7260 else
7261   echo "$as_me: failed program was:" >&5
7262 sed 's/^/| /' conftest.$ac_ext >&5
7263
7264 ac_cv_type_uint32_t=no
7265 fi
7266 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7267 fi
7268 echo "$as_me:$LINENO: result: $ac_cv_type_uint32_t" >&5
7269 echo "${ECHO_T}$ac_cv_type_uint32_t" >&6
7270 if test $ac_cv_type_uint32_t = yes; then
7271   acx_cv_header_stdint=$i
7272 else
7273   continue
7274 fi
7275
7276     echo "$as_me:$LINENO: checking for uint64_t" >&5
7277 echo $ECHO_N "checking for uint64_t... $ECHO_C" >&6
7278 if test "${ac_cv_type_uint64_t+set}" = set; then
7279   echo $ECHO_N "(cached) $ECHO_C" >&6
7280 else
7281   cat >conftest.$ac_ext <<_ACEOF
7282 /* confdefs.h.  */
7283 _ACEOF
7284 cat confdefs.h >>conftest.$ac_ext
7285 cat >>conftest.$ac_ext <<_ACEOF
7286 /* end confdefs.h.  */
7287 #include <sys/types.h>
7288 #include <$i>
7289
7290 int
7291 main ()
7292 {
7293 if ((uint64_t *) 0)
7294   return 0;
7295 if (sizeof (uint64_t))
7296   return 0;
7297   ;
7298   return 0;
7299 }
7300 _ACEOF
7301 rm -f conftest.$ac_objext
7302 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7303   (eval $ac_compile) 2>conftest.er1
7304   ac_status=$?
7305   grep -v '^ *+' conftest.er1 >conftest.err
7306   rm -f conftest.er1
7307   cat conftest.err >&5
7308   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7309   (exit $ac_status); } &&
7310          { ac_try='test -z "$ac_c_werror_flag"
7311                          || test ! -s conftest.err'
7312   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7313   (eval $ac_try) 2>&5
7314   ac_status=$?
7315   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7316   (exit $ac_status); }; } &&
7317          { ac_try='test -s conftest.$ac_objext'
7318   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7319   (eval $ac_try) 2>&5
7320   ac_status=$?
7321   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7322   (exit $ac_status); }; }; then
7323   ac_cv_type_uint64_t=yes
7324 else
7325   echo "$as_me: failed program was:" >&5
7326 sed 's/^/| /' conftest.$ac_ext >&5
7327
7328 ac_cv_type_uint64_t=no
7329 fi
7330 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7331 fi
7332 echo "$as_me:$LINENO: result: $ac_cv_type_uint64_t" >&5
7333 echo "${ECHO_T}$ac_cv_type_uint64_t" >&6
7334
7335     echo "$as_me:$LINENO: checking for uintptr_t" >&5
7336 echo $ECHO_N "checking for uintptr_t... $ECHO_C" >&6
7337 if test "${ac_cv_type_uintptr_t+set}" = set; then
7338   echo $ECHO_N "(cached) $ECHO_C" >&6
7339 else
7340   cat >conftest.$ac_ext <<_ACEOF
7341 /* confdefs.h.  */
7342 _ACEOF
7343 cat confdefs.h >>conftest.$ac_ext
7344 cat >>conftest.$ac_ext <<_ACEOF
7345 /* end confdefs.h.  */
7346 #include <sys/types.h>
7347 #include <$i>
7348
7349 int
7350 main ()
7351 {
7352 if ((uintptr_t *) 0)
7353   return 0;
7354 if (sizeof (uintptr_t))
7355   return 0;
7356   ;
7357   return 0;
7358 }
7359 _ACEOF
7360 rm -f conftest.$ac_objext
7361 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7362   (eval $ac_compile) 2>conftest.er1
7363   ac_status=$?
7364   grep -v '^ *+' conftest.er1 >conftest.err
7365   rm -f conftest.er1
7366   cat conftest.err >&5
7367   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7368   (exit $ac_status); } &&
7369          { ac_try='test -z "$ac_c_werror_flag"
7370                          || test ! -s conftest.err'
7371   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7372   (eval $ac_try) 2>&5
7373   ac_status=$?
7374   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7375   (exit $ac_status); }; } &&
7376          { ac_try='test -s conftest.$ac_objext'
7377   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7378   (eval $ac_try) 2>&5
7379   ac_status=$?
7380   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7381   (exit $ac_status); }; }; then
7382   ac_cv_type_uintptr_t=yes
7383 else
7384   echo "$as_me: failed program was:" >&5
7385 sed 's/^/| /' conftest.$ac_ext >&5
7386
7387 ac_cv_type_uintptr_t=no
7388 fi
7389 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7390 fi
7391 echo "$as_me:$LINENO: result: $ac_cv_type_uintptr_t" >&5
7392 echo "${ECHO_T}$ac_cv_type_uintptr_t" >&6
7393
7394     break
7395   done
7396 fi
7397 if test "$acx_cv_header_stdint" = stddef.h; then
7398   acx_cv_header_stdint_kind="(u_intXX_t style)"
7399   for i in sys/types.h $inttype_headers; do
7400     unset ac_cv_type_u_int32_t
7401     unset ac_cv_type_u_int64_t
7402     echo $ECHO_N "looking for u_intXX_t types in $i, $ECHO_C" >&6
7403     echo "$as_me:$LINENO: checking for u_int32_t" >&5
7404 echo $ECHO_N "checking for u_int32_t... $ECHO_C" >&6
7405 if test "${ac_cv_type_u_int32_t+set}" = set; then
7406   echo $ECHO_N "(cached) $ECHO_C" >&6
7407 else
7408   cat >conftest.$ac_ext <<_ACEOF
7409 /* confdefs.h.  */
7410 _ACEOF
7411 cat confdefs.h >>conftest.$ac_ext
7412 cat >>conftest.$ac_ext <<_ACEOF
7413 /* end confdefs.h.  */
7414 #include <sys/types.h>
7415 #include <$i>
7416
7417 int
7418 main ()
7419 {
7420 if ((u_int32_t *) 0)
7421   return 0;
7422 if (sizeof (u_int32_t))
7423   return 0;
7424   ;
7425   return 0;
7426 }
7427 _ACEOF
7428 rm -f conftest.$ac_objext
7429 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7430   (eval $ac_compile) 2>conftest.er1
7431   ac_status=$?
7432   grep -v '^ *+' conftest.er1 >conftest.err
7433   rm -f conftest.er1
7434   cat conftest.err >&5
7435   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7436   (exit $ac_status); } &&
7437          { ac_try='test -z "$ac_c_werror_flag"
7438                          || test ! -s conftest.err'
7439   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7440   (eval $ac_try) 2>&5
7441   ac_status=$?
7442   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7443   (exit $ac_status); }; } &&
7444          { ac_try='test -s conftest.$ac_objext'
7445   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7446   (eval $ac_try) 2>&5
7447   ac_status=$?
7448   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7449   (exit $ac_status); }; }; then
7450   ac_cv_type_u_int32_t=yes
7451 else
7452   echo "$as_me: failed program was:" >&5
7453 sed 's/^/| /' conftest.$ac_ext >&5
7454
7455 ac_cv_type_u_int32_t=no
7456 fi
7457 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7458 fi
7459 echo "$as_me:$LINENO: result: $ac_cv_type_u_int32_t" >&5
7460 echo "${ECHO_T}$ac_cv_type_u_int32_t" >&6
7461 if test $ac_cv_type_u_int32_t = yes; then
7462   acx_cv_header_stdint=$i
7463 else
7464   continue
7465 fi
7466
7467     echo "$as_me:$LINENO: checking for u_int64_t" >&5
7468 echo $ECHO_N "checking for u_int64_t... $ECHO_C" >&6
7469 if test "${ac_cv_type_u_int64_t+set}" = set; then
7470   echo $ECHO_N "(cached) $ECHO_C" >&6
7471 else
7472   cat >conftest.$ac_ext <<_ACEOF
7473 /* confdefs.h.  */
7474 _ACEOF
7475 cat confdefs.h >>conftest.$ac_ext
7476 cat >>conftest.$ac_ext <<_ACEOF
7477 /* end confdefs.h.  */
7478 #include <sys/types.h>
7479 #include <$i>
7480
7481 int
7482 main ()
7483 {
7484 if ((u_int64_t *) 0)
7485   return 0;
7486 if (sizeof (u_int64_t))
7487   return 0;
7488   ;
7489   return 0;
7490 }
7491 _ACEOF
7492 rm -f conftest.$ac_objext
7493 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7494   (eval $ac_compile) 2>conftest.er1
7495   ac_status=$?
7496   grep -v '^ *+' conftest.er1 >conftest.err
7497   rm -f conftest.er1
7498   cat conftest.err >&5
7499   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7500   (exit $ac_status); } &&
7501          { ac_try='test -z "$ac_c_werror_flag"
7502                          || test ! -s conftest.err'
7503   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7504   (eval $ac_try) 2>&5
7505   ac_status=$?
7506   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7507   (exit $ac_status); }; } &&
7508          { ac_try='test -s conftest.$ac_objext'
7509   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7510   (eval $ac_try) 2>&5
7511   ac_status=$?
7512   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7513   (exit $ac_status); }; }; then
7514   ac_cv_type_u_int64_t=yes
7515 else
7516   echo "$as_me: failed program was:" >&5
7517 sed 's/^/| /' conftest.$ac_ext >&5
7518
7519 ac_cv_type_u_int64_t=no
7520 fi
7521 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7522 fi
7523 echo "$as_me:$LINENO: result: $ac_cv_type_u_int64_t" >&5
7524 echo "${ECHO_T}$ac_cv_type_u_int64_t" >&6
7525
7526     break
7527   done
7528 fi
7529 if test "$acx_cv_header_stdint" = stddef.h; then
7530   acx_cv_header_stdint_kind="(using manual detection)"
7531 fi
7532
7533 test -z "$ac_cv_type_uintptr_t" && ac_cv_type_uintptr_t=no
7534 test -z "$ac_cv_type_uint64_t" && ac_cv_type_uint64_t=no
7535 test -z "$ac_cv_type_u_int64_t" && ac_cv_type_u_int64_t=no
7536 test -z "$ac_cv_type_int_least32_t" && ac_cv_type_int_least32_t=no
7537 test -z "$ac_cv_type_int_fast32_t" && ac_cv_type_int_fast32_t=no
7538
7539 # ----------------- Summarize what we found so far
7540
7541 echo "$as_me:$LINENO: checking what to include in gstdint.h" >&5
7542 echo $ECHO_N "checking what to include in gstdint.h... $ECHO_C" >&6
7543
7544 case `$as_basename gstdint.h ||
7545 $as_expr X/gstdint.h : '.*/\([^/][^/]*\)/*$' \| \
7546          Xgstdint.h : 'X\(//\)$' \| \
7547          Xgstdint.h : 'X\(/\)$' \| \
7548          .     : '\(.\)' 2>/dev/null ||
7549 echo X/gstdint.h |
7550     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
7551           /^X\/\(\/\/\)$/{ s//\1/; q; }
7552           /^X\/\(\/\).*/{ s//\1/; q; }
7553           s/.*/./; q'` in
7554   stdint.h) { echo "$as_me:$LINENO: WARNING: are you sure you want it there?" >&5
7555 echo "$as_me: WARNING: are you sure you want it there?" >&2;} ;;
7556   inttypes.h) { echo "$as_me:$LINENO: WARNING: are you sure you want it there?" >&5
7557 echo "$as_me: WARNING: are you sure you want it there?" >&2;} ;;
7558   *) ;;
7559 esac
7560
7561 echo "$as_me:$LINENO: result: $acx_cv_header_stdint $acx_cv_header_stdint_kind" >&5
7562 echo "${ECHO_T}$acx_cv_header_stdint $acx_cv_header_stdint_kind" >&6
7563
7564 # ----------------- done included file, check C basic types --------
7565
7566 # Lacking an uintptr_t?  Test size of void *
7567 case "$acx_cv_header_stdint:$ac_cv_type_uintptr_t" in
7568   stddef.h:* | *:no) echo "$as_me:$LINENO: checking for void *" >&5
7569 echo $ECHO_N "checking for void *... $ECHO_C" >&6
7570 if test "${ac_cv_type_void_p+set}" = set; then
7571   echo $ECHO_N "(cached) $ECHO_C" >&6
7572 else
7573   cat >conftest.$ac_ext <<_ACEOF
7574 /* confdefs.h.  */
7575 _ACEOF
7576 cat confdefs.h >>conftest.$ac_ext
7577 cat >>conftest.$ac_ext <<_ACEOF
7578 /* end confdefs.h.  */
7579 $ac_includes_default
7580 int
7581 main ()
7582 {
7583 if ((void * *) 0)
7584   return 0;
7585 if (sizeof (void *))
7586   return 0;
7587   ;
7588   return 0;
7589 }
7590 _ACEOF
7591 rm -f conftest.$ac_objext
7592 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7593   (eval $ac_compile) 2>conftest.er1
7594   ac_status=$?
7595   grep -v '^ *+' conftest.er1 >conftest.err
7596   rm -f conftest.er1
7597   cat conftest.err >&5
7598   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7599   (exit $ac_status); } &&
7600          { ac_try='test -z "$ac_c_werror_flag"
7601                          || test ! -s conftest.err'
7602   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7603   (eval $ac_try) 2>&5
7604   ac_status=$?
7605   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7606   (exit $ac_status); }; } &&
7607          { ac_try='test -s conftest.$ac_objext'
7608   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7609   (eval $ac_try) 2>&5
7610   ac_status=$?
7611   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7612   (exit $ac_status); }; }; then
7613   ac_cv_type_void_p=yes
7614 else
7615   echo "$as_me: failed program was:" >&5
7616 sed 's/^/| /' conftest.$ac_ext >&5
7617
7618 ac_cv_type_void_p=no
7619 fi
7620 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7621 fi
7622 echo "$as_me:$LINENO: result: $ac_cv_type_void_p" >&5
7623 echo "${ECHO_T}$ac_cv_type_void_p" >&6
7624
7625 echo "$as_me:$LINENO: checking size of void *" >&5
7626 echo $ECHO_N "checking size of void *... $ECHO_C" >&6
7627 if test "${ac_cv_sizeof_void_p+set}" = set; then
7628   echo $ECHO_N "(cached) $ECHO_C" >&6
7629 else
7630   if test "$ac_cv_type_void_p" = yes; then
7631   # The cast to unsigned long works around a bug in the HP C Compiler
7632   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
7633   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
7634   # This bug is HP SR number 8606223364.
7635   if test "$cross_compiling" = yes; then
7636   # Depending upon the size, compute the lo and hi bounds.
7637 cat >conftest.$ac_ext <<_ACEOF
7638 /* confdefs.h.  */
7639 _ACEOF
7640 cat confdefs.h >>conftest.$ac_ext
7641 cat >>conftest.$ac_ext <<_ACEOF
7642 /* end confdefs.h.  */
7643 $ac_includes_default
7644 int
7645 main ()
7646 {
7647 static int test_array [1 - 2 * !(((long) (sizeof (void *))) >= 0)];
7648 test_array [0] = 0
7649
7650   ;
7651   return 0;
7652 }
7653 _ACEOF
7654 rm -f conftest.$ac_objext
7655 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7656   (eval $ac_compile) 2>conftest.er1
7657   ac_status=$?
7658   grep -v '^ *+' conftest.er1 >conftest.err
7659   rm -f conftest.er1
7660   cat conftest.err >&5
7661   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7662   (exit $ac_status); } &&
7663          { ac_try='test -z "$ac_c_werror_flag"
7664                          || test ! -s conftest.err'
7665   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7666   (eval $ac_try) 2>&5
7667   ac_status=$?
7668   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7669   (exit $ac_status); }; } &&
7670          { ac_try='test -s conftest.$ac_objext'
7671   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7672   (eval $ac_try) 2>&5
7673   ac_status=$?
7674   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7675   (exit $ac_status); }; }; then
7676   ac_lo=0 ac_mid=0
7677   while :; do
7678     cat >conftest.$ac_ext <<_ACEOF
7679 /* confdefs.h.  */
7680 _ACEOF
7681 cat confdefs.h >>conftest.$ac_ext
7682 cat >>conftest.$ac_ext <<_ACEOF
7683 /* end confdefs.h.  */
7684 $ac_includes_default
7685 int
7686 main ()
7687 {
7688 static int test_array [1 - 2 * !(((long) (sizeof (void *))) <= $ac_mid)];
7689 test_array [0] = 0
7690
7691   ;
7692   return 0;
7693 }
7694 _ACEOF
7695 rm -f conftest.$ac_objext
7696 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7697   (eval $ac_compile) 2>conftest.er1
7698   ac_status=$?
7699   grep -v '^ *+' conftest.er1 >conftest.err
7700   rm -f conftest.er1
7701   cat conftest.err >&5
7702   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7703   (exit $ac_status); } &&
7704          { ac_try='test -z "$ac_c_werror_flag"
7705                          || test ! -s conftest.err'
7706   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7707   (eval $ac_try) 2>&5
7708   ac_status=$?
7709   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7710   (exit $ac_status); }; } &&
7711          { ac_try='test -s conftest.$ac_objext'
7712   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7713   (eval $ac_try) 2>&5
7714   ac_status=$?
7715   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7716   (exit $ac_status); }; }; then
7717   ac_hi=$ac_mid; break
7718 else
7719   echo "$as_me: failed program was:" >&5
7720 sed 's/^/| /' conftest.$ac_ext >&5
7721
7722 ac_lo=`expr $ac_mid + 1`
7723                     if test $ac_lo -le $ac_mid; then
7724                       ac_lo= ac_hi=
7725                       break
7726                     fi
7727                     ac_mid=`expr 2 '*' $ac_mid + 1`
7728 fi
7729 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7730   done
7731 else
7732   echo "$as_me: failed program was:" >&5
7733 sed 's/^/| /' conftest.$ac_ext >&5
7734
7735 cat >conftest.$ac_ext <<_ACEOF
7736 /* confdefs.h.  */
7737 _ACEOF
7738 cat confdefs.h >>conftest.$ac_ext
7739 cat >>conftest.$ac_ext <<_ACEOF
7740 /* end confdefs.h.  */
7741 $ac_includes_default
7742 int
7743 main ()
7744 {
7745 static int test_array [1 - 2 * !(((long) (sizeof (void *))) < 0)];
7746 test_array [0] = 0
7747
7748   ;
7749   return 0;
7750 }
7751 _ACEOF
7752 rm -f conftest.$ac_objext
7753 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7754   (eval $ac_compile) 2>conftest.er1
7755   ac_status=$?
7756   grep -v '^ *+' conftest.er1 >conftest.err
7757   rm -f conftest.er1
7758   cat conftest.err >&5
7759   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7760   (exit $ac_status); } &&
7761          { ac_try='test -z "$ac_c_werror_flag"
7762                          || test ! -s conftest.err'
7763   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7764   (eval $ac_try) 2>&5
7765   ac_status=$?
7766   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7767   (exit $ac_status); }; } &&
7768          { ac_try='test -s conftest.$ac_objext'
7769   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7770   (eval $ac_try) 2>&5
7771   ac_status=$?
7772   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7773   (exit $ac_status); }; }; then
7774   ac_hi=-1 ac_mid=-1
7775   while :; do
7776     cat >conftest.$ac_ext <<_ACEOF
7777 /* confdefs.h.  */
7778 _ACEOF
7779 cat confdefs.h >>conftest.$ac_ext
7780 cat >>conftest.$ac_ext <<_ACEOF
7781 /* end confdefs.h.  */
7782 $ac_includes_default
7783 int
7784 main ()
7785 {
7786 static int test_array [1 - 2 * !(((long) (sizeof (void *))) >= $ac_mid)];
7787 test_array [0] = 0
7788
7789   ;
7790   return 0;
7791 }
7792 _ACEOF
7793 rm -f conftest.$ac_objext
7794 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7795   (eval $ac_compile) 2>conftest.er1
7796   ac_status=$?
7797   grep -v '^ *+' conftest.er1 >conftest.err
7798   rm -f conftest.er1
7799   cat conftest.err >&5
7800   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7801   (exit $ac_status); } &&
7802          { ac_try='test -z "$ac_c_werror_flag"
7803                          || test ! -s conftest.err'
7804   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7805   (eval $ac_try) 2>&5
7806   ac_status=$?
7807   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7808   (exit $ac_status); }; } &&
7809          { ac_try='test -s conftest.$ac_objext'
7810   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7811   (eval $ac_try) 2>&5
7812   ac_status=$?
7813   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7814   (exit $ac_status); }; }; then
7815   ac_lo=$ac_mid; break
7816 else
7817   echo "$as_me: failed program was:" >&5
7818 sed 's/^/| /' conftest.$ac_ext >&5
7819
7820 ac_hi=`expr '(' $ac_mid ')' - 1`
7821                        if test $ac_mid -le $ac_hi; then
7822                          ac_lo= ac_hi=
7823                          break
7824                        fi
7825                        ac_mid=`expr 2 '*' $ac_mid`
7826 fi
7827 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7828   done
7829 else
7830   echo "$as_me: failed program was:" >&5
7831 sed 's/^/| /' conftest.$ac_ext >&5
7832
7833 ac_lo= ac_hi=
7834 fi
7835 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7836 fi
7837 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7838 # Binary search between lo and hi bounds.
7839 while test "x$ac_lo" != "x$ac_hi"; do
7840   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
7841   cat >conftest.$ac_ext <<_ACEOF
7842 /* confdefs.h.  */
7843 _ACEOF
7844 cat confdefs.h >>conftest.$ac_ext
7845 cat >>conftest.$ac_ext <<_ACEOF
7846 /* end confdefs.h.  */
7847 $ac_includes_default
7848 int
7849 main ()
7850 {
7851 static int test_array [1 - 2 * !(((long) (sizeof (void *))) <= $ac_mid)];
7852 test_array [0] = 0
7853
7854   ;
7855   return 0;
7856 }
7857 _ACEOF
7858 rm -f conftest.$ac_objext
7859 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7860   (eval $ac_compile) 2>conftest.er1
7861   ac_status=$?
7862   grep -v '^ *+' conftest.er1 >conftest.err
7863   rm -f conftest.er1
7864   cat conftest.err >&5
7865   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7866   (exit $ac_status); } &&
7867          { ac_try='test -z "$ac_c_werror_flag"
7868                          || test ! -s conftest.err'
7869   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7870   (eval $ac_try) 2>&5
7871   ac_status=$?
7872   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7873   (exit $ac_status); }; } &&
7874          { ac_try='test -s conftest.$ac_objext'
7875   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7876   (eval $ac_try) 2>&5
7877   ac_status=$?
7878   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7879   (exit $ac_status); }; }; then
7880   ac_hi=$ac_mid
7881 else
7882   echo "$as_me: failed program was:" >&5
7883 sed 's/^/| /' conftest.$ac_ext >&5
7884
7885 ac_lo=`expr '(' $ac_mid ')' + 1`
7886 fi
7887 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7888 done
7889 case $ac_lo in
7890 ?*) ac_cv_sizeof_void_p=$ac_lo;;
7891 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (void *), 77
7892 See \`config.log' for more details." >&5
7893 echo "$as_me: error: cannot compute sizeof (void *), 77
7894 See \`config.log' for more details." >&2;}
7895    { (exit 1); exit 1; }; } ;;
7896 esac
7897 else
7898   if test "$cross_compiling" = yes; then
7899   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
7900 See \`config.log' for more details." >&5
7901 echo "$as_me: error: cannot run test program while cross compiling
7902 See \`config.log' for more details." >&2;}
7903    { (exit 1); exit 1; }; }
7904 else
7905   cat >conftest.$ac_ext <<_ACEOF
7906 /* confdefs.h.  */
7907 _ACEOF
7908 cat confdefs.h >>conftest.$ac_ext
7909 cat >>conftest.$ac_ext <<_ACEOF
7910 /* end confdefs.h.  */
7911 $ac_includes_default
7912 long longval () { return (long) (sizeof (void *)); }
7913 unsigned long ulongval () { return (long) (sizeof (void *)); }
7914 #include <stdio.h>
7915 #include <stdlib.h>
7916 int
7917 main ()
7918 {
7919
7920   FILE *f = fopen ("conftest.val", "w");
7921   if (! f)
7922     exit (1);
7923   if (((long) (sizeof (void *))) < 0)
7924     {
7925       long i = longval ();
7926       if (i != ((long) (sizeof (void *))))
7927         exit (1);
7928       fprintf (f, "%ld\n", i);
7929     }
7930   else
7931     {
7932       unsigned long i = ulongval ();
7933       if (i != ((long) (sizeof (void *))))
7934         exit (1);
7935       fprintf (f, "%lu\n", i);
7936     }
7937   exit (ferror (f) || fclose (f) != 0);
7938
7939   ;
7940   return 0;
7941 }
7942 _ACEOF
7943 rm -f conftest$ac_exeext
7944 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7945   (eval $ac_link) 2>&5
7946   ac_status=$?
7947   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7948   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7949   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7950   (eval $ac_try) 2>&5
7951   ac_status=$?
7952   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7953   (exit $ac_status); }; }; then
7954   ac_cv_sizeof_void_p=`cat conftest.val`
7955 else
7956   echo "$as_me: program exited with status $ac_status" >&5
7957 echo "$as_me: failed program was:" >&5
7958 sed 's/^/| /' conftest.$ac_ext >&5
7959
7960 ( exit $ac_status )
7961 { { echo "$as_me:$LINENO: error: cannot compute sizeof (void *), 77
7962 See \`config.log' for more details." >&5
7963 echo "$as_me: error: cannot compute sizeof (void *), 77
7964 See \`config.log' for more details." >&2;}
7965    { (exit 1); exit 1; }; }
7966 fi
7967 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7968 fi
7969 fi
7970 rm -f conftest.val
7971 else
7972   ac_cv_sizeof_void_p=0
7973 fi
7974 fi
7975 echo "$as_me:$LINENO: result: $ac_cv_sizeof_void_p" >&5
7976 echo "${ECHO_T}$ac_cv_sizeof_void_p" >&6
7977 cat >>confdefs.h <<_ACEOF
7978 #define SIZEOF_VOID_P $ac_cv_sizeof_void_p
7979 _ACEOF
7980
7981  ;;
7982 esac
7983
7984 # Lacking an uint64_t?  Test size of long
7985 case "$acx_cv_header_stdint:$ac_cv_type_uint64_t:$ac_cv_type_u_int64_t" in
7986   stddef.h:*:* | *:no:no) echo "$as_me:$LINENO: checking for long" >&5
7987 echo $ECHO_N "checking for long... $ECHO_C" >&6
7988 if test "${ac_cv_type_long+set}" = set; then
7989   echo $ECHO_N "(cached) $ECHO_C" >&6
7990 else
7991   cat >conftest.$ac_ext <<_ACEOF
7992 /* confdefs.h.  */
7993 _ACEOF
7994 cat confdefs.h >>conftest.$ac_ext
7995 cat >>conftest.$ac_ext <<_ACEOF
7996 /* end confdefs.h.  */
7997 $ac_includes_default
7998 int
7999 main ()
8000 {
8001 if ((long *) 0)
8002   return 0;
8003 if (sizeof (long))
8004   return 0;
8005   ;
8006   return 0;
8007 }
8008 _ACEOF
8009 rm -f conftest.$ac_objext
8010 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8011   (eval $ac_compile) 2>conftest.er1
8012   ac_status=$?
8013   grep -v '^ *+' conftest.er1 >conftest.err
8014   rm -f conftest.er1
8015   cat conftest.err >&5
8016   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8017   (exit $ac_status); } &&
8018          { ac_try='test -z "$ac_c_werror_flag"
8019                          || test ! -s conftest.err'
8020   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8021   (eval $ac_try) 2>&5
8022   ac_status=$?
8023   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8024   (exit $ac_status); }; } &&
8025          { ac_try='test -s conftest.$ac_objext'
8026   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8027   (eval $ac_try) 2>&5
8028   ac_status=$?
8029   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8030   (exit $ac_status); }; }; then
8031   ac_cv_type_long=yes
8032 else
8033   echo "$as_me: failed program was:" >&5
8034 sed 's/^/| /' conftest.$ac_ext >&5
8035
8036 ac_cv_type_long=no
8037 fi
8038 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8039 fi
8040 echo "$as_me:$LINENO: result: $ac_cv_type_long" >&5
8041 echo "${ECHO_T}$ac_cv_type_long" >&6
8042
8043 echo "$as_me:$LINENO: checking size of long" >&5
8044 echo $ECHO_N "checking size of long... $ECHO_C" >&6
8045 if test "${ac_cv_sizeof_long+set}" = set; then
8046   echo $ECHO_N "(cached) $ECHO_C" >&6
8047 else
8048   if test "$ac_cv_type_long" = yes; then
8049   # The cast to unsigned long works around a bug in the HP C Compiler
8050   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
8051   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
8052   # This bug is HP SR number 8606223364.
8053   if test "$cross_compiling" = yes; then
8054   # Depending upon the size, compute the lo and hi bounds.
8055 cat >conftest.$ac_ext <<_ACEOF
8056 /* confdefs.h.  */
8057 _ACEOF
8058 cat confdefs.h >>conftest.$ac_ext
8059 cat >>conftest.$ac_ext <<_ACEOF
8060 /* end confdefs.h.  */
8061 $ac_includes_default
8062 int
8063 main ()
8064 {
8065 static int test_array [1 - 2 * !(((long) (sizeof (long))) >= 0)];
8066 test_array [0] = 0
8067
8068   ;
8069   return 0;
8070 }
8071 _ACEOF
8072 rm -f conftest.$ac_objext
8073 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8074   (eval $ac_compile) 2>conftest.er1
8075   ac_status=$?
8076   grep -v '^ *+' conftest.er1 >conftest.err
8077   rm -f conftest.er1
8078   cat conftest.err >&5
8079   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8080   (exit $ac_status); } &&
8081          { ac_try='test -z "$ac_c_werror_flag"
8082                          || test ! -s conftest.err'
8083   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8084   (eval $ac_try) 2>&5
8085   ac_status=$?
8086   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8087   (exit $ac_status); }; } &&
8088          { ac_try='test -s conftest.$ac_objext'
8089   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8090   (eval $ac_try) 2>&5
8091   ac_status=$?
8092   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8093   (exit $ac_status); }; }; then
8094   ac_lo=0 ac_mid=0
8095   while :; do
8096     cat >conftest.$ac_ext <<_ACEOF
8097 /* confdefs.h.  */
8098 _ACEOF
8099 cat confdefs.h >>conftest.$ac_ext
8100 cat >>conftest.$ac_ext <<_ACEOF
8101 /* end confdefs.h.  */
8102 $ac_includes_default
8103 int
8104 main ()
8105 {
8106 static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];
8107 test_array [0] = 0
8108
8109   ;
8110   return 0;
8111 }
8112 _ACEOF
8113 rm -f conftest.$ac_objext
8114 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8115   (eval $ac_compile) 2>conftest.er1
8116   ac_status=$?
8117   grep -v '^ *+' conftest.er1 >conftest.err
8118   rm -f conftest.er1
8119   cat conftest.err >&5
8120   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8121   (exit $ac_status); } &&
8122          { ac_try='test -z "$ac_c_werror_flag"
8123                          || test ! -s conftest.err'
8124   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8125   (eval $ac_try) 2>&5
8126   ac_status=$?
8127   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8128   (exit $ac_status); }; } &&
8129          { ac_try='test -s conftest.$ac_objext'
8130   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8131   (eval $ac_try) 2>&5
8132   ac_status=$?
8133   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8134   (exit $ac_status); }; }; then
8135   ac_hi=$ac_mid; break
8136 else
8137   echo "$as_me: failed program was:" >&5
8138 sed 's/^/| /' conftest.$ac_ext >&5
8139
8140 ac_lo=`expr $ac_mid + 1`
8141                     if test $ac_lo -le $ac_mid; then
8142                       ac_lo= ac_hi=
8143                       break
8144                     fi
8145                     ac_mid=`expr 2 '*' $ac_mid + 1`
8146 fi
8147 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8148   done
8149 else
8150   echo "$as_me: failed program was:" >&5
8151 sed 's/^/| /' conftest.$ac_ext >&5
8152
8153 cat >conftest.$ac_ext <<_ACEOF
8154 /* confdefs.h.  */
8155 _ACEOF
8156 cat confdefs.h >>conftest.$ac_ext
8157 cat >>conftest.$ac_ext <<_ACEOF
8158 /* end confdefs.h.  */
8159 $ac_includes_default
8160 int
8161 main ()
8162 {
8163 static int test_array [1 - 2 * !(((long) (sizeof (long))) < 0)];
8164 test_array [0] = 0
8165
8166   ;
8167   return 0;
8168 }
8169 _ACEOF
8170 rm -f conftest.$ac_objext
8171 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8172   (eval $ac_compile) 2>conftest.er1
8173   ac_status=$?
8174   grep -v '^ *+' conftest.er1 >conftest.err
8175   rm -f conftest.er1
8176   cat conftest.err >&5
8177   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8178   (exit $ac_status); } &&
8179          { ac_try='test -z "$ac_c_werror_flag"
8180                          || test ! -s conftest.err'
8181   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8182   (eval $ac_try) 2>&5
8183   ac_status=$?
8184   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8185   (exit $ac_status); }; } &&
8186          { ac_try='test -s conftest.$ac_objext'
8187   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8188   (eval $ac_try) 2>&5
8189   ac_status=$?
8190   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8191   (exit $ac_status); }; }; then
8192   ac_hi=-1 ac_mid=-1
8193   while :; do
8194     cat >conftest.$ac_ext <<_ACEOF
8195 /* confdefs.h.  */
8196 _ACEOF
8197 cat confdefs.h >>conftest.$ac_ext
8198 cat >>conftest.$ac_ext <<_ACEOF
8199 /* end confdefs.h.  */
8200 $ac_includes_default
8201 int
8202 main ()
8203 {
8204 static int test_array [1 - 2 * !(((long) (sizeof (long))) >= $ac_mid)];
8205 test_array [0] = 0
8206
8207   ;
8208   return 0;
8209 }
8210 _ACEOF
8211 rm -f conftest.$ac_objext
8212 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8213   (eval $ac_compile) 2>conftest.er1
8214   ac_status=$?
8215   grep -v '^ *+' conftest.er1 >conftest.err
8216   rm -f conftest.er1
8217   cat conftest.err >&5
8218   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8219   (exit $ac_status); } &&
8220          { ac_try='test -z "$ac_c_werror_flag"
8221                          || test ! -s conftest.err'
8222   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8223   (eval $ac_try) 2>&5
8224   ac_status=$?
8225   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8226   (exit $ac_status); }; } &&
8227          { ac_try='test -s conftest.$ac_objext'
8228   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8229   (eval $ac_try) 2>&5
8230   ac_status=$?
8231   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8232   (exit $ac_status); }; }; then
8233   ac_lo=$ac_mid; break
8234 else
8235   echo "$as_me: failed program was:" >&5
8236 sed 's/^/| /' conftest.$ac_ext >&5
8237
8238 ac_hi=`expr '(' $ac_mid ')' - 1`
8239                        if test $ac_mid -le $ac_hi; then
8240                          ac_lo= ac_hi=
8241                          break
8242                        fi
8243                        ac_mid=`expr 2 '*' $ac_mid`
8244 fi
8245 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8246   done
8247 else
8248   echo "$as_me: failed program was:" >&5
8249 sed 's/^/| /' conftest.$ac_ext >&5
8250
8251 ac_lo= ac_hi=
8252 fi
8253 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8254 fi
8255 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8256 # Binary search between lo and hi bounds.
8257 while test "x$ac_lo" != "x$ac_hi"; do
8258   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
8259   cat >conftest.$ac_ext <<_ACEOF
8260 /* confdefs.h.  */
8261 _ACEOF
8262 cat confdefs.h >>conftest.$ac_ext
8263 cat >>conftest.$ac_ext <<_ACEOF
8264 /* end confdefs.h.  */
8265 $ac_includes_default
8266 int
8267 main ()
8268 {
8269 static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];
8270 test_array [0] = 0
8271
8272   ;
8273   return 0;
8274 }
8275 _ACEOF
8276 rm -f conftest.$ac_objext
8277 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8278   (eval $ac_compile) 2>conftest.er1
8279   ac_status=$?
8280   grep -v '^ *+' conftest.er1 >conftest.err
8281   rm -f conftest.er1
8282   cat conftest.err >&5
8283   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8284   (exit $ac_status); } &&
8285          { ac_try='test -z "$ac_c_werror_flag"
8286                          || test ! -s conftest.err'
8287   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8288   (eval $ac_try) 2>&5
8289   ac_status=$?
8290   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8291   (exit $ac_status); }; } &&
8292          { ac_try='test -s conftest.$ac_objext'
8293   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8294   (eval $ac_try) 2>&5
8295   ac_status=$?
8296   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8297   (exit $ac_status); }; }; then
8298   ac_hi=$ac_mid
8299 else
8300   echo "$as_me: failed program was:" >&5
8301 sed 's/^/| /' conftest.$ac_ext >&5
8302
8303 ac_lo=`expr '(' $ac_mid ')' + 1`
8304 fi
8305 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8306 done
8307 case $ac_lo in
8308 ?*) ac_cv_sizeof_long=$ac_lo;;
8309 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77
8310 See \`config.log' for more details." >&5
8311 echo "$as_me: error: cannot compute sizeof (long), 77
8312 See \`config.log' for more details." >&2;}
8313    { (exit 1); exit 1; }; } ;;
8314 esac
8315 else
8316   if test "$cross_compiling" = yes; then
8317   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
8318 See \`config.log' for more details." >&5
8319 echo "$as_me: error: cannot run test program while cross compiling
8320 See \`config.log' for more details." >&2;}
8321    { (exit 1); exit 1; }; }
8322 else
8323   cat >conftest.$ac_ext <<_ACEOF
8324 /* confdefs.h.  */
8325 _ACEOF
8326 cat confdefs.h >>conftest.$ac_ext
8327 cat >>conftest.$ac_ext <<_ACEOF
8328 /* end confdefs.h.  */
8329 $ac_includes_default
8330 long longval () { return (long) (sizeof (long)); }
8331 unsigned long ulongval () { return (long) (sizeof (long)); }
8332 #include <stdio.h>
8333 #include <stdlib.h>
8334 int
8335 main ()
8336 {
8337
8338   FILE *f = fopen ("conftest.val", "w");
8339   if (! f)
8340     exit (1);
8341   if (((long) (sizeof (long))) < 0)
8342     {
8343       long i = longval ();
8344       if (i != ((long) (sizeof (long))))
8345         exit (1);
8346       fprintf (f, "%ld\n", i);
8347     }
8348   else
8349     {
8350       unsigned long i = ulongval ();
8351       if (i != ((long) (sizeof (long))))
8352         exit (1);
8353       fprintf (f, "%lu\n", i);
8354     }
8355   exit (ferror (f) || fclose (f) != 0);
8356
8357   ;
8358   return 0;
8359 }
8360 _ACEOF
8361 rm -f conftest$ac_exeext
8362 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8363   (eval $ac_link) 2>&5
8364   ac_status=$?
8365   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8366   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8367   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8368   (eval $ac_try) 2>&5
8369   ac_status=$?
8370   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8371   (exit $ac_status); }; }; then
8372   ac_cv_sizeof_long=`cat conftest.val`
8373 else
8374   echo "$as_me: program exited with status $ac_status" >&5
8375 echo "$as_me: failed program was:" >&5
8376 sed 's/^/| /' conftest.$ac_ext >&5
8377
8378 ( exit $ac_status )
8379 { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77
8380 See \`config.log' for more details." >&5
8381 echo "$as_me: error: cannot compute sizeof (long), 77
8382 See \`config.log' for more details." >&2;}
8383    { (exit 1); exit 1; }; }
8384 fi
8385 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8386 fi
8387 fi
8388 rm -f conftest.val
8389 else
8390   ac_cv_sizeof_long=0
8391 fi
8392 fi
8393 echo "$as_me:$LINENO: result: $ac_cv_sizeof_long" >&5
8394 echo "${ECHO_T}$ac_cv_sizeof_long" >&6
8395 cat >>confdefs.h <<_ACEOF
8396 #define SIZEOF_LONG $ac_cv_sizeof_long
8397 _ACEOF
8398
8399  ;;
8400 esac
8401
8402 if test $acx_cv_header_stdint = stddef.h; then
8403   # Lacking a good header?  Test size of everything and deduce all types.
8404   echo "$as_me:$LINENO: checking for int" >&5
8405 echo $ECHO_N "checking for int... $ECHO_C" >&6
8406 if test "${ac_cv_type_int+set}" = set; then
8407   echo $ECHO_N "(cached) $ECHO_C" >&6
8408 else
8409   cat >conftest.$ac_ext <<_ACEOF
8410 /* confdefs.h.  */
8411 _ACEOF
8412 cat confdefs.h >>conftest.$ac_ext
8413 cat >>conftest.$ac_ext <<_ACEOF
8414 /* end confdefs.h.  */
8415 $ac_includes_default
8416 int
8417 main ()
8418 {
8419 if ((int *) 0)
8420   return 0;
8421 if (sizeof (int))
8422   return 0;
8423   ;
8424   return 0;
8425 }
8426 _ACEOF
8427 rm -f conftest.$ac_objext
8428 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8429   (eval $ac_compile) 2>conftest.er1
8430   ac_status=$?
8431   grep -v '^ *+' conftest.er1 >conftest.err
8432   rm -f conftest.er1
8433   cat conftest.err >&5
8434   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8435   (exit $ac_status); } &&
8436          { ac_try='test -z "$ac_c_werror_flag"
8437                          || test ! -s conftest.err'
8438   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8439   (eval $ac_try) 2>&5
8440   ac_status=$?
8441   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8442   (exit $ac_status); }; } &&
8443          { ac_try='test -s conftest.$ac_objext'
8444   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8445   (eval $ac_try) 2>&5
8446   ac_status=$?
8447   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8448   (exit $ac_status); }; }; then
8449   ac_cv_type_int=yes
8450 else
8451   echo "$as_me: failed program was:" >&5
8452 sed 's/^/| /' conftest.$ac_ext >&5
8453
8454 ac_cv_type_int=no
8455 fi
8456 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8457 fi
8458 echo "$as_me:$LINENO: result: $ac_cv_type_int" >&5
8459 echo "${ECHO_T}$ac_cv_type_int" >&6
8460
8461 echo "$as_me:$LINENO: checking size of int" >&5
8462 echo $ECHO_N "checking size of int... $ECHO_C" >&6
8463 if test "${ac_cv_sizeof_int+set}" = set; then
8464   echo $ECHO_N "(cached) $ECHO_C" >&6
8465 else
8466   if test "$ac_cv_type_int" = yes; then
8467   # The cast to unsigned long works around a bug in the HP C Compiler
8468   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
8469   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
8470   # This bug is HP SR number 8606223364.
8471   if test "$cross_compiling" = yes; then
8472   # Depending upon the size, compute the lo and hi bounds.
8473 cat >conftest.$ac_ext <<_ACEOF
8474 /* confdefs.h.  */
8475 _ACEOF
8476 cat confdefs.h >>conftest.$ac_ext
8477 cat >>conftest.$ac_ext <<_ACEOF
8478 /* end confdefs.h.  */
8479 $ac_includes_default
8480 int
8481 main ()
8482 {
8483 static int test_array [1 - 2 * !(((long) (sizeof (int))) >= 0)];
8484 test_array [0] = 0
8485
8486   ;
8487   return 0;
8488 }
8489 _ACEOF
8490 rm -f conftest.$ac_objext
8491 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8492   (eval $ac_compile) 2>conftest.er1
8493   ac_status=$?
8494   grep -v '^ *+' conftest.er1 >conftest.err
8495   rm -f conftest.er1
8496   cat conftest.err >&5
8497   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8498   (exit $ac_status); } &&
8499          { ac_try='test -z "$ac_c_werror_flag"
8500                          || test ! -s conftest.err'
8501   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8502   (eval $ac_try) 2>&5
8503   ac_status=$?
8504   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8505   (exit $ac_status); }; } &&
8506          { ac_try='test -s conftest.$ac_objext'
8507   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8508   (eval $ac_try) 2>&5
8509   ac_status=$?
8510   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8511   (exit $ac_status); }; }; then
8512   ac_lo=0 ac_mid=0
8513   while :; do
8514     cat >conftest.$ac_ext <<_ACEOF
8515 /* confdefs.h.  */
8516 _ACEOF
8517 cat confdefs.h >>conftest.$ac_ext
8518 cat >>conftest.$ac_ext <<_ACEOF
8519 /* end confdefs.h.  */
8520 $ac_includes_default
8521 int
8522 main ()
8523 {
8524 static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)];
8525 test_array [0] = 0
8526
8527   ;
8528   return 0;
8529 }
8530 _ACEOF
8531 rm -f conftest.$ac_objext
8532 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8533   (eval $ac_compile) 2>conftest.er1
8534   ac_status=$?
8535   grep -v '^ *+' conftest.er1 >conftest.err
8536   rm -f conftest.er1
8537   cat conftest.err >&5
8538   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8539   (exit $ac_status); } &&
8540          { ac_try='test -z "$ac_c_werror_flag"
8541                          || test ! -s conftest.err'
8542   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8543   (eval $ac_try) 2>&5
8544   ac_status=$?
8545   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8546   (exit $ac_status); }; } &&
8547          { ac_try='test -s conftest.$ac_objext'
8548   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8549   (eval $ac_try) 2>&5
8550   ac_status=$?
8551   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8552   (exit $ac_status); }; }; then
8553   ac_hi=$ac_mid; break
8554 else
8555   echo "$as_me: failed program was:" >&5
8556 sed 's/^/| /' conftest.$ac_ext >&5
8557
8558 ac_lo=`expr $ac_mid + 1`
8559                     if test $ac_lo -le $ac_mid; then
8560                       ac_lo= ac_hi=
8561                       break
8562                     fi
8563                     ac_mid=`expr 2 '*' $ac_mid + 1`
8564 fi
8565 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8566   done
8567 else
8568   echo "$as_me: failed program was:" >&5
8569 sed 's/^/| /' conftest.$ac_ext >&5
8570
8571 cat >conftest.$ac_ext <<_ACEOF
8572 /* confdefs.h.  */
8573 _ACEOF
8574 cat confdefs.h >>conftest.$ac_ext
8575 cat >>conftest.$ac_ext <<_ACEOF
8576 /* end confdefs.h.  */
8577 $ac_includes_default
8578 int
8579 main ()
8580 {
8581 static int test_array [1 - 2 * !(((long) (sizeof (int))) < 0)];
8582 test_array [0] = 0
8583
8584   ;
8585   return 0;
8586 }
8587 _ACEOF
8588 rm -f conftest.$ac_objext
8589 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8590   (eval $ac_compile) 2>conftest.er1
8591   ac_status=$?
8592   grep -v '^ *+' conftest.er1 >conftest.err
8593   rm -f conftest.er1
8594   cat conftest.err >&5
8595   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8596   (exit $ac_status); } &&
8597          { ac_try='test -z "$ac_c_werror_flag"
8598                          || test ! -s conftest.err'
8599   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8600   (eval $ac_try) 2>&5
8601   ac_status=$?
8602   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8603   (exit $ac_status); }; } &&
8604          { ac_try='test -s conftest.$ac_objext'
8605   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8606   (eval $ac_try) 2>&5
8607   ac_status=$?
8608   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8609   (exit $ac_status); }; }; then
8610   ac_hi=-1 ac_mid=-1
8611   while :; do
8612     cat >conftest.$ac_ext <<_ACEOF
8613 /* confdefs.h.  */
8614 _ACEOF
8615 cat confdefs.h >>conftest.$ac_ext
8616 cat >>conftest.$ac_ext <<_ACEOF
8617 /* end confdefs.h.  */
8618 $ac_includes_default
8619 int
8620 main ()
8621 {
8622 static int test_array [1 - 2 * !(((long) (sizeof (int))) >= $ac_mid)];
8623 test_array [0] = 0
8624
8625   ;
8626   return 0;
8627 }
8628 _ACEOF
8629 rm -f conftest.$ac_objext
8630 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8631   (eval $ac_compile) 2>conftest.er1
8632   ac_status=$?
8633   grep -v '^ *+' conftest.er1 >conftest.err
8634   rm -f conftest.er1
8635   cat conftest.err >&5
8636   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8637   (exit $ac_status); } &&
8638          { ac_try='test -z "$ac_c_werror_flag"
8639                          || test ! -s conftest.err'
8640   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8641   (eval $ac_try) 2>&5
8642   ac_status=$?
8643   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8644   (exit $ac_status); }; } &&
8645          { ac_try='test -s conftest.$ac_objext'
8646   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8647   (eval $ac_try) 2>&5
8648   ac_status=$?
8649   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8650   (exit $ac_status); }; }; then
8651   ac_lo=$ac_mid; break
8652 else
8653   echo "$as_me: failed program was:" >&5
8654 sed 's/^/| /' conftest.$ac_ext >&5
8655
8656 ac_hi=`expr '(' $ac_mid ')' - 1`
8657                        if test $ac_mid -le $ac_hi; then
8658                          ac_lo= ac_hi=
8659                          break
8660                        fi
8661                        ac_mid=`expr 2 '*' $ac_mid`
8662 fi
8663 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8664   done
8665 else
8666   echo "$as_me: failed program was:" >&5
8667 sed 's/^/| /' conftest.$ac_ext >&5
8668
8669 ac_lo= ac_hi=
8670 fi
8671 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8672 fi
8673 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8674 # Binary search between lo and hi bounds.
8675 while test "x$ac_lo" != "x$ac_hi"; do
8676   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
8677   cat >conftest.$ac_ext <<_ACEOF
8678 /* confdefs.h.  */
8679 _ACEOF
8680 cat confdefs.h >>conftest.$ac_ext
8681 cat >>conftest.$ac_ext <<_ACEOF
8682 /* end confdefs.h.  */
8683 $ac_includes_default
8684 int
8685 main ()
8686 {
8687 static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)];
8688 test_array [0] = 0
8689
8690   ;
8691   return 0;
8692 }
8693 _ACEOF
8694 rm -f conftest.$ac_objext
8695 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8696   (eval $ac_compile) 2>conftest.er1
8697   ac_status=$?
8698   grep -v '^ *+' conftest.er1 >conftest.err
8699   rm -f conftest.er1
8700   cat conftest.err >&5
8701   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8702   (exit $ac_status); } &&
8703          { ac_try='test -z "$ac_c_werror_flag"
8704                          || test ! -s conftest.err'
8705   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8706   (eval $ac_try) 2>&5
8707   ac_status=$?
8708   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8709   (exit $ac_status); }; } &&
8710          { ac_try='test -s conftest.$ac_objext'
8711   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8712   (eval $ac_try) 2>&5
8713   ac_status=$?
8714   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8715   (exit $ac_status); }; }; then
8716   ac_hi=$ac_mid
8717 else
8718   echo "$as_me: failed program was:" >&5
8719 sed 's/^/| /' conftest.$ac_ext >&5
8720
8721 ac_lo=`expr '(' $ac_mid ')' + 1`
8722 fi
8723 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8724 done
8725 case $ac_lo in
8726 ?*) ac_cv_sizeof_int=$ac_lo;;
8727 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77
8728 See \`config.log' for more details." >&5
8729 echo "$as_me: error: cannot compute sizeof (int), 77
8730 See \`config.log' for more details." >&2;}
8731    { (exit 1); exit 1; }; } ;;
8732 esac
8733 else
8734   if test "$cross_compiling" = yes; then
8735   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
8736 See \`config.log' for more details." >&5
8737 echo "$as_me: error: cannot run test program while cross compiling
8738 See \`config.log' for more details." >&2;}
8739    { (exit 1); exit 1; }; }
8740 else
8741   cat >conftest.$ac_ext <<_ACEOF
8742 /* confdefs.h.  */
8743 _ACEOF
8744 cat confdefs.h >>conftest.$ac_ext
8745 cat >>conftest.$ac_ext <<_ACEOF
8746 /* end confdefs.h.  */
8747 $ac_includes_default
8748 long longval () { return (long) (sizeof (int)); }
8749 unsigned long ulongval () { return (long) (sizeof (int)); }
8750 #include <stdio.h>
8751 #include <stdlib.h>
8752 int
8753 main ()
8754 {
8755
8756   FILE *f = fopen ("conftest.val", "w");
8757   if (! f)
8758     exit (1);
8759   if (((long) (sizeof (int))) < 0)
8760     {
8761       long i = longval ();
8762       if (i != ((long) (sizeof (int))))
8763         exit (1);
8764       fprintf (f, "%ld\n", i);
8765     }
8766   else
8767     {
8768       unsigned long i = ulongval ();
8769       if (i != ((long) (sizeof (int))))
8770         exit (1);
8771       fprintf (f, "%lu\n", i);
8772     }
8773   exit (ferror (f) || fclose (f) != 0);
8774
8775   ;
8776   return 0;
8777 }
8778 _ACEOF
8779 rm -f conftest$ac_exeext
8780 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8781   (eval $ac_link) 2>&5
8782   ac_status=$?
8783   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8784   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8785   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8786   (eval $ac_try) 2>&5
8787   ac_status=$?
8788   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8789   (exit $ac_status); }; }; then
8790   ac_cv_sizeof_int=`cat conftest.val`
8791 else
8792   echo "$as_me: program exited with status $ac_status" >&5
8793 echo "$as_me: failed program was:" >&5
8794 sed 's/^/| /' conftest.$ac_ext >&5
8795
8796 ( exit $ac_status )
8797 { { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77
8798 See \`config.log' for more details." >&5
8799 echo "$as_me: error: cannot compute sizeof (int), 77
8800 See \`config.log' for more details." >&2;}
8801    { (exit 1); exit 1; }; }
8802 fi
8803 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8804 fi
8805 fi
8806 rm -f conftest.val
8807 else
8808   ac_cv_sizeof_int=0
8809 fi
8810 fi
8811 echo "$as_me:$LINENO: result: $ac_cv_sizeof_int" >&5
8812 echo "${ECHO_T}$ac_cv_sizeof_int" >&6
8813 cat >>confdefs.h <<_ACEOF
8814 #define SIZEOF_INT $ac_cv_sizeof_int
8815 _ACEOF
8816
8817
8818   echo "$as_me:$LINENO: checking for short" >&5
8819 echo $ECHO_N "checking for short... $ECHO_C" >&6
8820 if test "${ac_cv_type_short+set}" = set; then
8821   echo $ECHO_N "(cached) $ECHO_C" >&6
8822 else
8823   cat >conftest.$ac_ext <<_ACEOF
8824 /* confdefs.h.  */
8825 _ACEOF
8826 cat confdefs.h >>conftest.$ac_ext
8827 cat >>conftest.$ac_ext <<_ACEOF
8828 /* end confdefs.h.  */
8829 $ac_includes_default
8830 int
8831 main ()
8832 {
8833 if ((short *) 0)
8834   return 0;
8835 if (sizeof (short))
8836   return 0;
8837   ;
8838   return 0;
8839 }
8840 _ACEOF
8841 rm -f conftest.$ac_objext
8842 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8843   (eval $ac_compile) 2>conftest.er1
8844   ac_status=$?
8845   grep -v '^ *+' conftest.er1 >conftest.err
8846   rm -f conftest.er1
8847   cat conftest.err >&5
8848   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8849   (exit $ac_status); } &&
8850          { ac_try='test -z "$ac_c_werror_flag"
8851                          || test ! -s conftest.err'
8852   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8853   (eval $ac_try) 2>&5
8854   ac_status=$?
8855   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8856   (exit $ac_status); }; } &&
8857          { ac_try='test -s conftest.$ac_objext'
8858   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8859   (eval $ac_try) 2>&5
8860   ac_status=$?
8861   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8862   (exit $ac_status); }; }; then
8863   ac_cv_type_short=yes
8864 else
8865   echo "$as_me: failed program was:" >&5
8866 sed 's/^/| /' conftest.$ac_ext >&5
8867
8868 ac_cv_type_short=no
8869 fi
8870 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8871 fi
8872 echo "$as_me:$LINENO: result: $ac_cv_type_short" >&5
8873 echo "${ECHO_T}$ac_cv_type_short" >&6
8874
8875 echo "$as_me:$LINENO: checking size of short" >&5
8876 echo $ECHO_N "checking size of short... $ECHO_C" >&6
8877 if test "${ac_cv_sizeof_short+set}" = set; then
8878   echo $ECHO_N "(cached) $ECHO_C" >&6
8879 else
8880   if test "$ac_cv_type_short" = yes; then
8881   # The cast to unsigned long works around a bug in the HP C Compiler
8882   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
8883   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
8884   # This bug is HP SR number 8606223364.
8885   if test "$cross_compiling" = yes; then
8886   # Depending upon the size, compute the lo and hi bounds.
8887 cat >conftest.$ac_ext <<_ACEOF
8888 /* confdefs.h.  */
8889 _ACEOF
8890 cat confdefs.h >>conftest.$ac_ext
8891 cat >>conftest.$ac_ext <<_ACEOF
8892 /* end confdefs.h.  */
8893 $ac_includes_default
8894 int
8895 main ()
8896 {
8897 static int test_array [1 - 2 * !(((long) (sizeof (short))) >= 0)];
8898 test_array [0] = 0
8899
8900   ;
8901   return 0;
8902 }
8903 _ACEOF
8904 rm -f conftest.$ac_objext
8905 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8906   (eval $ac_compile) 2>conftest.er1
8907   ac_status=$?
8908   grep -v '^ *+' conftest.er1 >conftest.err
8909   rm -f conftest.er1
8910   cat conftest.err >&5
8911   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8912   (exit $ac_status); } &&
8913          { ac_try='test -z "$ac_c_werror_flag"
8914                          || test ! -s conftest.err'
8915   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8916   (eval $ac_try) 2>&5
8917   ac_status=$?
8918   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8919   (exit $ac_status); }; } &&
8920          { ac_try='test -s conftest.$ac_objext'
8921   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8922   (eval $ac_try) 2>&5
8923   ac_status=$?
8924   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8925   (exit $ac_status); }; }; then
8926   ac_lo=0 ac_mid=0
8927   while :; do
8928     cat >conftest.$ac_ext <<_ACEOF
8929 /* confdefs.h.  */
8930 _ACEOF
8931 cat confdefs.h >>conftest.$ac_ext
8932 cat >>conftest.$ac_ext <<_ACEOF
8933 /* end confdefs.h.  */
8934 $ac_includes_default
8935 int
8936 main ()
8937 {
8938 static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)];
8939 test_array [0] = 0
8940
8941   ;
8942   return 0;
8943 }
8944 _ACEOF
8945 rm -f conftest.$ac_objext
8946 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8947   (eval $ac_compile) 2>conftest.er1
8948   ac_status=$?
8949   grep -v '^ *+' conftest.er1 >conftest.err
8950   rm -f conftest.er1
8951   cat conftest.err >&5
8952   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8953   (exit $ac_status); } &&
8954          { ac_try='test -z "$ac_c_werror_flag"
8955                          || test ! -s conftest.err'
8956   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8957   (eval $ac_try) 2>&5
8958   ac_status=$?
8959   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8960   (exit $ac_status); }; } &&
8961          { ac_try='test -s conftest.$ac_objext'
8962   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8963   (eval $ac_try) 2>&5
8964   ac_status=$?
8965   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8966   (exit $ac_status); }; }; then
8967   ac_hi=$ac_mid; break
8968 else
8969   echo "$as_me: failed program was:" >&5
8970 sed 's/^/| /' conftest.$ac_ext >&5
8971
8972 ac_lo=`expr $ac_mid + 1`
8973                     if test $ac_lo -le $ac_mid; then
8974                       ac_lo= ac_hi=
8975                       break
8976                     fi
8977                     ac_mid=`expr 2 '*' $ac_mid + 1`
8978 fi
8979 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8980   done
8981 else
8982   echo "$as_me: failed program was:" >&5
8983 sed 's/^/| /' conftest.$ac_ext >&5
8984
8985 cat >conftest.$ac_ext <<_ACEOF
8986 /* confdefs.h.  */
8987 _ACEOF
8988 cat confdefs.h >>conftest.$ac_ext
8989 cat >>conftest.$ac_ext <<_ACEOF
8990 /* end confdefs.h.  */
8991 $ac_includes_default
8992 int
8993 main ()
8994 {
8995 static int test_array [1 - 2 * !(((long) (sizeof (short))) < 0)];
8996 test_array [0] = 0
8997
8998   ;
8999   return 0;
9000 }
9001 _ACEOF
9002 rm -f conftest.$ac_objext
9003 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9004   (eval $ac_compile) 2>conftest.er1
9005   ac_status=$?
9006   grep -v '^ *+' conftest.er1 >conftest.err
9007   rm -f conftest.er1
9008   cat conftest.err >&5
9009   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9010   (exit $ac_status); } &&
9011          { ac_try='test -z "$ac_c_werror_flag"
9012                          || test ! -s conftest.err'
9013   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9014   (eval $ac_try) 2>&5
9015   ac_status=$?
9016   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9017   (exit $ac_status); }; } &&
9018          { ac_try='test -s conftest.$ac_objext'
9019   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9020   (eval $ac_try) 2>&5
9021   ac_status=$?
9022   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9023   (exit $ac_status); }; }; then
9024   ac_hi=-1 ac_mid=-1
9025   while :; do
9026     cat >conftest.$ac_ext <<_ACEOF
9027 /* confdefs.h.  */
9028 _ACEOF
9029 cat confdefs.h >>conftest.$ac_ext
9030 cat >>conftest.$ac_ext <<_ACEOF
9031 /* end confdefs.h.  */
9032 $ac_includes_default
9033 int
9034 main ()
9035 {
9036 static int test_array [1 - 2 * !(((long) (sizeof (short))) >= $ac_mid)];
9037 test_array [0] = 0
9038
9039   ;
9040   return 0;
9041 }
9042 _ACEOF
9043 rm -f conftest.$ac_objext
9044 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9045   (eval $ac_compile) 2>conftest.er1
9046   ac_status=$?
9047   grep -v '^ *+' conftest.er1 >conftest.err
9048   rm -f conftest.er1
9049   cat conftest.err >&5
9050   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9051   (exit $ac_status); } &&
9052          { ac_try='test -z "$ac_c_werror_flag"
9053                          || test ! -s conftest.err'
9054   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9055   (eval $ac_try) 2>&5
9056   ac_status=$?
9057   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9058   (exit $ac_status); }; } &&
9059          { ac_try='test -s conftest.$ac_objext'
9060   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9061   (eval $ac_try) 2>&5
9062   ac_status=$?
9063   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9064   (exit $ac_status); }; }; then
9065   ac_lo=$ac_mid; break
9066 else
9067   echo "$as_me: failed program was:" >&5
9068 sed 's/^/| /' conftest.$ac_ext >&5
9069
9070 ac_hi=`expr '(' $ac_mid ')' - 1`
9071                        if test $ac_mid -le $ac_hi; then
9072                          ac_lo= ac_hi=
9073                          break
9074                        fi
9075                        ac_mid=`expr 2 '*' $ac_mid`
9076 fi
9077 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9078   done
9079 else
9080   echo "$as_me: failed program was:" >&5
9081 sed 's/^/| /' conftest.$ac_ext >&5
9082
9083 ac_lo= ac_hi=
9084 fi
9085 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9086 fi
9087 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9088 # Binary search between lo and hi bounds.
9089 while test "x$ac_lo" != "x$ac_hi"; do
9090   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
9091   cat >conftest.$ac_ext <<_ACEOF
9092 /* confdefs.h.  */
9093 _ACEOF
9094 cat confdefs.h >>conftest.$ac_ext
9095 cat >>conftest.$ac_ext <<_ACEOF
9096 /* end confdefs.h.  */
9097 $ac_includes_default
9098 int
9099 main ()
9100 {
9101 static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)];
9102 test_array [0] = 0
9103
9104   ;
9105   return 0;
9106 }
9107 _ACEOF
9108 rm -f conftest.$ac_objext
9109 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9110   (eval $ac_compile) 2>conftest.er1
9111   ac_status=$?
9112   grep -v '^ *+' conftest.er1 >conftest.err
9113   rm -f conftest.er1
9114   cat conftest.err >&5
9115   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9116   (exit $ac_status); } &&
9117          { ac_try='test -z "$ac_c_werror_flag"
9118                          || test ! -s conftest.err'
9119   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9120   (eval $ac_try) 2>&5
9121   ac_status=$?
9122   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9123   (exit $ac_status); }; } &&
9124          { ac_try='test -s conftest.$ac_objext'
9125   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9126   (eval $ac_try) 2>&5
9127   ac_status=$?
9128   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9129   (exit $ac_status); }; }; then
9130   ac_hi=$ac_mid
9131 else
9132   echo "$as_me: failed program was:" >&5
9133 sed 's/^/| /' conftest.$ac_ext >&5
9134
9135 ac_lo=`expr '(' $ac_mid ')' + 1`
9136 fi
9137 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9138 done
9139 case $ac_lo in
9140 ?*) ac_cv_sizeof_short=$ac_lo;;
9141 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77
9142 See \`config.log' for more details." >&5
9143 echo "$as_me: error: cannot compute sizeof (short), 77
9144 See \`config.log' for more details." >&2;}
9145    { (exit 1); exit 1; }; } ;;
9146 esac
9147 else
9148   if test "$cross_compiling" = yes; then
9149   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
9150 See \`config.log' for more details." >&5
9151 echo "$as_me: error: cannot run test program while cross compiling
9152 See \`config.log' for more details." >&2;}
9153    { (exit 1); exit 1; }; }
9154 else
9155   cat >conftest.$ac_ext <<_ACEOF
9156 /* confdefs.h.  */
9157 _ACEOF
9158 cat confdefs.h >>conftest.$ac_ext
9159 cat >>conftest.$ac_ext <<_ACEOF
9160 /* end confdefs.h.  */
9161 $ac_includes_default
9162 long longval () { return (long) (sizeof (short)); }
9163 unsigned long ulongval () { return (long) (sizeof (short)); }
9164 #include <stdio.h>
9165 #include <stdlib.h>
9166 int
9167 main ()
9168 {
9169
9170   FILE *f = fopen ("conftest.val", "w");
9171   if (! f)
9172     exit (1);
9173   if (((long) (sizeof (short))) < 0)
9174     {
9175       long i = longval ();
9176       if (i != ((long) (sizeof (short))))
9177         exit (1);
9178       fprintf (f, "%ld\n", i);
9179     }
9180   else
9181     {
9182       unsigned long i = ulongval ();
9183       if (i != ((long) (sizeof (short))))
9184         exit (1);
9185       fprintf (f, "%lu\n", i);
9186     }
9187   exit (ferror (f) || fclose (f) != 0);
9188
9189   ;
9190   return 0;
9191 }
9192 _ACEOF
9193 rm -f conftest$ac_exeext
9194 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9195   (eval $ac_link) 2>&5
9196   ac_status=$?
9197   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9198   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9199   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9200   (eval $ac_try) 2>&5
9201   ac_status=$?
9202   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9203   (exit $ac_status); }; }; then
9204   ac_cv_sizeof_short=`cat conftest.val`
9205 else
9206   echo "$as_me: program exited with status $ac_status" >&5
9207 echo "$as_me: failed program was:" >&5
9208 sed 's/^/| /' conftest.$ac_ext >&5
9209
9210 ( exit $ac_status )
9211 { { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77
9212 See \`config.log' for more details." >&5
9213 echo "$as_me: error: cannot compute sizeof (short), 77
9214 See \`config.log' for more details." >&2;}
9215    { (exit 1); exit 1; }; }
9216 fi
9217 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9218 fi
9219 fi
9220 rm -f conftest.val
9221 else
9222   ac_cv_sizeof_short=0
9223 fi
9224 fi
9225 echo "$as_me:$LINENO: result: $ac_cv_sizeof_short" >&5
9226 echo "${ECHO_T}$ac_cv_sizeof_short" >&6
9227 cat >>confdefs.h <<_ACEOF
9228 #define SIZEOF_SHORT $ac_cv_sizeof_short
9229 _ACEOF
9230
9231
9232   echo "$as_me:$LINENO: checking for char" >&5
9233 echo $ECHO_N "checking for char... $ECHO_C" >&6
9234 if test "${ac_cv_type_char+set}" = set; then
9235   echo $ECHO_N "(cached) $ECHO_C" >&6
9236 else
9237   cat >conftest.$ac_ext <<_ACEOF
9238 /* confdefs.h.  */
9239 _ACEOF
9240 cat confdefs.h >>conftest.$ac_ext
9241 cat >>conftest.$ac_ext <<_ACEOF
9242 /* end confdefs.h.  */
9243 $ac_includes_default
9244 int
9245 main ()
9246 {
9247 if ((char *) 0)
9248   return 0;
9249 if (sizeof (char))
9250   return 0;
9251   ;
9252   return 0;
9253 }
9254 _ACEOF
9255 rm -f conftest.$ac_objext
9256 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9257   (eval $ac_compile) 2>conftest.er1
9258   ac_status=$?
9259   grep -v '^ *+' conftest.er1 >conftest.err
9260   rm -f conftest.er1
9261   cat conftest.err >&5
9262   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9263   (exit $ac_status); } &&
9264          { ac_try='test -z "$ac_c_werror_flag"
9265                          || test ! -s conftest.err'
9266   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9267   (eval $ac_try) 2>&5
9268   ac_status=$?
9269   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9270   (exit $ac_status); }; } &&
9271          { ac_try='test -s conftest.$ac_objext'
9272   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9273   (eval $ac_try) 2>&5
9274   ac_status=$?
9275   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9276   (exit $ac_status); }; }; then
9277   ac_cv_type_char=yes
9278 else
9279   echo "$as_me: failed program was:" >&5
9280 sed 's/^/| /' conftest.$ac_ext >&5
9281
9282 ac_cv_type_char=no
9283 fi
9284 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9285 fi
9286 echo "$as_me:$LINENO: result: $ac_cv_type_char" >&5
9287 echo "${ECHO_T}$ac_cv_type_char" >&6
9288
9289 echo "$as_me:$LINENO: checking size of char" >&5
9290 echo $ECHO_N "checking size of char... $ECHO_C" >&6
9291 if test "${ac_cv_sizeof_char+set}" = set; then
9292   echo $ECHO_N "(cached) $ECHO_C" >&6
9293 else
9294   if test "$ac_cv_type_char" = yes; then
9295   # The cast to unsigned long works around a bug in the HP C Compiler
9296   # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
9297   # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
9298   # This bug is HP SR number 8606223364.
9299   if test "$cross_compiling" = yes; then
9300   # Depending upon the size, compute the lo and hi bounds.
9301 cat >conftest.$ac_ext <<_ACEOF
9302 /* confdefs.h.  */
9303 _ACEOF
9304 cat confdefs.h >>conftest.$ac_ext
9305 cat >>conftest.$ac_ext <<_ACEOF
9306 /* end confdefs.h.  */
9307 $ac_includes_default
9308 int
9309 main ()
9310 {
9311 static int test_array [1 - 2 * !(((long) (sizeof (char))) >= 0)];
9312 test_array [0] = 0
9313
9314   ;
9315   return 0;
9316 }
9317 _ACEOF
9318 rm -f conftest.$ac_objext
9319 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9320   (eval $ac_compile) 2>conftest.er1
9321   ac_status=$?
9322   grep -v '^ *+' conftest.er1 >conftest.err
9323   rm -f conftest.er1
9324   cat conftest.err >&5
9325   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9326   (exit $ac_status); } &&
9327          { ac_try='test -z "$ac_c_werror_flag"
9328                          || test ! -s conftest.err'
9329   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9330   (eval $ac_try) 2>&5
9331   ac_status=$?
9332   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9333   (exit $ac_status); }; } &&
9334          { ac_try='test -s conftest.$ac_objext'
9335   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9336   (eval $ac_try) 2>&5
9337   ac_status=$?
9338   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9339   (exit $ac_status); }; }; then
9340   ac_lo=0 ac_mid=0
9341   while :; do
9342     cat >conftest.$ac_ext <<_ACEOF
9343 /* confdefs.h.  */
9344 _ACEOF
9345 cat confdefs.h >>conftest.$ac_ext
9346 cat >>conftest.$ac_ext <<_ACEOF
9347 /* end confdefs.h.  */
9348 $ac_includes_default
9349 int
9350 main ()
9351 {
9352 static int test_array [1 - 2 * !(((long) (sizeof (char))) <= $ac_mid)];
9353 test_array [0] = 0
9354
9355   ;
9356   return 0;
9357 }
9358 _ACEOF
9359 rm -f conftest.$ac_objext
9360 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9361   (eval $ac_compile) 2>conftest.er1
9362   ac_status=$?
9363   grep -v '^ *+' conftest.er1 >conftest.err
9364   rm -f conftest.er1
9365   cat conftest.err >&5
9366   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9367   (exit $ac_status); } &&
9368          { ac_try='test -z "$ac_c_werror_flag"
9369                          || test ! -s conftest.err'
9370   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9371   (eval $ac_try) 2>&5
9372   ac_status=$?
9373   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9374   (exit $ac_status); }; } &&
9375          { ac_try='test -s conftest.$ac_objext'
9376   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9377   (eval $ac_try) 2>&5
9378   ac_status=$?
9379   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9380   (exit $ac_status); }; }; then
9381   ac_hi=$ac_mid; break
9382 else
9383   echo "$as_me: failed program was:" >&5
9384 sed 's/^/| /' conftest.$ac_ext >&5
9385
9386 ac_lo=`expr $ac_mid + 1`
9387                     if test $ac_lo -le $ac_mid; then
9388                       ac_lo= ac_hi=
9389                       break
9390                     fi
9391                     ac_mid=`expr 2 '*' $ac_mid + 1`
9392 fi
9393 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9394   done
9395 else
9396   echo "$as_me: failed program was:" >&5
9397 sed 's/^/| /' conftest.$ac_ext >&5
9398
9399 cat >conftest.$ac_ext <<_ACEOF
9400 /* confdefs.h.  */
9401 _ACEOF
9402 cat confdefs.h >>conftest.$ac_ext
9403 cat >>conftest.$ac_ext <<_ACEOF
9404 /* end confdefs.h.  */
9405 $ac_includes_default
9406 int
9407 main ()
9408 {
9409 static int test_array [1 - 2 * !(((long) (sizeof (char))) < 0)];
9410 test_array [0] = 0
9411
9412   ;
9413   return 0;
9414 }
9415 _ACEOF
9416 rm -f conftest.$ac_objext
9417 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9418   (eval $ac_compile) 2>conftest.er1
9419   ac_status=$?
9420   grep -v '^ *+' conftest.er1 >conftest.err
9421   rm -f conftest.er1
9422   cat conftest.err >&5
9423   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9424   (exit $ac_status); } &&
9425          { ac_try='test -z "$ac_c_werror_flag"
9426                          || test ! -s conftest.err'
9427   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9428   (eval $ac_try) 2>&5
9429   ac_status=$?
9430   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9431   (exit $ac_status); }; } &&
9432          { ac_try='test -s conftest.$ac_objext'
9433   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9434   (eval $ac_try) 2>&5
9435   ac_status=$?
9436   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9437   (exit $ac_status); }; }; then
9438   ac_hi=-1 ac_mid=-1
9439   while :; do
9440     cat >conftest.$ac_ext <<_ACEOF
9441 /* confdefs.h.  */
9442 _ACEOF
9443 cat confdefs.h >>conftest.$ac_ext
9444 cat >>conftest.$ac_ext <<_ACEOF
9445 /* end confdefs.h.  */
9446 $ac_includes_default
9447 int
9448 main ()
9449 {
9450 static int test_array [1 - 2 * !(((long) (sizeof (char))) >= $ac_mid)];
9451 test_array [0] = 0
9452
9453   ;
9454   return 0;
9455 }
9456 _ACEOF
9457 rm -f conftest.$ac_objext
9458 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9459   (eval $ac_compile) 2>conftest.er1
9460   ac_status=$?
9461   grep -v '^ *+' conftest.er1 >conftest.err
9462   rm -f conftest.er1
9463   cat conftest.err >&5
9464   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9465   (exit $ac_status); } &&
9466          { ac_try='test -z "$ac_c_werror_flag"
9467                          || test ! -s conftest.err'
9468   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9469   (eval $ac_try) 2>&5
9470   ac_status=$?
9471   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9472   (exit $ac_status); }; } &&
9473          { ac_try='test -s conftest.$ac_objext'
9474   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9475   (eval $ac_try) 2>&5
9476   ac_status=$?
9477   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9478   (exit $ac_status); }; }; then
9479   ac_lo=$ac_mid; break
9480 else
9481   echo "$as_me: failed program was:" >&5
9482 sed 's/^/| /' conftest.$ac_ext >&5
9483
9484 ac_hi=`expr '(' $ac_mid ')' - 1`
9485                        if test $ac_mid -le $ac_hi; then
9486                          ac_lo= ac_hi=
9487                          break
9488                        fi
9489                        ac_mid=`expr 2 '*' $ac_mid`
9490 fi
9491 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9492   done
9493 else
9494   echo "$as_me: failed program was:" >&5
9495 sed 's/^/| /' conftest.$ac_ext >&5
9496
9497 ac_lo= ac_hi=
9498 fi
9499 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9500 fi
9501 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9502 # Binary search between lo and hi bounds.
9503 while test "x$ac_lo" != "x$ac_hi"; do
9504   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
9505   cat >conftest.$ac_ext <<_ACEOF
9506 /* confdefs.h.  */
9507 _ACEOF
9508 cat confdefs.h >>conftest.$ac_ext
9509 cat >>conftest.$ac_ext <<_ACEOF
9510 /* end confdefs.h.  */
9511 $ac_includes_default
9512 int
9513 main ()
9514 {
9515 static int test_array [1 - 2 * !(((long) (sizeof (char))) <= $ac_mid)];
9516 test_array [0] = 0
9517
9518   ;
9519   return 0;
9520 }
9521 _ACEOF
9522 rm -f conftest.$ac_objext
9523 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9524   (eval $ac_compile) 2>conftest.er1
9525   ac_status=$?
9526   grep -v '^ *+' conftest.er1 >conftest.err
9527   rm -f conftest.er1
9528   cat conftest.err >&5
9529   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9530   (exit $ac_status); } &&
9531          { ac_try='test -z "$ac_c_werror_flag"
9532                          || test ! -s conftest.err'
9533   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9534   (eval $ac_try) 2>&5
9535   ac_status=$?
9536   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9537   (exit $ac_status); }; } &&
9538          { ac_try='test -s conftest.$ac_objext'
9539   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9540   (eval $ac_try) 2>&5
9541   ac_status=$?
9542   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9543   (exit $ac_status); }; }; then
9544   ac_hi=$ac_mid
9545 else
9546   echo "$as_me: failed program was:" >&5
9547 sed 's/^/| /' conftest.$ac_ext >&5
9548
9549 ac_lo=`expr '(' $ac_mid ')' + 1`
9550 fi
9551 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9552 done
9553 case $ac_lo in
9554 ?*) ac_cv_sizeof_char=$ac_lo;;
9555 '') { { echo "$as_me:$LINENO: error: cannot compute sizeof (char), 77
9556 See \`config.log' for more details." >&5
9557 echo "$as_me: error: cannot compute sizeof (char), 77
9558 See \`config.log' for more details." >&2;}
9559    { (exit 1); exit 1; }; } ;;
9560 esac
9561 else
9562   if test "$cross_compiling" = yes; then
9563   { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
9564 See \`config.log' for more details." >&5
9565 echo "$as_me: error: cannot run test program while cross compiling
9566 See \`config.log' for more details." >&2;}
9567    { (exit 1); exit 1; }; }
9568 else
9569   cat >conftest.$ac_ext <<_ACEOF
9570 /* confdefs.h.  */
9571 _ACEOF
9572 cat confdefs.h >>conftest.$ac_ext
9573 cat >>conftest.$ac_ext <<_ACEOF
9574 /* end confdefs.h.  */
9575 $ac_includes_default
9576 long longval () { return (long) (sizeof (char)); }
9577 unsigned long ulongval () { return (long) (sizeof (char)); }
9578 #include <stdio.h>
9579 #include <stdlib.h>
9580 int
9581 main ()
9582 {
9583
9584   FILE *f = fopen ("conftest.val", "w");
9585   if (! f)
9586     exit (1);
9587   if (((long) (sizeof (char))) < 0)
9588     {
9589       long i = longval ();
9590       if (i != ((long) (sizeof (char))))
9591         exit (1);
9592       fprintf (f, "%ld\n", i);
9593     }
9594   else
9595     {
9596       unsigned long i = ulongval ();
9597       if (i != ((long) (sizeof (char))))
9598         exit (1);
9599       fprintf (f, "%lu\n", i);
9600     }
9601   exit (ferror (f) || fclose (f) != 0);
9602
9603   ;
9604   return 0;
9605 }
9606 _ACEOF
9607 rm -f conftest$ac_exeext
9608 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9609   (eval $ac_link) 2>&5
9610   ac_status=$?
9611   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9612   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9613   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9614   (eval $ac_try) 2>&5
9615   ac_status=$?
9616   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9617   (exit $ac_status); }; }; then
9618   ac_cv_sizeof_char=`cat conftest.val`
9619 else
9620   echo "$as_me: program exited with status $ac_status" >&5
9621 echo "$as_me: failed program was:" >&5
9622 sed 's/^/| /' conftest.$ac_ext >&5
9623
9624 ( exit $ac_status )
9625 { { echo "$as_me:$LINENO: error: cannot compute sizeof (char), 77
9626 See \`config.log' for more details." >&5
9627 echo "$as_me: error: cannot compute sizeof (char), 77
9628 See \`config.log' for more details." >&2;}
9629    { (exit 1); exit 1; }; }
9630 fi
9631 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9632 fi
9633 fi
9634 rm -f conftest.val
9635 else
9636   ac_cv_sizeof_char=0
9637 fi
9638 fi
9639 echo "$as_me:$LINENO: result: $ac_cv_sizeof_char" >&5
9640 echo "${ECHO_T}$ac_cv_sizeof_char" >&6
9641 cat >>confdefs.h <<_ACEOF
9642 #define SIZEOF_CHAR $ac_cv_sizeof_char
9643 _ACEOF
9644
9645
9646
9647   echo "$as_me:$LINENO: checking for type equivalent to int8_t" >&5
9648 echo $ECHO_N "checking for type equivalent to int8_t... $ECHO_C" >&6
9649   case "$ac_cv_sizeof_char" in
9650     1) acx_cv_type_int8_t=char ;;
9651     *) { { echo "$as_me:$LINENO: error: no 8-bit type" >&5
9652 echo "$as_me: error: no 8-bit type" >&2;}
9653    { (exit please report a bug); exit please report a bug; }; }
9654   esac
9655   echo "$as_me:$LINENO: result: $acx_cv_type_int8_t" >&5
9656 echo "${ECHO_T}$acx_cv_type_int8_t" >&6
9657
9658   echo "$as_me:$LINENO: checking for type equivalent to int16_t" >&5
9659 echo $ECHO_N "checking for type equivalent to int16_t... $ECHO_C" >&6
9660   case "$ac_cv_sizeof_int:$ac_cv_sizeof_short" in
9661     2:*) acx_cv_type_int16_t=int ;;
9662     *:2) acx_cv_type_int16_t=short ;;
9663     *) { { echo "$as_me:$LINENO: error: no 16-bit type" >&5
9664 echo "$as_me: error: no 16-bit type" >&2;}
9665    { (exit please report a bug); exit please report a bug; }; }
9666   esac
9667   echo "$as_me:$LINENO: result: $acx_cv_type_int16_t" >&5
9668 echo "${ECHO_T}$acx_cv_type_int16_t" >&6
9669
9670   echo "$as_me:$LINENO: checking for type equivalent to int32_t" >&5
9671 echo $ECHO_N "checking for type equivalent to int32_t... $ECHO_C" >&6
9672   case "$ac_cv_sizeof_int:$ac_cv_sizeof_long" in
9673     4:*) acx_cv_type_int32_t=int ;;
9674     *:4) acx_cv_type_int32_t=long ;;
9675     *) { { echo "$as_me:$LINENO: error: no 32-bit type" >&5
9676 echo "$as_me: error: no 32-bit type" >&2;}
9677    { (exit please report a bug); exit please report a bug; }; }
9678   esac
9679   echo "$as_me:$LINENO: result: $acx_cv_type_int32_t" >&5
9680 echo "${ECHO_T}$acx_cv_type_int32_t" >&6
9681 fi
9682
9683 # These tests are here to make the output prettier
9684
9685 if test "$ac_cv_type_uint64_t" != yes && test "$ac_cv_type_u_int64_t" != yes; then
9686   case "$ac_cv_sizeof_long" in
9687     8) acx_cv_type_int64_t=long ;;
9688   esac
9689   echo "$as_me:$LINENO: checking for type equivalent to int64_t" >&5
9690 echo $ECHO_N "checking for type equivalent to int64_t... $ECHO_C" >&6
9691   echo "$as_me:$LINENO: result: ${acx_cv_type_int64_t-'using preprocessor symbols'}" >&5
9692 echo "${ECHO_T}${acx_cv_type_int64_t-'using preprocessor symbols'}" >&6
9693 fi
9694
9695 # Now we can use the above types
9696
9697 if test "$ac_cv_type_uintptr_t" != yes; then
9698   echo "$as_me:$LINENO: checking for type equivalent to intptr_t" >&5
9699 echo $ECHO_N "checking for type equivalent to intptr_t... $ECHO_C" >&6
9700   case $ac_cv_sizeof_void_p in
9701     2) acx_cv_type_intptr_t=int16_t ;;
9702     4) acx_cv_type_intptr_t=int32_t ;;
9703     8) acx_cv_type_intptr_t=int64_t ;;
9704     *) { { echo "$as_me:$LINENO: error: no equivalent for intptr_t" >&5
9705 echo "$as_me: error: no equivalent for intptr_t" >&2;}
9706    { (exit please report a bug); exit please report a bug; }; }
9707   esac
9708   echo "$as_me:$LINENO: result: $acx_cv_type_intptr_t" >&5
9709 echo "${ECHO_T}$acx_cv_type_intptr_t" >&6
9710 fi
9711
9712 # ----------------- done all checks, emit header -------------
9713           ac_config_commands="$ac_config_commands gstdint.h"
9714
9715
9716
9717
9718 echo "$as_me:$LINENO: checking for struct stat.st_blksize" >&5
9719 echo $ECHO_N "checking for struct stat.st_blksize... $ECHO_C" >&6
9720 if test "${ac_cv_member_struct_stat_st_blksize+set}" = set; then
9721   echo $ECHO_N "(cached) $ECHO_C" >&6
9722 else
9723   cat >conftest.$ac_ext <<_ACEOF
9724 /* confdefs.h.  */
9725 _ACEOF
9726 cat confdefs.h >>conftest.$ac_ext
9727 cat >>conftest.$ac_ext <<_ACEOF
9728 /* end confdefs.h.  */
9729 $ac_includes_default
9730 int
9731 main ()
9732 {
9733 static struct stat ac_aggr;
9734 if (ac_aggr.st_blksize)
9735 return 0;
9736   ;
9737   return 0;
9738 }
9739 _ACEOF
9740 rm -f conftest.$ac_objext
9741 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9742   (eval $ac_compile) 2>conftest.er1
9743   ac_status=$?
9744   grep -v '^ *+' conftest.er1 >conftest.err
9745   rm -f conftest.er1
9746   cat conftest.err >&5
9747   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9748   (exit $ac_status); } &&
9749          { ac_try='test -z "$ac_c_werror_flag"
9750                          || test ! -s conftest.err'
9751   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9752   (eval $ac_try) 2>&5
9753   ac_status=$?
9754   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9755   (exit $ac_status); }; } &&
9756          { ac_try='test -s conftest.$ac_objext'
9757   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9758   (eval $ac_try) 2>&5
9759   ac_status=$?
9760   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9761   (exit $ac_status); }; }; then
9762   ac_cv_member_struct_stat_st_blksize=yes
9763 else
9764   echo "$as_me: failed program was:" >&5
9765 sed 's/^/| /' conftest.$ac_ext >&5
9766
9767 cat >conftest.$ac_ext <<_ACEOF
9768 /* confdefs.h.  */
9769 _ACEOF
9770 cat confdefs.h >>conftest.$ac_ext
9771 cat >>conftest.$ac_ext <<_ACEOF
9772 /* end confdefs.h.  */
9773 $ac_includes_default
9774 int
9775 main ()
9776 {
9777 static struct stat ac_aggr;
9778 if (sizeof ac_aggr.st_blksize)
9779 return 0;
9780   ;
9781   return 0;
9782 }
9783 _ACEOF
9784 rm -f conftest.$ac_objext
9785 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9786   (eval $ac_compile) 2>conftest.er1
9787   ac_status=$?
9788   grep -v '^ *+' conftest.er1 >conftest.err
9789   rm -f conftest.er1
9790   cat conftest.err >&5
9791   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9792   (exit $ac_status); } &&
9793          { ac_try='test -z "$ac_c_werror_flag"
9794                          || test ! -s conftest.err'
9795   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9796   (eval $ac_try) 2>&5
9797   ac_status=$?
9798   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9799   (exit $ac_status); }; } &&
9800          { ac_try='test -s conftest.$ac_objext'
9801   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9802   (eval $ac_try) 2>&5
9803   ac_status=$?
9804   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9805   (exit $ac_status); }; }; then
9806   ac_cv_member_struct_stat_st_blksize=yes
9807 else
9808   echo "$as_me: failed program was:" >&5
9809 sed 's/^/| /' conftest.$ac_ext >&5
9810
9811 ac_cv_member_struct_stat_st_blksize=no
9812 fi
9813 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9814 fi
9815 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9816 fi
9817 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blksize" >&5
9818 echo "${ECHO_T}$ac_cv_member_struct_stat_st_blksize" >&6
9819 if test $ac_cv_member_struct_stat_st_blksize = yes; then
9820
9821 cat >>confdefs.h <<_ACEOF
9822 #define HAVE_STRUCT_STAT_ST_BLKSIZE 1
9823 _ACEOF
9824
9825
9826 fi
9827
9828 echo "$as_me:$LINENO: checking for struct stat.st_blocks" >&5
9829 echo $ECHO_N "checking for struct stat.st_blocks... $ECHO_C" >&6
9830 if test "${ac_cv_member_struct_stat_st_blocks+set}" = set; then
9831   echo $ECHO_N "(cached) $ECHO_C" >&6
9832 else
9833   cat >conftest.$ac_ext <<_ACEOF
9834 /* confdefs.h.  */
9835 _ACEOF
9836 cat confdefs.h >>conftest.$ac_ext
9837 cat >>conftest.$ac_ext <<_ACEOF
9838 /* end confdefs.h.  */
9839 $ac_includes_default
9840 int
9841 main ()
9842 {
9843 static struct stat ac_aggr;
9844 if (ac_aggr.st_blocks)
9845 return 0;
9846   ;
9847   return 0;
9848 }
9849 _ACEOF
9850 rm -f conftest.$ac_objext
9851 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9852   (eval $ac_compile) 2>conftest.er1
9853   ac_status=$?
9854   grep -v '^ *+' conftest.er1 >conftest.err
9855   rm -f conftest.er1
9856   cat conftest.err >&5
9857   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9858   (exit $ac_status); } &&
9859          { ac_try='test -z "$ac_c_werror_flag"
9860                          || test ! -s conftest.err'
9861   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9862   (eval $ac_try) 2>&5
9863   ac_status=$?
9864   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9865   (exit $ac_status); }; } &&
9866          { ac_try='test -s conftest.$ac_objext'
9867   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9868   (eval $ac_try) 2>&5
9869   ac_status=$?
9870   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9871   (exit $ac_status); }; }; then
9872   ac_cv_member_struct_stat_st_blocks=yes
9873 else
9874   echo "$as_me: failed program was:" >&5
9875 sed 's/^/| /' conftest.$ac_ext >&5
9876
9877 cat >conftest.$ac_ext <<_ACEOF
9878 /* confdefs.h.  */
9879 _ACEOF
9880 cat confdefs.h >>conftest.$ac_ext
9881 cat >>conftest.$ac_ext <<_ACEOF
9882 /* end confdefs.h.  */
9883 $ac_includes_default
9884 int
9885 main ()
9886 {
9887 static struct stat ac_aggr;
9888 if (sizeof ac_aggr.st_blocks)
9889 return 0;
9890   ;
9891   return 0;
9892 }
9893 _ACEOF
9894 rm -f conftest.$ac_objext
9895 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9896   (eval $ac_compile) 2>conftest.er1
9897   ac_status=$?
9898   grep -v '^ *+' conftest.er1 >conftest.err
9899   rm -f conftest.er1
9900   cat conftest.err >&5
9901   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9902   (exit $ac_status); } &&
9903          { ac_try='test -z "$ac_c_werror_flag"
9904                          || test ! -s conftest.err'
9905   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9906   (eval $ac_try) 2>&5
9907   ac_status=$?
9908   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9909   (exit $ac_status); }; } &&
9910          { ac_try='test -s conftest.$ac_objext'
9911   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9912   (eval $ac_try) 2>&5
9913   ac_status=$?
9914   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9915   (exit $ac_status); }; }; then
9916   ac_cv_member_struct_stat_st_blocks=yes
9917 else
9918   echo "$as_me: failed program was:" >&5
9919 sed 's/^/| /' conftest.$ac_ext >&5
9920
9921 ac_cv_member_struct_stat_st_blocks=no
9922 fi
9923 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9924 fi
9925 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9926 fi
9927 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blocks" >&5
9928 echo "${ECHO_T}$ac_cv_member_struct_stat_st_blocks" >&6
9929 if test $ac_cv_member_struct_stat_st_blocks = yes; then
9930
9931 cat >>confdefs.h <<_ACEOF
9932 #define HAVE_STRUCT_STAT_ST_BLOCKS 1
9933 _ACEOF
9934
9935
9936 fi
9937
9938 echo "$as_me:$LINENO: checking for struct stat.st_rdev" >&5
9939 echo $ECHO_N "checking for struct stat.st_rdev... $ECHO_C" >&6
9940 if test "${ac_cv_member_struct_stat_st_rdev+set}" = set; then
9941   echo $ECHO_N "(cached) $ECHO_C" >&6
9942 else
9943   cat >conftest.$ac_ext <<_ACEOF
9944 /* confdefs.h.  */
9945 _ACEOF
9946 cat confdefs.h >>conftest.$ac_ext
9947 cat >>conftest.$ac_ext <<_ACEOF
9948 /* end confdefs.h.  */
9949 $ac_includes_default
9950 int
9951 main ()
9952 {
9953 static struct stat ac_aggr;
9954 if (ac_aggr.st_rdev)
9955 return 0;
9956   ;
9957   return 0;
9958 }
9959 _ACEOF
9960 rm -f conftest.$ac_objext
9961 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9962   (eval $ac_compile) 2>conftest.er1
9963   ac_status=$?
9964   grep -v '^ *+' conftest.er1 >conftest.err
9965   rm -f conftest.er1
9966   cat conftest.err >&5
9967   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9968   (exit $ac_status); } &&
9969          { ac_try='test -z "$ac_c_werror_flag"
9970                          || test ! -s conftest.err'
9971   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9972   (eval $ac_try) 2>&5
9973   ac_status=$?
9974   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9975   (exit $ac_status); }; } &&
9976          { ac_try='test -s conftest.$ac_objext'
9977   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9978   (eval $ac_try) 2>&5
9979   ac_status=$?
9980   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9981   (exit $ac_status); }; }; then
9982   ac_cv_member_struct_stat_st_rdev=yes
9983 else
9984   echo "$as_me: failed program was:" >&5
9985 sed 's/^/| /' conftest.$ac_ext >&5
9986
9987 cat >conftest.$ac_ext <<_ACEOF
9988 /* confdefs.h.  */
9989 _ACEOF
9990 cat confdefs.h >>conftest.$ac_ext
9991 cat >>conftest.$ac_ext <<_ACEOF
9992 /* end confdefs.h.  */
9993 $ac_includes_default
9994 int
9995 main ()
9996 {
9997 static struct stat ac_aggr;
9998 if (sizeof ac_aggr.st_rdev)
9999 return 0;
10000   ;
10001   return 0;
10002 }
10003 _ACEOF
10004 rm -f conftest.$ac_objext
10005 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10006   (eval $ac_compile) 2>conftest.er1
10007   ac_status=$?
10008   grep -v '^ *+' conftest.er1 >conftest.err
10009   rm -f conftest.er1
10010   cat conftest.err >&5
10011   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10012   (exit $ac_status); } &&
10013          { ac_try='test -z "$ac_c_werror_flag"
10014                          || test ! -s conftest.err'
10015   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10016   (eval $ac_try) 2>&5
10017   ac_status=$?
10018   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10019   (exit $ac_status); }; } &&
10020          { ac_try='test -s conftest.$ac_objext'
10021   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10022   (eval $ac_try) 2>&5
10023   ac_status=$?
10024   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10025   (exit $ac_status); }; }; then
10026   ac_cv_member_struct_stat_st_rdev=yes
10027 else
10028   echo "$as_me: failed program was:" >&5
10029 sed 's/^/| /' conftest.$ac_ext >&5
10030
10031 ac_cv_member_struct_stat_st_rdev=no
10032 fi
10033 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10034 fi
10035 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10036 fi
10037 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_rdev" >&5
10038 echo "${ECHO_T}$ac_cv_member_struct_stat_st_rdev" >&6
10039 if test $ac_cv_member_struct_stat_st_rdev = yes; then
10040
10041 cat >>confdefs.h <<_ACEOF
10042 #define HAVE_STRUCT_STAT_ST_RDEV 1
10043 _ACEOF
10044
10045
10046 fi
10047
10048
10049 # Check for library functions.
10050
10051
10052
10053
10054
10055
10056
10057
10058 for ac_func in getrusage times mkstemp strtof strtold snprintf ftruncate chsize
10059 do
10060 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10061 echo "$as_me:$LINENO: checking for $ac_func" >&5
10062 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10063 if eval "test \"\${$as_ac_var+set}\" = set"; then
10064   echo $ECHO_N "(cached) $ECHO_C" >&6
10065 else
10066   if test x$gcc_no_link = xyes; then
10067   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10068 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10069    { (exit 1); exit 1; }; }
10070 fi
10071 cat >conftest.$ac_ext <<_ACEOF
10072 /* confdefs.h.  */
10073 _ACEOF
10074 cat confdefs.h >>conftest.$ac_ext
10075 cat >>conftest.$ac_ext <<_ACEOF
10076 /* end confdefs.h.  */
10077 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10078    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10079 #define $ac_func innocuous_$ac_func
10080
10081 /* System header to define __stub macros and hopefully few prototypes,
10082     which can conflict with char $ac_func (); below.
10083     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10084     <limits.h> exists even on freestanding compilers.  */
10085
10086 #ifdef __STDC__
10087 # include <limits.h>
10088 #else
10089 # include <assert.h>
10090 #endif
10091
10092 #undef $ac_func
10093
10094 /* Override any gcc2 internal prototype to avoid an error.  */
10095 #ifdef __cplusplus
10096 extern "C"
10097 {
10098 #endif
10099 /* We use char because int might match the return type of a gcc2
10100    builtin and then its argument prototype would still apply.  */
10101 char $ac_func ();
10102 /* The GNU C library defines this for functions which it implements
10103     to always fail with ENOSYS.  Some functions are actually named
10104     something starting with __ and the normal name is an alias.  */
10105 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10106 choke me
10107 #else
10108 char (*f) () = $ac_func;
10109 #endif
10110 #ifdef __cplusplus
10111 }
10112 #endif
10113
10114 int
10115 main ()
10116 {
10117 return f != $ac_func;
10118   ;
10119   return 0;
10120 }
10121 _ACEOF
10122 rm -f conftest.$ac_objext conftest$ac_exeext
10123 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10124   (eval $ac_link) 2>conftest.er1
10125   ac_status=$?
10126   grep -v '^ *+' conftest.er1 >conftest.err
10127   rm -f conftest.er1
10128   cat conftest.err >&5
10129   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10130   (exit $ac_status); } &&
10131          { ac_try='test -z "$ac_c_werror_flag"
10132                          || test ! -s conftest.err'
10133   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10134   (eval $ac_try) 2>&5
10135   ac_status=$?
10136   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10137   (exit $ac_status); }; } &&
10138          { ac_try='test -s conftest$ac_exeext'
10139   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10140   (eval $ac_try) 2>&5
10141   ac_status=$?
10142   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10143   (exit $ac_status); }; }; then
10144   eval "$as_ac_var=yes"
10145 else
10146   echo "$as_me: failed program was:" >&5
10147 sed 's/^/| /' conftest.$ac_ext >&5
10148
10149 eval "$as_ac_var=no"
10150 fi
10151 rm -f conftest.err conftest.$ac_objext \
10152       conftest$ac_exeext conftest.$ac_ext
10153 fi
10154 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10155 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10156 if test `eval echo '${'$as_ac_var'}'` = yes; then
10157   cat >>confdefs.h <<_ACEOF
10158 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10159 _ACEOF
10160
10161 fi
10162 done
10163
10164
10165
10166
10167
10168
10169
10170
10171
10172 for ac_func in chdir strerror getlogin gethostname kill link symlink perror
10173 do
10174 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10175 echo "$as_me:$LINENO: checking for $ac_func" >&5
10176 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10177 if eval "test \"\${$as_ac_var+set}\" = set"; then
10178   echo $ECHO_N "(cached) $ECHO_C" >&6
10179 else
10180   if test x$gcc_no_link = xyes; then
10181   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10182 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10183    { (exit 1); exit 1; }; }
10184 fi
10185 cat >conftest.$ac_ext <<_ACEOF
10186 /* confdefs.h.  */
10187 _ACEOF
10188 cat confdefs.h >>conftest.$ac_ext
10189 cat >>conftest.$ac_ext <<_ACEOF
10190 /* end confdefs.h.  */
10191 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10192    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10193 #define $ac_func innocuous_$ac_func
10194
10195 /* System header to define __stub macros and hopefully few prototypes,
10196     which can conflict with char $ac_func (); below.
10197     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10198     <limits.h> exists even on freestanding compilers.  */
10199
10200 #ifdef __STDC__
10201 # include <limits.h>
10202 #else
10203 # include <assert.h>
10204 #endif
10205
10206 #undef $ac_func
10207
10208 /* Override any gcc2 internal prototype to avoid an error.  */
10209 #ifdef __cplusplus
10210 extern "C"
10211 {
10212 #endif
10213 /* We use char because int might match the return type of a gcc2
10214    builtin and then its argument prototype would still apply.  */
10215 char $ac_func ();
10216 /* The GNU C library defines this for functions which it implements
10217     to always fail with ENOSYS.  Some functions are actually named
10218     something starting with __ and the normal name is an alias.  */
10219 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10220 choke me
10221 #else
10222 char (*f) () = $ac_func;
10223 #endif
10224 #ifdef __cplusplus
10225 }
10226 #endif
10227
10228 int
10229 main ()
10230 {
10231 return f != $ac_func;
10232   ;
10233   return 0;
10234 }
10235 _ACEOF
10236 rm -f conftest.$ac_objext conftest$ac_exeext
10237 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10238   (eval $ac_link) 2>conftest.er1
10239   ac_status=$?
10240   grep -v '^ *+' conftest.er1 >conftest.err
10241   rm -f conftest.er1
10242   cat conftest.err >&5
10243   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10244   (exit $ac_status); } &&
10245          { ac_try='test -z "$ac_c_werror_flag"
10246                          || test ! -s conftest.err'
10247   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10248   (eval $ac_try) 2>&5
10249   ac_status=$?
10250   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10251   (exit $ac_status); }; } &&
10252          { ac_try='test -s conftest$ac_exeext'
10253   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10254   (eval $ac_try) 2>&5
10255   ac_status=$?
10256   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10257   (exit $ac_status); }; }; then
10258   eval "$as_ac_var=yes"
10259 else
10260   echo "$as_me: failed program was:" >&5
10261 sed 's/^/| /' conftest.$ac_ext >&5
10262
10263 eval "$as_ac_var=no"
10264 fi
10265 rm -f conftest.err conftest.$ac_objext \
10266       conftest$ac_exeext conftest.$ac_ext
10267 fi
10268 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10269 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10270 if test `eval echo '${'$as_ac_var'}'` = yes; then
10271   cat >>confdefs.h <<_ACEOF
10272 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10273 _ACEOF
10274
10275 fi
10276 done
10277
10278
10279
10280
10281
10282
10283
10284
10285
10286
10287
10288 for ac_func in sleep time ttyname signal alarm ctime clock access fork execl
10289 do
10290 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10291 echo "$as_me:$LINENO: checking for $ac_func" >&5
10292 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10293 if eval "test \"\${$as_ac_var+set}\" = set"; then
10294   echo $ECHO_N "(cached) $ECHO_C" >&6
10295 else
10296   if test x$gcc_no_link = xyes; then
10297   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10298 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10299    { (exit 1); exit 1; }; }
10300 fi
10301 cat >conftest.$ac_ext <<_ACEOF
10302 /* confdefs.h.  */
10303 _ACEOF
10304 cat confdefs.h >>conftest.$ac_ext
10305 cat >>conftest.$ac_ext <<_ACEOF
10306 /* end confdefs.h.  */
10307 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10308    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10309 #define $ac_func innocuous_$ac_func
10310
10311 /* System header to define __stub macros and hopefully few prototypes,
10312     which can conflict with char $ac_func (); below.
10313     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10314     <limits.h> exists even on freestanding compilers.  */
10315
10316 #ifdef __STDC__
10317 # include <limits.h>
10318 #else
10319 # include <assert.h>
10320 #endif
10321
10322 #undef $ac_func
10323
10324 /* Override any gcc2 internal prototype to avoid an error.  */
10325 #ifdef __cplusplus
10326 extern "C"
10327 {
10328 #endif
10329 /* We use char because int might match the return type of a gcc2
10330    builtin and then its argument prototype would still apply.  */
10331 char $ac_func ();
10332 /* The GNU C library defines this for functions which it implements
10333     to always fail with ENOSYS.  Some functions are actually named
10334     something starting with __ and the normal name is an alias.  */
10335 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10336 choke me
10337 #else
10338 char (*f) () = $ac_func;
10339 #endif
10340 #ifdef __cplusplus
10341 }
10342 #endif
10343
10344 int
10345 main ()
10346 {
10347 return f != $ac_func;
10348   ;
10349   return 0;
10350 }
10351 _ACEOF
10352 rm -f conftest.$ac_objext conftest$ac_exeext
10353 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10354   (eval $ac_link) 2>conftest.er1
10355   ac_status=$?
10356   grep -v '^ *+' conftest.er1 >conftest.err
10357   rm -f conftest.er1
10358   cat conftest.err >&5
10359   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10360   (exit $ac_status); } &&
10361          { ac_try='test -z "$ac_c_werror_flag"
10362                          || test ! -s conftest.err'
10363   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10364   (eval $ac_try) 2>&5
10365   ac_status=$?
10366   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10367   (exit $ac_status); }; } &&
10368          { ac_try='test -s conftest$ac_exeext'
10369   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10370   (eval $ac_try) 2>&5
10371   ac_status=$?
10372   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10373   (exit $ac_status); }; }; then
10374   eval "$as_ac_var=yes"
10375 else
10376   echo "$as_me: failed program was:" >&5
10377 sed 's/^/| /' conftest.$ac_ext >&5
10378
10379 eval "$as_ac_var=no"
10380 fi
10381 rm -f conftest.err conftest.$ac_objext \
10382       conftest$ac_exeext conftest.$ac_ext
10383 fi
10384 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10385 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10386 if test `eval echo '${'$as_ac_var'}'` = yes; then
10387   cat >>confdefs.h <<_ACEOF
10388 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10389 _ACEOF
10390
10391 fi
10392 done
10393
10394
10395
10396
10397
10398
10399
10400
10401
10402
10403 for ac_func in wait setmode execvp pipe dup2 close fdopen strcasestr getrlimit
10404 do
10405 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10406 echo "$as_me:$LINENO: checking for $ac_func" >&5
10407 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10408 if eval "test \"\${$as_ac_var+set}\" = set"; then
10409   echo $ECHO_N "(cached) $ECHO_C" >&6
10410 else
10411   if test x$gcc_no_link = xyes; then
10412   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10413 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10414    { (exit 1); exit 1; }; }
10415 fi
10416 cat >conftest.$ac_ext <<_ACEOF
10417 /* confdefs.h.  */
10418 _ACEOF
10419 cat confdefs.h >>conftest.$ac_ext
10420 cat >>conftest.$ac_ext <<_ACEOF
10421 /* end confdefs.h.  */
10422 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10423    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10424 #define $ac_func innocuous_$ac_func
10425
10426 /* System header to define __stub macros and hopefully few prototypes,
10427     which can conflict with char $ac_func (); below.
10428     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10429     <limits.h> exists even on freestanding compilers.  */
10430
10431 #ifdef __STDC__
10432 # include <limits.h>
10433 #else
10434 # include <assert.h>
10435 #endif
10436
10437 #undef $ac_func
10438
10439 /* Override any gcc2 internal prototype to avoid an error.  */
10440 #ifdef __cplusplus
10441 extern "C"
10442 {
10443 #endif
10444 /* We use char because int might match the return type of a gcc2
10445    builtin and then its argument prototype would still apply.  */
10446 char $ac_func ();
10447 /* The GNU C library defines this for functions which it implements
10448     to always fail with ENOSYS.  Some functions are actually named
10449     something starting with __ and the normal name is an alias.  */
10450 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10451 choke me
10452 #else
10453 char (*f) () = $ac_func;
10454 #endif
10455 #ifdef __cplusplus
10456 }
10457 #endif
10458
10459 int
10460 main ()
10461 {
10462 return f != $ac_func;
10463   ;
10464   return 0;
10465 }
10466 _ACEOF
10467 rm -f conftest.$ac_objext conftest$ac_exeext
10468 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10469   (eval $ac_link) 2>conftest.er1
10470   ac_status=$?
10471   grep -v '^ *+' conftest.er1 >conftest.err
10472   rm -f conftest.er1
10473   cat conftest.err >&5
10474   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10475   (exit $ac_status); } &&
10476          { ac_try='test -z "$ac_c_werror_flag"
10477                          || test ! -s conftest.err'
10478   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10479   (eval $ac_try) 2>&5
10480   ac_status=$?
10481   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10482   (exit $ac_status); }; } &&
10483          { ac_try='test -s conftest$ac_exeext'
10484   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10485   (eval $ac_try) 2>&5
10486   ac_status=$?
10487   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10488   (exit $ac_status); }; }; then
10489   eval "$as_ac_var=yes"
10490 else
10491   echo "$as_me: failed program was:" >&5
10492 sed 's/^/| /' conftest.$ac_ext >&5
10493
10494 eval "$as_ac_var=no"
10495 fi
10496 rm -f conftest.err conftest.$ac_objext \
10497       conftest$ac_exeext conftest.$ac_ext
10498 fi
10499 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10500 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10501 if test `eval echo '${'$as_ac_var'}'` = yes; then
10502   cat >>confdefs.h <<_ACEOF
10503 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10504 _ACEOF
10505
10506 fi
10507 done
10508
10509
10510
10511
10512
10513 for ac_func in gettimeofday stat fstat lstat
10514 do
10515 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10516 echo "$as_me:$LINENO: checking for $ac_func" >&5
10517 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10518 if eval "test \"\${$as_ac_var+set}\" = set"; then
10519   echo $ECHO_N "(cached) $ECHO_C" >&6
10520 else
10521   if test x$gcc_no_link = xyes; then
10522   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10523 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10524    { (exit 1); exit 1; }; }
10525 fi
10526 cat >conftest.$ac_ext <<_ACEOF
10527 /* confdefs.h.  */
10528 _ACEOF
10529 cat confdefs.h >>conftest.$ac_ext
10530 cat >>conftest.$ac_ext <<_ACEOF
10531 /* end confdefs.h.  */
10532 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10533    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10534 #define $ac_func innocuous_$ac_func
10535
10536 /* System header to define __stub macros and hopefully few prototypes,
10537     which can conflict with char $ac_func (); below.
10538     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10539     <limits.h> exists even on freestanding compilers.  */
10540
10541 #ifdef __STDC__
10542 # include <limits.h>
10543 #else
10544 # include <assert.h>
10545 #endif
10546
10547 #undef $ac_func
10548
10549 /* Override any gcc2 internal prototype to avoid an error.  */
10550 #ifdef __cplusplus
10551 extern "C"
10552 {
10553 #endif
10554 /* We use char because int might match the return type of a gcc2
10555    builtin and then its argument prototype would still apply.  */
10556 char $ac_func ();
10557 /* The GNU C library defines this for functions which it implements
10558     to always fail with ENOSYS.  Some functions are actually named
10559     something starting with __ and the normal name is an alias.  */
10560 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10561 choke me
10562 #else
10563 char (*f) () = $ac_func;
10564 #endif
10565 #ifdef __cplusplus
10566 }
10567 #endif
10568
10569 int
10570 main ()
10571 {
10572 return f != $ac_func;
10573   ;
10574   return 0;
10575 }
10576 _ACEOF
10577 rm -f conftest.$ac_objext conftest$ac_exeext
10578 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10579   (eval $ac_link) 2>conftest.er1
10580   ac_status=$?
10581   grep -v '^ *+' conftest.er1 >conftest.err
10582   rm -f conftest.er1
10583   cat conftest.err >&5
10584   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10585   (exit $ac_status); } &&
10586          { ac_try='test -z "$ac_c_werror_flag"
10587                          || test ! -s conftest.err'
10588   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10589   (eval $ac_try) 2>&5
10590   ac_status=$?
10591   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10592   (exit $ac_status); }; } &&
10593          { ac_try='test -s conftest$ac_exeext'
10594   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10595   (eval $ac_try) 2>&5
10596   ac_status=$?
10597   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10598   (exit $ac_status); }; }; then
10599   eval "$as_ac_var=yes"
10600 else
10601   echo "$as_me: failed program was:" >&5
10602 sed 's/^/| /' conftest.$ac_ext >&5
10603
10604 eval "$as_ac_var=no"
10605 fi
10606 rm -f conftest.err conftest.$ac_objext \
10607       conftest$ac_exeext conftest.$ac_ext
10608 fi
10609 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10610 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10611 if test `eval echo '${'$as_ac_var'}'` = yes; then
10612   cat >>confdefs.h <<_ACEOF
10613 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10614 _ACEOF
10615
10616 fi
10617 done
10618
10619
10620 # Check for glibc backtrace functions
10621
10622
10623 for ac_func in backtrace backtrace_symbols
10624 do
10625 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10626 echo "$as_me:$LINENO: checking for $ac_func" >&5
10627 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10628 if eval "test \"\${$as_ac_var+set}\" = set"; then
10629   echo $ECHO_N "(cached) $ECHO_C" >&6
10630 else
10631   if test x$gcc_no_link = xyes; then
10632   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10633 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10634    { (exit 1); exit 1; }; }
10635 fi
10636 cat >conftest.$ac_ext <<_ACEOF
10637 /* confdefs.h.  */
10638 _ACEOF
10639 cat confdefs.h >>conftest.$ac_ext
10640 cat >>conftest.$ac_ext <<_ACEOF
10641 /* end confdefs.h.  */
10642 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10643    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10644 #define $ac_func innocuous_$ac_func
10645
10646 /* System header to define __stub macros and hopefully few prototypes,
10647     which can conflict with char $ac_func (); below.
10648     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10649     <limits.h> exists even on freestanding compilers.  */
10650
10651 #ifdef __STDC__
10652 # include <limits.h>
10653 #else
10654 # include <assert.h>
10655 #endif
10656
10657 #undef $ac_func
10658
10659 /* Override any gcc2 internal prototype to avoid an error.  */
10660 #ifdef __cplusplus
10661 extern "C"
10662 {
10663 #endif
10664 /* We use char because int might match the return type of a gcc2
10665    builtin and then its argument prototype would still apply.  */
10666 char $ac_func ();
10667 /* The GNU C library defines this for functions which it implements
10668     to always fail with ENOSYS.  Some functions are actually named
10669     something starting with __ and the normal name is an alias.  */
10670 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10671 choke me
10672 #else
10673 char (*f) () = $ac_func;
10674 #endif
10675 #ifdef __cplusplus
10676 }
10677 #endif
10678
10679 int
10680 main ()
10681 {
10682 return f != $ac_func;
10683   ;
10684   return 0;
10685 }
10686 _ACEOF
10687 rm -f conftest.$ac_objext conftest$ac_exeext
10688 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10689   (eval $ac_link) 2>conftest.er1
10690   ac_status=$?
10691   grep -v '^ *+' conftest.er1 >conftest.err
10692   rm -f conftest.er1
10693   cat conftest.err >&5
10694   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10695   (exit $ac_status); } &&
10696          { ac_try='test -z "$ac_c_werror_flag"
10697                          || test ! -s conftest.err'
10698   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10699   (eval $ac_try) 2>&5
10700   ac_status=$?
10701   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10702   (exit $ac_status); }; } &&
10703          { ac_try='test -s conftest$ac_exeext'
10704   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10705   (eval $ac_try) 2>&5
10706   ac_status=$?
10707   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10708   (exit $ac_status); }; }; then
10709   eval "$as_ac_var=yes"
10710 else
10711   echo "$as_me: failed program was:" >&5
10712 sed 's/^/| /' conftest.$ac_ext >&5
10713
10714 eval "$as_ac_var=no"
10715 fi
10716 rm -f conftest.err conftest.$ac_objext \
10717       conftest$ac_exeext conftest.$ac_ext
10718 fi
10719 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10720 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10721 if test `eval echo '${'$as_ac_var'}'` = yes; then
10722   cat >>confdefs.h <<_ACEOF
10723 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10724 _ACEOF
10725
10726 fi
10727 done
10728
10729
10730 # Check for types
10731 echo "$as_me:$LINENO: checking for intptr_t" >&5
10732 echo $ECHO_N "checking for intptr_t... $ECHO_C" >&6
10733 if test "${ac_cv_type_intptr_t+set}" = set; then
10734   echo $ECHO_N "(cached) $ECHO_C" >&6
10735 else
10736   cat >conftest.$ac_ext <<_ACEOF
10737 /* confdefs.h.  */
10738 _ACEOF
10739 cat confdefs.h >>conftest.$ac_ext
10740 cat >>conftest.$ac_ext <<_ACEOF
10741 /* end confdefs.h.  */
10742 $ac_includes_default
10743 int
10744 main ()
10745 {
10746 if ((intptr_t *) 0)
10747   return 0;
10748 if (sizeof (intptr_t))
10749   return 0;
10750   ;
10751   return 0;
10752 }
10753 _ACEOF
10754 rm -f conftest.$ac_objext
10755 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10756   (eval $ac_compile) 2>conftest.er1
10757   ac_status=$?
10758   grep -v '^ *+' conftest.er1 >conftest.err
10759   rm -f conftest.er1
10760   cat conftest.err >&5
10761   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10762   (exit $ac_status); } &&
10763          { ac_try='test -z "$ac_c_werror_flag"
10764                          || test ! -s conftest.err'
10765   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10766   (eval $ac_try) 2>&5
10767   ac_status=$?
10768   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10769   (exit $ac_status); }; } &&
10770          { ac_try='test -s conftest.$ac_objext'
10771   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10772   (eval $ac_try) 2>&5
10773   ac_status=$?
10774   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10775   (exit $ac_status); }; }; then
10776   ac_cv_type_intptr_t=yes
10777 else
10778   echo "$as_me: failed program was:" >&5
10779 sed 's/^/| /' conftest.$ac_ext >&5
10780
10781 ac_cv_type_intptr_t=no
10782 fi
10783 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10784 fi
10785 echo "$as_me:$LINENO: result: $ac_cv_type_intptr_t" >&5
10786 echo "${ECHO_T}$ac_cv_type_intptr_t" >&6
10787 if test $ac_cv_type_intptr_t = yes; then
10788
10789 cat >>confdefs.h <<_ACEOF
10790 #define HAVE_INTPTR_T 1
10791 _ACEOF
10792
10793
10794 fi
10795
10796
10797 # Check libc for getgid, getpid, getuid
10798 echo "$as_me:$LINENO: checking for getgid in -lc" >&5
10799 echo $ECHO_N "checking for getgid in -lc... $ECHO_C" >&6
10800 if test "${ac_cv_lib_c_getgid+set}" = set; then
10801   echo $ECHO_N "(cached) $ECHO_C" >&6
10802 else
10803   ac_check_lib_save_LIBS=$LIBS
10804 LIBS="-lc  $LIBS"
10805 if test x$gcc_no_link = xyes; then
10806   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10807 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10808    { (exit 1); exit 1; }; }
10809 fi
10810 cat >conftest.$ac_ext <<_ACEOF
10811 /* confdefs.h.  */
10812 _ACEOF
10813 cat confdefs.h >>conftest.$ac_ext
10814 cat >>conftest.$ac_ext <<_ACEOF
10815 /* end confdefs.h.  */
10816
10817 /* Override any gcc2 internal prototype to avoid an error.  */
10818 #ifdef __cplusplus
10819 extern "C"
10820 #endif
10821 /* We use char because int might match the return type of a gcc2
10822    builtin and then its argument prototype would still apply.  */
10823 char getgid ();
10824 int
10825 main ()
10826 {
10827 getgid ();
10828   ;
10829   return 0;
10830 }
10831 _ACEOF
10832 rm -f conftest.$ac_objext conftest$ac_exeext
10833 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10834   (eval $ac_link) 2>conftest.er1
10835   ac_status=$?
10836   grep -v '^ *+' conftest.er1 >conftest.err
10837   rm -f conftest.er1
10838   cat conftest.err >&5
10839   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10840   (exit $ac_status); } &&
10841          { ac_try='test -z "$ac_c_werror_flag"
10842                          || test ! -s conftest.err'
10843   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10844   (eval $ac_try) 2>&5
10845   ac_status=$?
10846   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10847   (exit $ac_status); }; } &&
10848          { ac_try='test -s conftest$ac_exeext'
10849   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10850   (eval $ac_try) 2>&5
10851   ac_status=$?
10852   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10853   (exit $ac_status); }; }; then
10854   ac_cv_lib_c_getgid=yes
10855 else
10856   echo "$as_me: failed program was:" >&5
10857 sed 's/^/| /' conftest.$ac_ext >&5
10858
10859 ac_cv_lib_c_getgid=no
10860 fi
10861 rm -f conftest.err conftest.$ac_objext \
10862       conftest$ac_exeext conftest.$ac_ext
10863 LIBS=$ac_check_lib_save_LIBS
10864 fi
10865 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getgid" >&5
10866 echo "${ECHO_T}$ac_cv_lib_c_getgid" >&6
10867 if test $ac_cv_lib_c_getgid = yes; then
10868
10869 cat >>confdefs.h <<\_ACEOF
10870 #define HAVE_GETGID 1
10871 _ACEOF
10872
10873 fi
10874
10875 echo "$as_me:$LINENO: checking for getpid in -lc" >&5
10876 echo $ECHO_N "checking for getpid in -lc... $ECHO_C" >&6
10877 if test "${ac_cv_lib_c_getpid+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 getpid ();
10901 int
10902 main ()
10903 {
10904 getpid ();
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_getpid=yes
10932 else
10933   echo "$as_me: failed program was:" >&5
10934 sed 's/^/| /' conftest.$ac_ext >&5
10935
10936 ac_cv_lib_c_getpid=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_getpid" >&5
10943 echo "${ECHO_T}$ac_cv_lib_c_getpid" >&6
10944 if test $ac_cv_lib_c_getpid = yes; then
10945
10946 cat >>confdefs.h <<\_ACEOF
10947 #define HAVE_GETPID 1
10948 _ACEOF
10949
10950 fi
10951
10952 echo "$as_me:$LINENO: checking for getppid in -lc" >&5
10953 echo $ECHO_N "checking for getppid in -lc... $ECHO_C" >&6
10954 if test "${ac_cv_lib_c_getppid+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 getppid ();
10978 int
10979 main ()
10980 {
10981 getppid ();
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_getppid=yes
11009 else
11010   echo "$as_me: failed program was:" >&5
11011 sed 's/^/| /' conftest.$ac_ext >&5
11012
11013 ac_cv_lib_c_getppid=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_getppid" >&5
11020 echo "${ECHO_T}$ac_cv_lib_c_getppid" >&6
11021 if test $ac_cv_lib_c_getppid = yes; then
11022
11023 cat >>confdefs.h <<\_ACEOF
11024 #define HAVE_GETPPID 1
11025 _ACEOF
11026
11027 fi
11028
11029 echo "$as_me:$LINENO: checking for getuid in -lc" >&5
11030 echo $ECHO_N "checking for getuid in -lc... $ECHO_C" >&6
11031 if test "${ac_cv_lib_c_getuid+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 getuid ();
11055 int
11056 main ()
11057 {
11058 getuid ();
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_getuid=yes
11086 else
11087   echo "$as_me: failed program was:" >&5
11088 sed 's/^/| /' conftest.$ac_ext >&5
11089
11090 ac_cv_lib_c_getuid=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_getuid" >&5
11097 echo "${ECHO_T}$ac_cv_lib_c_getuid" >&6
11098 if test $ac_cv_lib_c_getuid = yes; then
11099
11100 cat >>confdefs.h <<\_ACEOF
11101 #define HAVE_GETUID 1
11102 _ACEOF
11103
11104 fi
11105
11106
11107 # Check for C99 (and other IEEE) math functions
11108 # ??? This list seems awful long. Is there a better way to test for these?
11109 echo "$as_me:$LINENO: checking for acosf in -lm" >&5
11110 echo $ECHO_N "checking for acosf in -lm... $ECHO_C" >&6
11111 if test "${ac_cv_lib_m_acosf+set}" = set; then
11112   echo $ECHO_N "(cached) $ECHO_C" >&6
11113 else
11114   ac_check_lib_save_LIBS=$LIBS
11115 LIBS="-lm  $LIBS"
11116 if test x$gcc_no_link = xyes; then
11117   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11118 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11119    { (exit 1); exit 1; }; }
11120 fi
11121 cat >conftest.$ac_ext <<_ACEOF
11122 /* confdefs.h.  */
11123 _ACEOF
11124 cat confdefs.h >>conftest.$ac_ext
11125 cat >>conftest.$ac_ext <<_ACEOF
11126 /* end confdefs.h.  */
11127
11128 /* Override any gcc2 internal prototype to avoid an error.  */
11129 #ifdef __cplusplus
11130 extern "C"
11131 #endif
11132 /* We use char because int might match the return type of a gcc2
11133    builtin and then its argument prototype would still apply.  */
11134 char acosf ();
11135 int
11136 main ()
11137 {
11138 acosf ();
11139   ;
11140   return 0;
11141 }
11142 _ACEOF
11143 rm -f conftest.$ac_objext conftest$ac_exeext
11144 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11145   (eval $ac_link) 2>conftest.er1
11146   ac_status=$?
11147   grep -v '^ *+' conftest.er1 >conftest.err
11148   rm -f conftest.er1
11149   cat conftest.err >&5
11150   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11151   (exit $ac_status); } &&
11152          { ac_try='test -z "$ac_c_werror_flag"
11153                          || test ! -s conftest.err'
11154   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11155   (eval $ac_try) 2>&5
11156   ac_status=$?
11157   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11158   (exit $ac_status); }; } &&
11159          { ac_try='test -s conftest$ac_exeext'
11160   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11161   (eval $ac_try) 2>&5
11162   ac_status=$?
11163   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11164   (exit $ac_status); }; }; then
11165   ac_cv_lib_m_acosf=yes
11166 else
11167   echo "$as_me: failed program was:" >&5
11168 sed 's/^/| /' conftest.$ac_ext >&5
11169
11170 ac_cv_lib_m_acosf=no
11171 fi
11172 rm -f conftest.err conftest.$ac_objext \
11173       conftest$ac_exeext conftest.$ac_ext
11174 LIBS=$ac_check_lib_save_LIBS
11175 fi
11176 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosf" >&5
11177 echo "${ECHO_T}$ac_cv_lib_m_acosf" >&6
11178 if test $ac_cv_lib_m_acosf = yes; then
11179
11180 cat >>confdefs.h <<\_ACEOF
11181 #define HAVE_ACOSF 1
11182 _ACEOF
11183
11184 fi
11185
11186 echo "$as_me:$LINENO: checking for acos in -lm" >&5
11187 echo $ECHO_N "checking for acos in -lm... $ECHO_C" >&6
11188 if test "${ac_cv_lib_m_acos+set}" = set; then
11189   echo $ECHO_N "(cached) $ECHO_C" >&6
11190 else
11191   ac_check_lib_save_LIBS=$LIBS
11192 LIBS="-lm  $LIBS"
11193 if test x$gcc_no_link = xyes; then
11194   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11195 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11196    { (exit 1); exit 1; }; }
11197 fi
11198 cat >conftest.$ac_ext <<_ACEOF
11199 /* confdefs.h.  */
11200 _ACEOF
11201 cat confdefs.h >>conftest.$ac_ext
11202 cat >>conftest.$ac_ext <<_ACEOF
11203 /* end confdefs.h.  */
11204
11205 /* Override any gcc2 internal prototype to avoid an error.  */
11206 #ifdef __cplusplus
11207 extern "C"
11208 #endif
11209 /* We use char because int might match the return type of a gcc2
11210    builtin and then its argument prototype would still apply.  */
11211 char acos ();
11212 int
11213 main ()
11214 {
11215 acos ();
11216   ;
11217   return 0;
11218 }
11219 _ACEOF
11220 rm -f conftest.$ac_objext conftest$ac_exeext
11221 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11222   (eval $ac_link) 2>conftest.er1
11223   ac_status=$?
11224   grep -v '^ *+' conftest.er1 >conftest.err
11225   rm -f conftest.er1
11226   cat conftest.err >&5
11227   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11228   (exit $ac_status); } &&
11229          { ac_try='test -z "$ac_c_werror_flag"
11230                          || test ! -s conftest.err'
11231   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11232   (eval $ac_try) 2>&5
11233   ac_status=$?
11234   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11235   (exit $ac_status); }; } &&
11236          { ac_try='test -s conftest$ac_exeext'
11237   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11238   (eval $ac_try) 2>&5
11239   ac_status=$?
11240   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11241   (exit $ac_status); }; }; then
11242   ac_cv_lib_m_acos=yes
11243 else
11244   echo "$as_me: failed program was:" >&5
11245 sed 's/^/| /' conftest.$ac_ext >&5
11246
11247 ac_cv_lib_m_acos=no
11248 fi
11249 rm -f conftest.err conftest.$ac_objext \
11250       conftest$ac_exeext conftest.$ac_ext
11251 LIBS=$ac_check_lib_save_LIBS
11252 fi
11253 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acos" >&5
11254 echo "${ECHO_T}$ac_cv_lib_m_acos" >&6
11255 if test $ac_cv_lib_m_acos = yes; then
11256
11257 cat >>confdefs.h <<\_ACEOF
11258 #define HAVE_ACOS 1
11259 _ACEOF
11260
11261 fi
11262
11263 echo "$as_me:$LINENO: checking for acosl in -lm" >&5
11264 echo $ECHO_N "checking for acosl in -lm... $ECHO_C" >&6
11265 if test "${ac_cv_lib_m_acosl+set}" = set; then
11266   echo $ECHO_N "(cached) $ECHO_C" >&6
11267 else
11268   ac_check_lib_save_LIBS=$LIBS
11269 LIBS="-lm  $LIBS"
11270 if test x$gcc_no_link = xyes; then
11271   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11272 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11273    { (exit 1); exit 1; }; }
11274 fi
11275 cat >conftest.$ac_ext <<_ACEOF
11276 /* confdefs.h.  */
11277 _ACEOF
11278 cat confdefs.h >>conftest.$ac_ext
11279 cat >>conftest.$ac_ext <<_ACEOF
11280 /* end confdefs.h.  */
11281
11282 /* Override any gcc2 internal prototype to avoid an error.  */
11283 #ifdef __cplusplus
11284 extern "C"
11285 #endif
11286 /* We use char because int might match the return type of a gcc2
11287    builtin and then its argument prototype would still apply.  */
11288 char acosl ();
11289 int
11290 main ()
11291 {
11292 acosl ();
11293   ;
11294   return 0;
11295 }
11296 _ACEOF
11297 rm -f conftest.$ac_objext conftest$ac_exeext
11298 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11299   (eval $ac_link) 2>conftest.er1
11300   ac_status=$?
11301   grep -v '^ *+' conftest.er1 >conftest.err
11302   rm -f conftest.er1
11303   cat conftest.err >&5
11304   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11305   (exit $ac_status); } &&
11306          { ac_try='test -z "$ac_c_werror_flag"
11307                          || test ! -s conftest.err'
11308   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11309   (eval $ac_try) 2>&5
11310   ac_status=$?
11311   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11312   (exit $ac_status); }; } &&
11313          { ac_try='test -s conftest$ac_exeext'
11314   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11315   (eval $ac_try) 2>&5
11316   ac_status=$?
11317   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11318   (exit $ac_status); }; }; then
11319   ac_cv_lib_m_acosl=yes
11320 else
11321   echo "$as_me: failed program was:" >&5
11322 sed 's/^/| /' conftest.$ac_ext >&5
11323
11324 ac_cv_lib_m_acosl=no
11325 fi
11326 rm -f conftest.err conftest.$ac_objext \
11327       conftest$ac_exeext conftest.$ac_ext
11328 LIBS=$ac_check_lib_save_LIBS
11329 fi
11330 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosl" >&5
11331 echo "${ECHO_T}$ac_cv_lib_m_acosl" >&6
11332 if test $ac_cv_lib_m_acosl = yes; then
11333
11334 cat >>confdefs.h <<\_ACEOF
11335 #define HAVE_ACOSL 1
11336 _ACEOF
11337
11338 fi
11339
11340 echo "$as_me:$LINENO: checking for acoshf in -lm" >&5
11341 echo $ECHO_N "checking for acoshf in -lm... $ECHO_C" >&6
11342 if test "${ac_cv_lib_m_acoshf+set}" = set; then
11343   echo $ECHO_N "(cached) $ECHO_C" >&6
11344 else
11345   ac_check_lib_save_LIBS=$LIBS
11346 LIBS="-lm  $LIBS"
11347 if test x$gcc_no_link = xyes; then
11348   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11349 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11350    { (exit 1); exit 1; }; }
11351 fi
11352 cat >conftest.$ac_ext <<_ACEOF
11353 /* confdefs.h.  */
11354 _ACEOF
11355 cat confdefs.h >>conftest.$ac_ext
11356 cat >>conftest.$ac_ext <<_ACEOF
11357 /* end confdefs.h.  */
11358
11359 /* Override any gcc2 internal prototype to avoid an error.  */
11360 #ifdef __cplusplus
11361 extern "C"
11362 #endif
11363 /* We use char because int might match the return type of a gcc2
11364    builtin and then its argument prototype would still apply.  */
11365 char acoshf ();
11366 int
11367 main ()
11368 {
11369 acoshf ();
11370   ;
11371   return 0;
11372 }
11373 _ACEOF
11374 rm -f conftest.$ac_objext conftest$ac_exeext
11375 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11376   (eval $ac_link) 2>conftest.er1
11377   ac_status=$?
11378   grep -v '^ *+' conftest.er1 >conftest.err
11379   rm -f conftest.er1
11380   cat conftest.err >&5
11381   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11382   (exit $ac_status); } &&
11383          { ac_try='test -z "$ac_c_werror_flag"
11384                          || test ! -s conftest.err'
11385   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11386   (eval $ac_try) 2>&5
11387   ac_status=$?
11388   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11389   (exit $ac_status); }; } &&
11390          { ac_try='test -s conftest$ac_exeext'
11391   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11392   (eval $ac_try) 2>&5
11393   ac_status=$?
11394   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11395   (exit $ac_status); }; }; then
11396   ac_cv_lib_m_acoshf=yes
11397 else
11398   echo "$as_me: failed program was:" >&5
11399 sed 's/^/| /' conftest.$ac_ext >&5
11400
11401 ac_cv_lib_m_acoshf=no
11402 fi
11403 rm -f conftest.err conftest.$ac_objext \
11404       conftest$ac_exeext conftest.$ac_ext
11405 LIBS=$ac_check_lib_save_LIBS
11406 fi
11407 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acoshf" >&5
11408 echo "${ECHO_T}$ac_cv_lib_m_acoshf" >&6
11409 if test $ac_cv_lib_m_acoshf = yes; then
11410
11411 cat >>confdefs.h <<\_ACEOF
11412 #define HAVE_ACOSHF 1
11413 _ACEOF
11414
11415 fi
11416
11417 echo "$as_me:$LINENO: checking for acosh in -lm" >&5
11418 echo $ECHO_N "checking for acosh in -lm... $ECHO_C" >&6
11419 if test "${ac_cv_lib_m_acosh+set}" = set; then
11420   echo $ECHO_N "(cached) $ECHO_C" >&6
11421 else
11422   ac_check_lib_save_LIBS=$LIBS
11423 LIBS="-lm  $LIBS"
11424 if test x$gcc_no_link = xyes; then
11425   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11426 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11427    { (exit 1); exit 1; }; }
11428 fi
11429 cat >conftest.$ac_ext <<_ACEOF
11430 /* confdefs.h.  */
11431 _ACEOF
11432 cat confdefs.h >>conftest.$ac_ext
11433 cat >>conftest.$ac_ext <<_ACEOF
11434 /* end confdefs.h.  */
11435
11436 /* Override any gcc2 internal prototype to avoid an error.  */
11437 #ifdef __cplusplus
11438 extern "C"
11439 #endif
11440 /* We use char because int might match the return type of a gcc2
11441    builtin and then its argument prototype would still apply.  */
11442 char acosh ();
11443 int
11444 main ()
11445 {
11446 acosh ();
11447   ;
11448   return 0;
11449 }
11450 _ACEOF
11451 rm -f conftest.$ac_objext conftest$ac_exeext
11452 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11453   (eval $ac_link) 2>conftest.er1
11454   ac_status=$?
11455   grep -v '^ *+' conftest.er1 >conftest.err
11456   rm -f conftest.er1
11457   cat conftest.err >&5
11458   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11459   (exit $ac_status); } &&
11460          { ac_try='test -z "$ac_c_werror_flag"
11461                          || test ! -s conftest.err'
11462   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11463   (eval $ac_try) 2>&5
11464   ac_status=$?
11465   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11466   (exit $ac_status); }; } &&
11467          { ac_try='test -s conftest$ac_exeext'
11468   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11469   (eval $ac_try) 2>&5
11470   ac_status=$?
11471   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11472   (exit $ac_status); }; }; then
11473   ac_cv_lib_m_acosh=yes
11474 else
11475   echo "$as_me: failed program was:" >&5
11476 sed 's/^/| /' conftest.$ac_ext >&5
11477
11478 ac_cv_lib_m_acosh=no
11479 fi
11480 rm -f conftest.err conftest.$ac_objext \
11481       conftest$ac_exeext conftest.$ac_ext
11482 LIBS=$ac_check_lib_save_LIBS
11483 fi
11484 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosh" >&5
11485 echo "${ECHO_T}$ac_cv_lib_m_acosh" >&6
11486 if test $ac_cv_lib_m_acosh = yes; then
11487
11488 cat >>confdefs.h <<\_ACEOF
11489 #define HAVE_ACOSH 1
11490 _ACEOF
11491
11492 fi
11493
11494 echo "$as_me:$LINENO: checking for acoshl in -lm" >&5
11495 echo $ECHO_N "checking for acoshl in -lm... $ECHO_C" >&6
11496 if test "${ac_cv_lib_m_acoshl+set}" = set; then
11497   echo $ECHO_N "(cached) $ECHO_C" >&6
11498 else
11499   ac_check_lib_save_LIBS=$LIBS
11500 LIBS="-lm  $LIBS"
11501 if test x$gcc_no_link = xyes; then
11502   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11503 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11504    { (exit 1); exit 1; }; }
11505 fi
11506 cat >conftest.$ac_ext <<_ACEOF
11507 /* confdefs.h.  */
11508 _ACEOF
11509 cat confdefs.h >>conftest.$ac_ext
11510 cat >>conftest.$ac_ext <<_ACEOF
11511 /* end confdefs.h.  */
11512
11513 /* Override any gcc2 internal prototype to avoid an error.  */
11514 #ifdef __cplusplus
11515 extern "C"
11516 #endif
11517 /* We use char because int might match the return type of a gcc2
11518    builtin and then its argument prototype would still apply.  */
11519 char acoshl ();
11520 int
11521 main ()
11522 {
11523 acoshl ();
11524   ;
11525   return 0;
11526 }
11527 _ACEOF
11528 rm -f conftest.$ac_objext conftest$ac_exeext
11529 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11530   (eval $ac_link) 2>conftest.er1
11531   ac_status=$?
11532   grep -v '^ *+' conftest.er1 >conftest.err
11533   rm -f conftest.er1
11534   cat conftest.err >&5
11535   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11536   (exit $ac_status); } &&
11537          { ac_try='test -z "$ac_c_werror_flag"
11538                          || test ! -s conftest.err'
11539   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11540   (eval $ac_try) 2>&5
11541   ac_status=$?
11542   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11543   (exit $ac_status); }; } &&
11544          { ac_try='test -s conftest$ac_exeext'
11545   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11546   (eval $ac_try) 2>&5
11547   ac_status=$?
11548   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11549   (exit $ac_status); }; }; then
11550   ac_cv_lib_m_acoshl=yes
11551 else
11552   echo "$as_me: failed program was:" >&5
11553 sed 's/^/| /' conftest.$ac_ext >&5
11554
11555 ac_cv_lib_m_acoshl=no
11556 fi
11557 rm -f conftest.err conftest.$ac_objext \
11558       conftest$ac_exeext conftest.$ac_ext
11559 LIBS=$ac_check_lib_save_LIBS
11560 fi
11561 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acoshl" >&5
11562 echo "${ECHO_T}$ac_cv_lib_m_acoshl" >&6
11563 if test $ac_cv_lib_m_acoshl = yes; then
11564
11565 cat >>confdefs.h <<\_ACEOF
11566 #define HAVE_ACOSHL 1
11567 _ACEOF
11568
11569 fi
11570
11571 echo "$as_me:$LINENO: checking for asinf in -lm" >&5
11572 echo $ECHO_N "checking for asinf in -lm... $ECHO_C" >&6
11573 if test "${ac_cv_lib_m_asinf+set}" = set; then
11574   echo $ECHO_N "(cached) $ECHO_C" >&6
11575 else
11576   ac_check_lib_save_LIBS=$LIBS
11577 LIBS="-lm  $LIBS"
11578 if test x$gcc_no_link = xyes; then
11579   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11580 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11581    { (exit 1); exit 1; }; }
11582 fi
11583 cat >conftest.$ac_ext <<_ACEOF
11584 /* confdefs.h.  */
11585 _ACEOF
11586 cat confdefs.h >>conftest.$ac_ext
11587 cat >>conftest.$ac_ext <<_ACEOF
11588 /* end confdefs.h.  */
11589
11590 /* Override any gcc2 internal prototype to avoid an error.  */
11591 #ifdef __cplusplus
11592 extern "C"
11593 #endif
11594 /* We use char because int might match the return type of a gcc2
11595    builtin and then its argument prototype would still apply.  */
11596 char asinf ();
11597 int
11598 main ()
11599 {
11600 asinf ();
11601   ;
11602   return 0;
11603 }
11604 _ACEOF
11605 rm -f conftest.$ac_objext conftest$ac_exeext
11606 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11607   (eval $ac_link) 2>conftest.er1
11608   ac_status=$?
11609   grep -v '^ *+' conftest.er1 >conftest.err
11610   rm -f conftest.er1
11611   cat conftest.err >&5
11612   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11613   (exit $ac_status); } &&
11614          { ac_try='test -z "$ac_c_werror_flag"
11615                          || test ! -s conftest.err'
11616   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11617   (eval $ac_try) 2>&5
11618   ac_status=$?
11619   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11620   (exit $ac_status); }; } &&
11621          { ac_try='test -s conftest$ac_exeext'
11622   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11623   (eval $ac_try) 2>&5
11624   ac_status=$?
11625   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11626   (exit $ac_status); }; }; then
11627   ac_cv_lib_m_asinf=yes
11628 else
11629   echo "$as_me: failed program was:" >&5
11630 sed 's/^/| /' conftest.$ac_ext >&5
11631
11632 ac_cv_lib_m_asinf=no
11633 fi
11634 rm -f conftest.err conftest.$ac_objext \
11635       conftest$ac_exeext conftest.$ac_ext
11636 LIBS=$ac_check_lib_save_LIBS
11637 fi
11638 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinf" >&5
11639 echo "${ECHO_T}$ac_cv_lib_m_asinf" >&6
11640 if test $ac_cv_lib_m_asinf = yes; then
11641
11642 cat >>confdefs.h <<\_ACEOF
11643 #define HAVE_ASINF 1
11644 _ACEOF
11645
11646 fi
11647
11648 echo "$as_me:$LINENO: checking for asin in -lm" >&5
11649 echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
11650 if test "${ac_cv_lib_m_asin+set}" = set; then
11651   echo $ECHO_N "(cached) $ECHO_C" >&6
11652 else
11653   ac_check_lib_save_LIBS=$LIBS
11654 LIBS="-lm  $LIBS"
11655 if test x$gcc_no_link = xyes; then
11656   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11657 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11658    { (exit 1); exit 1; }; }
11659 fi
11660 cat >conftest.$ac_ext <<_ACEOF
11661 /* confdefs.h.  */
11662 _ACEOF
11663 cat confdefs.h >>conftest.$ac_ext
11664 cat >>conftest.$ac_ext <<_ACEOF
11665 /* end confdefs.h.  */
11666
11667 /* Override any gcc2 internal prototype to avoid an error.  */
11668 #ifdef __cplusplus
11669 extern "C"
11670 #endif
11671 /* We use char because int might match the return type of a gcc2
11672    builtin and then its argument prototype would still apply.  */
11673 char asin ();
11674 int
11675 main ()
11676 {
11677 asin ();
11678   ;
11679   return 0;
11680 }
11681 _ACEOF
11682 rm -f conftest.$ac_objext conftest$ac_exeext
11683 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11684   (eval $ac_link) 2>conftest.er1
11685   ac_status=$?
11686   grep -v '^ *+' conftest.er1 >conftest.err
11687   rm -f conftest.er1
11688   cat conftest.err >&5
11689   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11690   (exit $ac_status); } &&
11691          { ac_try='test -z "$ac_c_werror_flag"
11692                          || test ! -s conftest.err'
11693   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11694   (eval $ac_try) 2>&5
11695   ac_status=$?
11696   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11697   (exit $ac_status); }; } &&
11698          { ac_try='test -s conftest$ac_exeext'
11699   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11700   (eval $ac_try) 2>&5
11701   ac_status=$?
11702   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11703   (exit $ac_status); }; }; then
11704   ac_cv_lib_m_asin=yes
11705 else
11706   echo "$as_me: failed program was:" >&5
11707 sed 's/^/| /' conftest.$ac_ext >&5
11708
11709 ac_cv_lib_m_asin=no
11710 fi
11711 rm -f conftest.err conftest.$ac_objext \
11712       conftest$ac_exeext conftest.$ac_ext
11713 LIBS=$ac_check_lib_save_LIBS
11714 fi
11715 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
11716 echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
11717 if test $ac_cv_lib_m_asin = yes; then
11718
11719 cat >>confdefs.h <<\_ACEOF
11720 #define HAVE_ASIN 1
11721 _ACEOF
11722
11723 fi
11724
11725 echo "$as_me:$LINENO: checking for asinl in -lm" >&5
11726 echo $ECHO_N "checking for asinl in -lm... $ECHO_C" >&6
11727 if test "${ac_cv_lib_m_asinl+set}" = set; then
11728   echo $ECHO_N "(cached) $ECHO_C" >&6
11729 else
11730   ac_check_lib_save_LIBS=$LIBS
11731 LIBS="-lm  $LIBS"
11732 if test x$gcc_no_link = xyes; then
11733   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11734 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11735    { (exit 1); exit 1; }; }
11736 fi
11737 cat >conftest.$ac_ext <<_ACEOF
11738 /* confdefs.h.  */
11739 _ACEOF
11740 cat confdefs.h >>conftest.$ac_ext
11741 cat >>conftest.$ac_ext <<_ACEOF
11742 /* end confdefs.h.  */
11743
11744 /* Override any gcc2 internal prototype to avoid an error.  */
11745 #ifdef __cplusplus
11746 extern "C"
11747 #endif
11748 /* We use char because int might match the return type of a gcc2
11749    builtin and then its argument prototype would still apply.  */
11750 char asinl ();
11751 int
11752 main ()
11753 {
11754 asinl ();
11755   ;
11756   return 0;
11757 }
11758 _ACEOF
11759 rm -f conftest.$ac_objext conftest$ac_exeext
11760 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11761   (eval $ac_link) 2>conftest.er1
11762   ac_status=$?
11763   grep -v '^ *+' conftest.er1 >conftest.err
11764   rm -f conftest.er1
11765   cat conftest.err >&5
11766   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11767   (exit $ac_status); } &&
11768          { ac_try='test -z "$ac_c_werror_flag"
11769                          || test ! -s conftest.err'
11770   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11771   (eval $ac_try) 2>&5
11772   ac_status=$?
11773   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11774   (exit $ac_status); }; } &&
11775          { ac_try='test -s conftest$ac_exeext'
11776   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11777   (eval $ac_try) 2>&5
11778   ac_status=$?
11779   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11780   (exit $ac_status); }; }; then
11781   ac_cv_lib_m_asinl=yes
11782 else
11783   echo "$as_me: failed program was:" >&5
11784 sed 's/^/| /' conftest.$ac_ext >&5
11785
11786 ac_cv_lib_m_asinl=no
11787 fi
11788 rm -f conftest.err conftest.$ac_objext \
11789       conftest$ac_exeext conftest.$ac_ext
11790 LIBS=$ac_check_lib_save_LIBS
11791 fi
11792 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinl" >&5
11793 echo "${ECHO_T}$ac_cv_lib_m_asinl" >&6
11794 if test $ac_cv_lib_m_asinl = yes; then
11795
11796 cat >>confdefs.h <<\_ACEOF
11797 #define HAVE_ASINL 1
11798 _ACEOF
11799
11800 fi
11801
11802 echo "$as_me:$LINENO: checking for asinhf in -lm" >&5
11803 echo $ECHO_N "checking for asinhf in -lm... $ECHO_C" >&6
11804 if test "${ac_cv_lib_m_asinhf+set}" = set; then
11805   echo $ECHO_N "(cached) $ECHO_C" >&6
11806 else
11807   ac_check_lib_save_LIBS=$LIBS
11808 LIBS="-lm  $LIBS"
11809 if test x$gcc_no_link = xyes; then
11810   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11811 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11812    { (exit 1); exit 1; }; }
11813 fi
11814 cat >conftest.$ac_ext <<_ACEOF
11815 /* confdefs.h.  */
11816 _ACEOF
11817 cat confdefs.h >>conftest.$ac_ext
11818 cat >>conftest.$ac_ext <<_ACEOF
11819 /* end confdefs.h.  */
11820
11821 /* Override any gcc2 internal prototype to avoid an error.  */
11822 #ifdef __cplusplus
11823 extern "C"
11824 #endif
11825 /* We use char because int might match the return type of a gcc2
11826    builtin and then its argument prototype would still apply.  */
11827 char asinhf ();
11828 int
11829 main ()
11830 {
11831 asinhf ();
11832   ;
11833   return 0;
11834 }
11835 _ACEOF
11836 rm -f conftest.$ac_objext conftest$ac_exeext
11837 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11838   (eval $ac_link) 2>conftest.er1
11839   ac_status=$?
11840   grep -v '^ *+' conftest.er1 >conftest.err
11841   rm -f conftest.er1
11842   cat conftest.err >&5
11843   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11844   (exit $ac_status); } &&
11845          { ac_try='test -z "$ac_c_werror_flag"
11846                          || test ! -s conftest.err'
11847   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11848   (eval $ac_try) 2>&5
11849   ac_status=$?
11850   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11851   (exit $ac_status); }; } &&
11852          { ac_try='test -s conftest$ac_exeext'
11853   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11854   (eval $ac_try) 2>&5
11855   ac_status=$?
11856   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11857   (exit $ac_status); }; }; then
11858   ac_cv_lib_m_asinhf=yes
11859 else
11860   echo "$as_me: failed program was:" >&5
11861 sed 's/^/| /' conftest.$ac_ext >&5
11862
11863 ac_cv_lib_m_asinhf=no
11864 fi
11865 rm -f conftest.err conftest.$ac_objext \
11866       conftest$ac_exeext conftest.$ac_ext
11867 LIBS=$ac_check_lib_save_LIBS
11868 fi
11869 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinhf" >&5
11870 echo "${ECHO_T}$ac_cv_lib_m_asinhf" >&6
11871 if test $ac_cv_lib_m_asinhf = yes; then
11872
11873 cat >>confdefs.h <<\_ACEOF
11874 #define HAVE_ASINHF 1
11875 _ACEOF
11876
11877 fi
11878
11879 echo "$as_me:$LINENO: checking for asinh in -lm" >&5
11880 echo $ECHO_N "checking for asinh in -lm... $ECHO_C" >&6
11881 if test "${ac_cv_lib_m_asinh+set}" = set; then
11882   echo $ECHO_N "(cached) $ECHO_C" >&6
11883 else
11884   ac_check_lib_save_LIBS=$LIBS
11885 LIBS="-lm  $LIBS"
11886 if test x$gcc_no_link = xyes; then
11887   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11888 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11889    { (exit 1); exit 1; }; }
11890 fi
11891 cat >conftest.$ac_ext <<_ACEOF
11892 /* confdefs.h.  */
11893 _ACEOF
11894 cat confdefs.h >>conftest.$ac_ext
11895 cat >>conftest.$ac_ext <<_ACEOF
11896 /* end confdefs.h.  */
11897
11898 /* Override any gcc2 internal prototype to avoid an error.  */
11899 #ifdef __cplusplus
11900 extern "C"
11901 #endif
11902 /* We use char because int might match the return type of a gcc2
11903    builtin and then its argument prototype would still apply.  */
11904 char asinh ();
11905 int
11906 main ()
11907 {
11908 asinh ();
11909   ;
11910   return 0;
11911 }
11912 _ACEOF
11913 rm -f conftest.$ac_objext conftest$ac_exeext
11914 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11915   (eval $ac_link) 2>conftest.er1
11916   ac_status=$?
11917   grep -v '^ *+' conftest.er1 >conftest.err
11918   rm -f conftest.er1
11919   cat conftest.err >&5
11920   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11921   (exit $ac_status); } &&
11922          { ac_try='test -z "$ac_c_werror_flag"
11923                          || test ! -s conftest.err'
11924   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11925   (eval $ac_try) 2>&5
11926   ac_status=$?
11927   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11928   (exit $ac_status); }; } &&
11929          { ac_try='test -s conftest$ac_exeext'
11930   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11931   (eval $ac_try) 2>&5
11932   ac_status=$?
11933   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11934   (exit $ac_status); }; }; then
11935   ac_cv_lib_m_asinh=yes
11936 else
11937   echo "$as_me: failed program was:" >&5
11938 sed 's/^/| /' conftest.$ac_ext >&5
11939
11940 ac_cv_lib_m_asinh=no
11941 fi
11942 rm -f conftest.err conftest.$ac_objext \
11943       conftest$ac_exeext conftest.$ac_ext
11944 LIBS=$ac_check_lib_save_LIBS
11945 fi
11946 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinh" >&5
11947 echo "${ECHO_T}$ac_cv_lib_m_asinh" >&6
11948 if test $ac_cv_lib_m_asinh = yes; then
11949
11950 cat >>confdefs.h <<\_ACEOF
11951 #define HAVE_ASINH 1
11952 _ACEOF
11953
11954 fi
11955
11956 echo "$as_me:$LINENO: checking for asinhl in -lm" >&5
11957 echo $ECHO_N "checking for asinhl in -lm... $ECHO_C" >&6
11958 if test "${ac_cv_lib_m_asinhl+set}" = set; then
11959   echo $ECHO_N "(cached) $ECHO_C" >&6
11960 else
11961   ac_check_lib_save_LIBS=$LIBS
11962 LIBS="-lm  $LIBS"
11963 if test x$gcc_no_link = xyes; then
11964   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11965 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11966    { (exit 1); exit 1; }; }
11967 fi
11968 cat >conftest.$ac_ext <<_ACEOF
11969 /* confdefs.h.  */
11970 _ACEOF
11971 cat confdefs.h >>conftest.$ac_ext
11972 cat >>conftest.$ac_ext <<_ACEOF
11973 /* end confdefs.h.  */
11974
11975 /* Override any gcc2 internal prototype to avoid an error.  */
11976 #ifdef __cplusplus
11977 extern "C"
11978 #endif
11979 /* We use char because int might match the return type of a gcc2
11980    builtin and then its argument prototype would still apply.  */
11981 char asinhl ();
11982 int
11983 main ()
11984 {
11985 asinhl ();
11986   ;
11987   return 0;
11988 }
11989 _ACEOF
11990 rm -f conftest.$ac_objext conftest$ac_exeext
11991 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11992   (eval $ac_link) 2>conftest.er1
11993   ac_status=$?
11994   grep -v '^ *+' conftest.er1 >conftest.err
11995   rm -f conftest.er1
11996   cat conftest.err >&5
11997   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11998   (exit $ac_status); } &&
11999          { ac_try='test -z "$ac_c_werror_flag"
12000                          || test ! -s conftest.err'
12001   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12002   (eval $ac_try) 2>&5
12003   ac_status=$?
12004   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12005   (exit $ac_status); }; } &&
12006          { ac_try='test -s conftest$ac_exeext'
12007   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12008   (eval $ac_try) 2>&5
12009   ac_status=$?
12010   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12011   (exit $ac_status); }; }; then
12012   ac_cv_lib_m_asinhl=yes
12013 else
12014   echo "$as_me: failed program was:" >&5
12015 sed 's/^/| /' conftest.$ac_ext >&5
12016
12017 ac_cv_lib_m_asinhl=no
12018 fi
12019 rm -f conftest.err conftest.$ac_objext \
12020       conftest$ac_exeext conftest.$ac_ext
12021 LIBS=$ac_check_lib_save_LIBS
12022 fi
12023 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinhl" >&5
12024 echo "${ECHO_T}$ac_cv_lib_m_asinhl" >&6
12025 if test $ac_cv_lib_m_asinhl = yes; then
12026
12027 cat >>confdefs.h <<\_ACEOF
12028 #define HAVE_ASINHL 1
12029 _ACEOF
12030
12031 fi
12032
12033 echo "$as_me:$LINENO: checking for atan2f in -lm" >&5
12034 echo $ECHO_N "checking for atan2f in -lm... $ECHO_C" >&6
12035 if test "${ac_cv_lib_m_atan2f+set}" = set; then
12036   echo $ECHO_N "(cached) $ECHO_C" >&6
12037 else
12038   ac_check_lib_save_LIBS=$LIBS
12039 LIBS="-lm  $LIBS"
12040 if test x$gcc_no_link = xyes; then
12041   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12042 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12043    { (exit 1); exit 1; }; }
12044 fi
12045 cat >conftest.$ac_ext <<_ACEOF
12046 /* confdefs.h.  */
12047 _ACEOF
12048 cat confdefs.h >>conftest.$ac_ext
12049 cat >>conftest.$ac_ext <<_ACEOF
12050 /* end confdefs.h.  */
12051
12052 /* Override any gcc2 internal prototype to avoid an error.  */
12053 #ifdef __cplusplus
12054 extern "C"
12055 #endif
12056 /* We use char because int might match the return type of a gcc2
12057    builtin and then its argument prototype would still apply.  */
12058 char atan2f ();
12059 int
12060 main ()
12061 {
12062 atan2f ();
12063   ;
12064   return 0;
12065 }
12066 _ACEOF
12067 rm -f conftest.$ac_objext conftest$ac_exeext
12068 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12069   (eval $ac_link) 2>conftest.er1
12070   ac_status=$?
12071   grep -v '^ *+' conftest.er1 >conftest.err
12072   rm -f conftest.er1
12073   cat conftest.err >&5
12074   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12075   (exit $ac_status); } &&
12076          { ac_try='test -z "$ac_c_werror_flag"
12077                          || test ! -s conftest.err'
12078   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12079   (eval $ac_try) 2>&5
12080   ac_status=$?
12081   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12082   (exit $ac_status); }; } &&
12083          { ac_try='test -s conftest$ac_exeext'
12084   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12085   (eval $ac_try) 2>&5
12086   ac_status=$?
12087   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12088   (exit $ac_status); }; }; then
12089   ac_cv_lib_m_atan2f=yes
12090 else
12091   echo "$as_me: failed program was:" >&5
12092 sed 's/^/| /' conftest.$ac_ext >&5
12093
12094 ac_cv_lib_m_atan2f=no
12095 fi
12096 rm -f conftest.err conftest.$ac_objext \
12097       conftest$ac_exeext conftest.$ac_ext
12098 LIBS=$ac_check_lib_save_LIBS
12099 fi
12100 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2f" >&5
12101 echo "${ECHO_T}$ac_cv_lib_m_atan2f" >&6
12102 if test $ac_cv_lib_m_atan2f = yes; then
12103
12104 cat >>confdefs.h <<\_ACEOF
12105 #define HAVE_ATAN2F 1
12106 _ACEOF
12107
12108 fi
12109
12110 echo "$as_me:$LINENO: checking for atan2 in -lm" >&5
12111 echo $ECHO_N "checking for atan2 in -lm... $ECHO_C" >&6
12112 if test "${ac_cv_lib_m_atan2+set}" = set; then
12113   echo $ECHO_N "(cached) $ECHO_C" >&6
12114 else
12115   ac_check_lib_save_LIBS=$LIBS
12116 LIBS="-lm  $LIBS"
12117 if test x$gcc_no_link = xyes; then
12118   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12119 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12120    { (exit 1); exit 1; }; }
12121 fi
12122 cat >conftest.$ac_ext <<_ACEOF
12123 /* confdefs.h.  */
12124 _ACEOF
12125 cat confdefs.h >>conftest.$ac_ext
12126 cat >>conftest.$ac_ext <<_ACEOF
12127 /* end confdefs.h.  */
12128
12129 /* Override any gcc2 internal prototype to avoid an error.  */
12130 #ifdef __cplusplus
12131 extern "C"
12132 #endif
12133 /* We use char because int might match the return type of a gcc2
12134    builtin and then its argument prototype would still apply.  */
12135 char atan2 ();
12136 int
12137 main ()
12138 {
12139 atan2 ();
12140   ;
12141   return 0;
12142 }
12143 _ACEOF
12144 rm -f conftest.$ac_objext conftest$ac_exeext
12145 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12146   (eval $ac_link) 2>conftest.er1
12147   ac_status=$?
12148   grep -v '^ *+' conftest.er1 >conftest.err
12149   rm -f conftest.er1
12150   cat conftest.err >&5
12151   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12152   (exit $ac_status); } &&
12153          { ac_try='test -z "$ac_c_werror_flag"
12154                          || test ! -s conftest.err'
12155   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12156   (eval $ac_try) 2>&5
12157   ac_status=$?
12158   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12159   (exit $ac_status); }; } &&
12160          { ac_try='test -s conftest$ac_exeext'
12161   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12162   (eval $ac_try) 2>&5
12163   ac_status=$?
12164   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12165   (exit $ac_status); }; }; then
12166   ac_cv_lib_m_atan2=yes
12167 else
12168   echo "$as_me: failed program was:" >&5
12169 sed 's/^/| /' conftest.$ac_ext >&5
12170
12171 ac_cv_lib_m_atan2=no
12172 fi
12173 rm -f conftest.err conftest.$ac_objext \
12174       conftest$ac_exeext conftest.$ac_ext
12175 LIBS=$ac_check_lib_save_LIBS
12176 fi
12177 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2" >&5
12178 echo "${ECHO_T}$ac_cv_lib_m_atan2" >&6
12179 if test $ac_cv_lib_m_atan2 = yes; then
12180
12181 cat >>confdefs.h <<\_ACEOF
12182 #define HAVE_ATAN2 1
12183 _ACEOF
12184
12185 fi
12186
12187 echo "$as_me:$LINENO: checking for atan2l in -lm" >&5
12188 echo $ECHO_N "checking for atan2l in -lm... $ECHO_C" >&6
12189 if test "${ac_cv_lib_m_atan2l+set}" = set; then
12190   echo $ECHO_N "(cached) $ECHO_C" >&6
12191 else
12192   ac_check_lib_save_LIBS=$LIBS
12193 LIBS="-lm  $LIBS"
12194 if test x$gcc_no_link = xyes; then
12195   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12196 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12197    { (exit 1); exit 1; }; }
12198 fi
12199 cat >conftest.$ac_ext <<_ACEOF
12200 /* confdefs.h.  */
12201 _ACEOF
12202 cat confdefs.h >>conftest.$ac_ext
12203 cat >>conftest.$ac_ext <<_ACEOF
12204 /* end confdefs.h.  */
12205
12206 /* Override any gcc2 internal prototype to avoid an error.  */
12207 #ifdef __cplusplus
12208 extern "C"
12209 #endif
12210 /* We use char because int might match the return type of a gcc2
12211    builtin and then its argument prototype would still apply.  */
12212 char atan2l ();
12213 int
12214 main ()
12215 {
12216 atan2l ();
12217   ;
12218   return 0;
12219 }
12220 _ACEOF
12221 rm -f conftest.$ac_objext conftest$ac_exeext
12222 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12223   (eval $ac_link) 2>conftest.er1
12224   ac_status=$?
12225   grep -v '^ *+' conftest.er1 >conftest.err
12226   rm -f conftest.er1
12227   cat conftest.err >&5
12228   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12229   (exit $ac_status); } &&
12230          { ac_try='test -z "$ac_c_werror_flag"
12231                          || test ! -s conftest.err'
12232   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12233   (eval $ac_try) 2>&5
12234   ac_status=$?
12235   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12236   (exit $ac_status); }; } &&
12237          { ac_try='test -s conftest$ac_exeext'
12238   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12239   (eval $ac_try) 2>&5
12240   ac_status=$?
12241   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12242   (exit $ac_status); }; }; then
12243   ac_cv_lib_m_atan2l=yes
12244 else
12245   echo "$as_me: failed program was:" >&5
12246 sed 's/^/| /' conftest.$ac_ext >&5
12247
12248 ac_cv_lib_m_atan2l=no
12249 fi
12250 rm -f conftest.err conftest.$ac_objext \
12251       conftest$ac_exeext conftest.$ac_ext
12252 LIBS=$ac_check_lib_save_LIBS
12253 fi
12254 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2l" >&5
12255 echo "${ECHO_T}$ac_cv_lib_m_atan2l" >&6
12256 if test $ac_cv_lib_m_atan2l = yes; then
12257
12258 cat >>confdefs.h <<\_ACEOF
12259 #define HAVE_ATAN2L 1
12260 _ACEOF
12261
12262 fi
12263
12264 echo "$as_me:$LINENO: checking for atanf in -lm" >&5
12265 echo $ECHO_N "checking for atanf in -lm... $ECHO_C" >&6
12266 if test "${ac_cv_lib_m_atanf+set}" = set; then
12267   echo $ECHO_N "(cached) $ECHO_C" >&6
12268 else
12269   ac_check_lib_save_LIBS=$LIBS
12270 LIBS="-lm  $LIBS"
12271 if test x$gcc_no_link = xyes; then
12272   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12273 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12274    { (exit 1); exit 1; }; }
12275 fi
12276 cat >conftest.$ac_ext <<_ACEOF
12277 /* confdefs.h.  */
12278 _ACEOF
12279 cat confdefs.h >>conftest.$ac_ext
12280 cat >>conftest.$ac_ext <<_ACEOF
12281 /* end confdefs.h.  */
12282
12283 /* Override any gcc2 internal prototype to avoid an error.  */
12284 #ifdef __cplusplus
12285 extern "C"
12286 #endif
12287 /* We use char because int might match the return type of a gcc2
12288    builtin and then its argument prototype would still apply.  */
12289 char atanf ();
12290 int
12291 main ()
12292 {
12293 atanf ();
12294   ;
12295   return 0;
12296 }
12297 _ACEOF
12298 rm -f conftest.$ac_objext conftest$ac_exeext
12299 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12300   (eval $ac_link) 2>conftest.er1
12301   ac_status=$?
12302   grep -v '^ *+' conftest.er1 >conftest.err
12303   rm -f conftest.er1
12304   cat conftest.err >&5
12305   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12306   (exit $ac_status); } &&
12307          { ac_try='test -z "$ac_c_werror_flag"
12308                          || test ! -s conftest.err'
12309   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12310   (eval $ac_try) 2>&5
12311   ac_status=$?
12312   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12313   (exit $ac_status); }; } &&
12314          { ac_try='test -s conftest$ac_exeext'
12315   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12316   (eval $ac_try) 2>&5
12317   ac_status=$?
12318   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12319   (exit $ac_status); }; }; then
12320   ac_cv_lib_m_atanf=yes
12321 else
12322   echo "$as_me: failed program was:" >&5
12323 sed 's/^/| /' conftest.$ac_ext >&5
12324
12325 ac_cv_lib_m_atanf=no
12326 fi
12327 rm -f conftest.err conftest.$ac_objext \
12328       conftest$ac_exeext conftest.$ac_ext
12329 LIBS=$ac_check_lib_save_LIBS
12330 fi
12331 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanf" >&5
12332 echo "${ECHO_T}$ac_cv_lib_m_atanf" >&6
12333 if test $ac_cv_lib_m_atanf = yes; then
12334
12335 cat >>confdefs.h <<\_ACEOF
12336 #define HAVE_ATANF 1
12337 _ACEOF
12338
12339 fi
12340
12341 echo "$as_me:$LINENO: checking for atan in -lm" >&5
12342 echo $ECHO_N "checking for atan in -lm... $ECHO_C" >&6
12343 if test "${ac_cv_lib_m_atan+set}" = set; then
12344   echo $ECHO_N "(cached) $ECHO_C" >&6
12345 else
12346   ac_check_lib_save_LIBS=$LIBS
12347 LIBS="-lm  $LIBS"
12348 if test x$gcc_no_link = xyes; then
12349   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12350 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12351    { (exit 1); exit 1; }; }
12352 fi
12353 cat >conftest.$ac_ext <<_ACEOF
12354 /* confdefs.h.  */
12355 _ACEOF
12356 cat confdefs.h >>conftest.$ac_ext
12357 cat >>conftest.$ac_ext <<_ACEOF
12358 /* end confdefs.h.  */
12359
12360 /* Override any gcc2 internal prototype to avoid an error.  */
12361 #ifdef __cplusplus
12362 extern "C"
12363 #endif
12364 /* We use char because int might match the return type of a gcc2
12365    builtin and then its argument prototype would still apply.  */
12366 char atan ();
12367 int
12368 main ()
12369 {
12370 atan ();
12371   ;
12372   return 0;
12373 }
12374 _ACEOF
12375 rm -f conftest.$ac_objext conftest$ac_exeext
12376 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12377   (eval $ac_link) 2>conftest.er1
12378   ac_status=$?
12379   grep -v '^ *+' conftest.er1 >conftest.err
12380   rm -f conftest.er1
12381   cat conftest.err >&5
12382   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12383   (exit $ac_status); } &&
12384          { ac_try='test -z "$ac_c_werror_flag"
12385                          || test ! -s conftest.err'
12386   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12387   (eval $ac_try) 2>&5
12388   ac_status=$?
12389   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12390   (exit $ac_status); }; } &&
12391          { ac_try='test -s conftest$ac_exeext'
12392   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12393   (eval $ac_try) 2>&5
12394   ac_status=$?
12395   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12396   (exit $ac_status); }; }; then
12397   ac_cv_lib_m_atan=yes
12398 else
12399   echo "$as_me: failed program was:" >&5
12400 sed 's/^/| /' conftest.$ac_ext >&5
12401
12402 ac_cv_lib_m_atan=no
12403 fi
12404 rm -f conftest.err conftest.$ac_objext \
12405       conftest$ac_exeext conftest.$ac_ext
12406 LIBS=$ac_check_lib_save_LIBS
12407 fi
12408 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan" >&5
12409 echo "${ECHO_T}$ac_cv_lib_m_atan" >&6
12410 if test $ac_cv_lib_m_atan = yes; then
12411
12412 cat >>confdefs.h <<\_ACEOF
12413 #define HAVE_ATAN 1
12414 _ACEOF
12415
12416 fi
12417
12418 echo "$as_me:$LINENO: checking for atanl in -lm" >&5
12419 echo $ECHO_N "checking for atanl in -lm... $ECHO_C" >&6
12420 if test "${ac_cv_lib_m_atanl+set}" = set; then
12421   echo $ECHO_N "(cached) $ECHO_C" >&6
12422 else
12423   ac_check_lib_save_LIBS=$LIBS
12424 LIBS="-lm  $LIBS"
12425 if test x$gcc_no_link = xyes; then
12426   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12427 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12428    { (exit 1); exit 1; }; }
12429 fi
12430 cat >conftest.$ac_ext <<_ACEOF
12431 /* confdefs.h.  */
12432 _ACEOF
12433 cat confdefs.h >>conftest.$ac_ext
12434 cat >>conftest.$ac_ext <<_ACEOF
12435 /* end confdefs.h.  */
12436
12437 /* Override any gcc2 internal prototype to avoid an error.  */
12438 #ifdef __cplusplus
12439 extern "C"
12440 #endif
12441 /* We use char because int might match the return type of a gcc2
12442    builtin and then its argument prototype would still apply.  */
12443 char atanl ();
12444 int
12445 main ()
12446 {
12447 atanl ();
12448   ;
12449   return 0;
12450 }
12451 _ACEOF
12452 rm -f conftest.$ac_objext conftest$ac_exeext
12453 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12454   (eval $ac_link) 2>conftest.er1
12455   ac_status=$?
12456   grep -v '^ *+' conftest.er1 >conftest.err
12457   rm -f conftest.er1
12458   cat conftest.err >&5
12459   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12460   (exit $ac_status); } &&
12461          { ac_try='test -z "$ac_c_werror_flag"
12462                          || test ! -s conftest.err'
12463   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12464   (eval $ac_try) 2>&5
12465   ac_status=$?
12466   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12467   (exit $ac_status); }; } &&
12468          { ac_try='test -s conftest$ac_exeext'
12469   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12470   (eval $ac_try) 2>&5
12471   ac_status=$?
12472   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12473   (exit $ac_status); }; }; then
12474   ac_cv_lib_m_atanl=yes
12475 else
12476   echo "$as_me: failed program was:" >&5
12477 sed 's/^/| /' conftest.$ac_ext >&5
12478
12479 ac_cv_lib_m_atanl=no
12480 fi
12481 rm -f conftest.err conftest.$ac_objext \
12482       conftest$ac_exeext conftest.$ac_ext
12483 LIBS=$ac_check_lib_save_LIBS
12484 fi
12485 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanl" >&5
12486 echo "${ECHO_T}$ac_cv_lib_m_atanl" >&6
12487 if test $ac_cv_lib_m_atanl = yes; then
12488
12489 cat >>confdefs.h <<\_ACEOF
12490 #define HAVE_ATANL 1
12491 _ACEOF
12492
12493 fi
12494
12495 echo "$as_me:$LINENO: checking for atanhf in -lm" >&5
12496 echo $ECHO_N "checking for atanhf in -lm... $ECHO_C" >&6
12497 if test "${ac_cv_lib_m_atanhf+set}" = set; then
12498   echo $ECHO_N "(cached) $ECHO_C" >&6
12499 else
12500   ac_check_lib_save_LIBS=$LIBS
12501 LIBS="-lm  $LIBS"
12502 if test x$gcc_no_link = xyes; then
12503   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12504 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12505    { (exit 1); exit 1; }; }
12506 fi
12507 cat >conftest.$ac_ext <<_ACEOF
12508 /* confdefs.h.  */
12509 _ACEOF
12510 cat confdefs.h >>conftest.$ac_ext
12511 cat >>conftest.$ac_ext <<_ACEOF
12512 /* end confdefs.h.  */
12513
12514 /* Override any gcc2 internal prototype to avoid an error.  */
12515 #ifdef __cplusplus
12516 extern "C"
12517 #endif
12518 /* We use char because int might match the return type of a gcc2
12519    builtin and then its argument prototype would still apply.  */
12520 char atanhf ();
12521 int
12522 main ()
12523 {
12524 atanhf ();
12525   ;
12526   return 0;
12527 }
12528 _ACEOF
12529 rm -f conftest.$ac_objext conftest$ac_exeext
12530 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12531   (eval $ac_link) 2>conftest.er1
12532   ac_status=$?
12533   grep -v '^ *+' conftest.er1 >conftest.err
12534   rm -f conftest.er1
12535   cat conftest.err >&5
12536   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12537   (exit $ac_status); } &&
12538          { ac_try='test -z "$ac_c_werror_flag"
12539                          || test ! -s conftest.err'
12540   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12541   (eval $ac_try) 2>&5
12542   ac_status=$?
12543   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12544   (exit $ac_status); }; } &&
12545          { ac_try='test -s conftest$ac_exeext'
12546   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12547   (eval $ac_try) 2>&5
12548   ac_status=$?
12549   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12550   (exit $ac_status); }; }; then
12551   ac_cv_lib_m_atanhf=yes
12552 else
12553   echo "$as_me: failed program was:" >&5
12554 sed 's/^/| /' conftest.$ac_ext >&5
12555
12556 ac_cv_lib_m_atanhf=no
12557 fi
12558 rm -f conftest.err conftest.$ac_objext \
12559       conftest$ac_exeext conftest.$ac_ext
12560 LIBS=$ac_check_lib_save_LIBS
12561 fi
12562 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanhf" >&5
12563 echo "${ECHO_T}$ac_cv_lib_m_atanhf" >&6
12564 if test $ac_cv_lib_m_atanhf = yes; then
12565
12566 cat >>confdefs.h <<\_ACEOF
12567 #define HAVE_ATANHF 1
12568 _ACEOF
12569
12570 fi
12571
12572 echo "$as_me:$LINENO: checking for atanh in -lm" >&5
12573 echo $ECHO_N "checking for atanh in -lm... $ECHO_C" >&6
12574 if test "${ac_cv_lib_m_atanh+set}" = set; then
12575   echo $ECHO_N "(cached) $ECHO_C" >&6
12576 else
12577   ac_check_lib_save_LIBS=$LIBS
12578 LIBS="-lm  $LIBS"
12579 if test x$gcc_no_link = xyes; then
12580   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12581 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12582    { (exit 1); exit 1; }; }
12583 fi
12584 cat >conftest.$ac_ext <<_ACEOF
12585 /* confdefs.h.  */
12586 _ACEOF
12587 cat confdefs.h >>conftest.$ac_ext
12588 cat >>conftest.$ac_ext <<_ACEOF
12589 /* end confdefs.h.  */
12590
12591 /* Override any gcc2 internal prototype to avoid an error.  */
12592 #ifdef __cplusplus
12593 extern "C"
12594 #endif
12595 /* We use char because int might match the return type of a gcc2
12596    builtin and then its argument prototype would still apply.  */
12597 char atanh ();
12598 int
12599 main ()
12600 {
12601 atanh ();
12602   ;
12603   return 0;
12604 }
12605 _ACEOF
12606 rm -f conftest.$ac_objext conftest$ac_exeext
12607 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12608   (eval $ac_link) 2>conftest.er1
12609   ac_status=$?
12610   grep -v '^ *+' conftest.er1 >conftest.err
12611   rm -f conftest.er1
12612   cat conftest.err >&5
12613   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12614   (exit $ac_status); } &&
12615          { ac_try='test -z "$ac_c_werror_flag"
12616                          || test ! -s conftest.err'
12617   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12618   (eval $ac_try) 2>&5
12619   ac_status=$?
12620   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12621   (exit $ac_status); }; } &&
12622          { ac_try='test -s conftest$ac_exeext'
12623   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12624   (eval $ac_try) 2>&5
12625   ac_status=$?
12626   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12627   (exit $ac_status); }; }; then
12628   ac_cv_lib_m_atanh=yes
12629 else
12630   echo "$as_me: failed program was:" >&5
12631 sed 's/^/| /' conftest.$ac_ext >&5
12632
12633 ac_cv_lib_m_atanh=no
12634 fi
12635 rm -f conftest.err conftest.$ac_objext \
12636       conftest$ac_exeext conftest.$ac_ext
12637 LIBS=$ac_check_lib_save_LIBS
12638 fi
12639 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanh" >&5
12640 echo "${ECHO_T}$ac_cv_lib_m_atanh" >&6
12641 if test $ac_cv_lib_m_atanh = yes; then
12642
12643 cat >>confdefs.h <<\_ACEOF
12644 #define HAVE_ATANH 1
12645 _ACEOF
12646
12647 fi
12648
12649 echo "$as_me:$LINENO: checking for atanhl in -lm" >&5
12650 echo $ECHO_N "checking for atanhl in -lm... $ECHO_C" >&6
12651 if test "${ac_cv_lib_m_atanhl+set}" = set; then
12652   echo $ECHO_N "(cached) $ECHO_C" >&6
12653 else
12654   ac_check_lib_save_LIBS=$LIBS
12655 LIBS="-lm  $LIBS"
12656 if test x$gcc_no_link = xyes; then
12657   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12658 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12659    { (exit 1); exit 1; }; }
12660 fi
12661 cat >conftest.$ac_ext <<_ACEOF
12662 /* confdefs.h.  */
12663 _ACEOF
12664 cat confdefs.h >>conftest.$ac_ext
12665 cat >>conftest.$ac_ext <<_ACEOF
12666 /* end confdefs.h.  */
12667
12668 /* Override any gcc2 internal prototype to avoid an error.  */
12669 #ifdef __cplusplus
12670 extern "C"
12671 #endif
12672 /* We use char because int might match the return type of a gcc2
12673    builtin and then its argument prototype would still apply.  */
12674 char atanhl ();
12675 int
12676 main ()
12677 {
12678 atanhl ();
12679   ;
12680   return 0;
12681 }
12682 _ACEOF
12683 rm -f conftest.$ac_objext conftest$ac_exeext
12684 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12685   (eval $ac_link) 2>conftest.er1
12686   ac_status=$?
12687   grep -v '^ *+' conftest.er1 >conftest.err
12688   rm -f conftest.er1
12689   cat conftest.err >&5
12690   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12691   (exit $ac_status); } &&
12692          { ac_try='test -z "$ac_c_werror_flag"
12693                          || test ! -s conftest.err'
12694   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12695   (eval $ac_try) 2>&5
12696   ac_status=$?
12697   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12698   (exit $ac_status); }; } &&
12699          { ac_try='test -s conftest$ac_exeext'
12700   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12701   (eval $ac_try) 2>&5
12702   ac_status=$?
12703   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12704   (exit $ac_status); }; }; then
12705   ac_cv_lib_m_atanhl=yes
12706 else
12707   echo "$as_me: failed program was:" >&5
12708 sed 's/^/| /' conftest.$ac_ext >&5
12709
12710 ac_cv_lib_m_atanhl=no
12711 fi
12712 rm -f conftest.err conftest.$ac_objext \
12713       conftest$ac_exeext conftest.$ac_ext
12714 LIBS=$ac_check_lib_save_LIBS
12715 fi
12716 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanhl" >&5
12717 echo "${ECHO_T}$ac_cv_lib_m_atanhl" >&6
12718 if test $ac_cv_lib_m_atanhl = yes; then
12719
12720 cat >>confdefs.h <<\_ACEOF
12721 #define HAVE_ATANHL 1
12722 _ACEOF
12723
12724 fi
12725
12726 echo "$as_me:$LINENO: checking for cargf in -lm" >&5
12727 echo $ECHO_N "checking for cargf in -lm... $ECHO_C" >&6
12728 if test "${ac_cv_lib_m_cargf+set}" = set; then
12729   echo $ECHO_N "(cached) $ECHO_C" >&6
12730 else
12731   ac_check_lib_save_LIBS=$LIBS
12732 LIBS="-lm  $LIBS"
12733 if test x$gcc_no_link = xyes; then
12734   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12735 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12736    { (exit 1); exit 1; }; }
12737 fi
12738 cat >conftest.$ac_ext <<_ACEOF
12739 /* confdefs.h.  */
12740 _ACEOF
12741 cat confdefs.h >>conftest.$ac_ext
12742 cat >>conftest.$ac_ext <<_ACEOF
12743 /* end confdefs.h.  */
12744
12745 /* Override any gcc2 internal prototype to avoid an error.  */
12746 #ifdef __cplusplus
12747 extern "C"
12748 #endif
12749 /* We use char because int might match the return type of a gcc2
12750    builtin and then its argument prototype would still apply.  */
12751 char cargf ();
12752 int
12753 main ()
12754 {
12755 cargf ();
12756   ;
12757   return 0;
12758 }
12759 _ACEOF
12760 rm -f conftest.$ac_objext conftest$ac_exeext
12761 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12762   (eval $ac_link) 2>conftest.er1
12763   ac_status=$?
12764   grep -v '^ *+' conftest.er1 >conftest.err
12765   rm -f conftest.er1
12766   cat conftest.err >&5
12767   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12768   (exit $ac_status); } &&
12769          { ac_try='test -z "$ac_c_werror_flag"
12770                          || test ! -s conftest.err'
12771   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12772   (eval $ac_try) 2>&5
12773   ac_status=$?
12774   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12775   (exit $ac_status); }; } &&
12776          { ac_try='test -s conftest$ac_exeext'
12777   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12778   (eval $ac_try) 2>&5
12779   ac_status=$?
12780   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12781   (exit $ac_status); }; }; then
12782   ac_cv_lib_m_cargf=yes
12783 else
12784   echo "$as_me: failed program was:" >&5
12785 sed 's/^/| /' conftest.$ac_ext >&5
12786
12787 ac_cv_lib_m_cargf=no
12788 fi
12789 rm -f conftest.err conftest.$ac_objext \
12790       conftest$ac_exeext conftest.$ac_ext
12791 LIBS=$ac_check_lib_save_LIBS
12792 fi
12793 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cargf" >&5
12794 echo "${ECHO_T}$ac_cv_lib_m_cargf" >&6
12795 if test $ac_cv_lib_m_cargf = yes; then
12796
12797 cat >>confdefs.h <<\_ACEOF
12798 #define HAVE_CARGF 1
12799 _ACEOF
12800
12801 fi
12802
12803 echo "$as_me:$LINENO: checking for carg in -lm" >&5
12804 echo $ECHO_N "checking for carg in -lm... $ECHO_C" >&6
12805 if test "${ac_cv_lib_m_carg+set}" = set; then
12806   echo $ECHO_N "(cached) $ECHO_C" >&6
12807 else
12808   ac_check_lib_save_LIBS=$LIBS
12809 LIBS="-lm  $LIBS"
12810 if test x$gcc_no_link = xyes; then
12811   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12812 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12813    { (exit 1); exit 1; }; }
12814 fi
12815 cat >conftest.$ac_ext <<_ACEOF
12816 /* confdefs.h.  */
12817 _ACEOF
12818 cat confdefs.h >>conftest.$ac_ext
12819 cat >>conftest.$ac_ext <<_ACEOF
12820 /* end confdefs.h.  */
12821
12822 /* Override any gcc2 internal prototype to avoid an error.  */
12823 #ifdef __cplusplus
12824 extern "C"
12825 #endif
12826 /* We use char because int might match the return type of a gcc2
12827    builtin and then its argument prototype would still apply.  */
12828 char carg ();
12829 int
12830 main ()
12831 {
12832 carg ();
12833   ;
12834   return 0;
12835 }
12836 _ACEOF
12837 rm -f conftest.$ac_objext conftest$ac_exeext
12838 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12839   (eval $ac_link) 2>conftest.er1
12840   ac_status=$?
12841   grep -v '^ *+' conftest.er1 >conftest.err
12842   rm -f conftest.er1
12843   cat conftest.err >&5
12844   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12845   (exit $ac_status); } &&
12846          { ac_try='test -z "$ac_c_werror_flag"
12847                          || test ! -s conftest.err'
12848   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12849   (eval $ac_try) 2>&5
12850   ac_status=$?
12851   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12852   (exit $ac_status); }; } &&
12853          { ac_try='test -s conftest$ac_exeext'
12854   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12855   (eval $ac_try) 2>&5
12856   ac_status=$?
12857   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12858   (exit $ac_status); }; }; then
12859   ac_cv_lib_m_carg=yes
12860 else
12861   echo "$as_me: failed program was:" >&5
12862 sed 's/^/| /' conftest.$ac_ext >&5
12863
12864 ac_cv_lib_m_carg=no
12865 fi
12866 rm -f conftest.err conftest.$ac_objext \
12867       conftest$ac_exeext conftest.$ac_ext
12868 LIBS=$ac_check_lib_save_LIBS
12869 fi
12870 echo "$as_me:$LINENO: result: $ac_cv_lib_m_carg" >&5
12871 echo "${ECHO_T}$ac_cv_lib_m_carg" >&6
12872 if test $ac_cv_lib_m_carg = yes; then
12873
12874 cat >>confdefs.h <<\_ACEOF
12875 #define HAVE_CARG 1
12876 _ACEOF
12877
12878 fi
12879
12880 echo "$as_me:$LINENO: checking for cargl in -lm" >&5
12881 echo $ECHO_N "checking for cargl in -lm... $ECHO_C" >&6
12882 if test "${ac_cv_lib_m_cargl+set}" = set; then
12883   echo $ECHO_N "(cached) $ECHO_C" >&6
12884 else
12885   ac_check_lib_save_LIBS=$LIBS
12886 LIBS="-lm  $LIBS"
12887 if test x$gcc_no_link = xyes; then
12888   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12889 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12890    { (exit 1); exit 1; }; }
12891 fi
12892 cat >conftest.$ac_ext <<_ACEOF
12893 /* confdefs.h.  */
12894 _ACEOF
12895 cat confdefs.h >>conftest.$ac_ext
12896 cat >>conftest.$ac_ext <<_ACEOF
12897 /* end confdefs.h.  */
12898
12899 /* Override any gcc2 internal prototype to avoid an error.  */
12900 #ifdef __cplusplus
12901 extern "C"
12902 #endif
12903 /* We use char because int might match the return type of a gcc2
12904    builtin and then its argument prototype would still apply.  */
12905 char cargl ();
12906 int
12907 main ()
12908 {
12909 cargl ();
12910   ;
12911   return 0;
12912 }
12913 _ACEOF
12914 rm -f conftest.$ac_objext conftest$ac_exeext
12915 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12916   (eval $ac_link) 2>conftest.er1
12917   ac_status=$?
12918   grep -v '^ *+' conftest.er1 >conftest.err
12919   rm -f conftest.er1
12920   cat conftest.err >&5
12921   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12922   (exit $ac_status); } &&
12923          { ac_try='test -z "$ac_c_werror_flag"
12924                          || test ! -s conftest.err'
12925   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12926   (eval $ac_try) 2>&5
12927   ac_status=$?
12928   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12929   (exit $ac_status); }; } &&
12930          { ac_try='test -s conftest$ac_exeext'
12931   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12932   (eval $ac_try) 2>&5
12933   ac_status=$?
12934   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12935   (exit $ac_status); }; }; then
12936   ac_cv_lib_m_cargl=yes
12937 else
12938   echo "$as_me: failed program was:" >&5
12939 sed 's/^/| /' conftest.$ac_ext >&5
12940
12941 ac_cv_lib_m_cargl=no
12942 fi
12943 rm -f conftest.err conftest.$ac_objext \
12944       conftest$ac_exeext conftest.$ac_ext
12945 LIBS=$ac_check_lib_save_LIBS
12946 fi
12947 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cargl" >&5
12948 echo "${ECHO_T}$ac_cv_lib_m_cargl" >&6
12949 if test $ac_cv_lib_m_cargl = yes; then
12950
12951 cat >>confdefs.h <<\_ACEOF
12952 #define HAVE_CARGL 1
12953 _ACEOF
12954
12955 fi
12956
12957 echo "$as_me:$LINENO: checking for ceilf in -lm" >&5
12958 echo $ECHO_N "checking for ceilf in -lm... $ECHO_C" >&6
12959 if test "${ac_cv_lib_m_ceilf+set}" = set; then
12960   echo $ECHO_N "(cached) $ECHO_C" >&6
12961 else
12962   ac_check_lib_save_LIBS=$LIBS
12963 LIBS="-lm  $LIBS"
12964 if test x$gcc_no_link = xyes; then
12965   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12966 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12967    { (exit 1); exit 1; }; }
12968 fi
12969 cat >conftest.$ac_ext <<_ACEOF
12970 /* confdefs.h.  */
12971 _ACEOF
12972 cat confdefs.h >>conftest.$ac_ext
12973 cat >>conftest.$ac_ext <<_ACEOF
12974 /* end confdefs.h.  */
12975
12976 /* Override any gcc2 internal prototype to avoid an error.  */
12977 #ifdef __cplusplus
12978 extern "C"
12979 #endif
12980 /* We use char because int might match the return type of a gcc2
12981    builtin and then its argument prototype would still apply.  */
12982 char ceilf ();
12983 int
12984 main ()
12985 {
12986 ceilf ();
12987   ;
12988   return 0;
12989 }
12990 _ACEOF
12991 rm -f conftest.$ac_objext conftest$ac_exeext
12992 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12993   (eval $ac_link) 2>conftest.er1
12994   ac_status=$?
12995   grep -v '^ *+' conftest.er1 >conftest.err
12996   rm -f conftest.er1
12997   cat conftest.err >&5
12998   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12999   (exit $ac_status); } &&
13000          { ac_try='test -z "$ac_c_werror_flag"
13001                          || test ! -s conftest.err'
13002   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13003   (eval $ac_try) 2>&5
13004   ac_status=$?
13005   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13006   (exit $ac_status); }; } &&
13007          { ac_try='test -s conftest$ac_exeext'
13008   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13009   (eval $ac_try) 2>&5
13010   ac_status=$?
13011   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13012   (exit $ac_status); }; }; then
13013   ac_cv_lib_m_ceilf=yes
13014 else
13015   echo "$as_me: failed program was:" >&5
13016 sed 's/^/| /' conftest.$ac_ext >&5
13017
13018 ac_cv_lib_m_ceilf=no
13019 fi
13020 rm -f conftest.err conftest.$ac_objext \
13021       conftest$ac_exeext conftest.$ac_ext
13022 LIBS=$ac_check_lib_save_LIBS
13023 fi
13024 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceilf" >&5
13025 echo "${ECHO_T}$ac_cv_lib_m_ceilf" >&6
13026 if test $ac_cv_lib_m_ceilf = yes; then
13027
13028 cat >>confdefs.h <<\_ACEOF
13029 #define HAVE_CEILF 1
13030 _ACEOF
13031
13032 fi
13033
13034 echo "$as_me:$LINENO: checking for ceil in -lm" >&5
13035 echo $ECHO_N "checking for ceil in -lm... $ECHO_C" >&6
13036 if test "${ac_cv_lib_m_ceil+set}" = set; then
13037   echo $ECHO_N "(cached) $ECHO_C" >&6
13038 else
13039   ac_check_lib_save_LIBS=$LIBS
13040 LIBS="-lm  $LIBS"
13041 if test x$gcc_no_link = xyes; then
13042   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13043 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13044    { (exit 1); exit 1; }; }
13045 fi
13046 cat >conftest.$ac_ext <<_ACEOF
13047 /* confdefs.h.  */
13048 _ACEOF
13049 cat confdefs.h >>conftest.$ac_ext
13050 cat >>conftest.$ac_ext <<_ACEOF
13051 /* end confdefs.h.  */
13052
13053 /* Override any gcc2 internal prototype to avoid an error.  */
13054 #ifdef __cplusplus
13055 extern "C"
13056 #endif
13057 /* We use char because int might match the return type of a gcc2
13058    builtin and then its argument prototype would still apply.  */
13059 char ceil ();
13060 int
13061 main ()
13062 {
13063 ceil ();
13064   ;
13065   return 0;
13066 }
13067 _ACEOF
13068 rm -f conftest.$ac_objext conftest$ac_exeext
13069 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13070   (eval $ac_link) 2>conftest.er1
13071   ac_status=$?
13072   grep -v '^ *+' conftest.er1 >conftest.err
13073   rm -f conftest.er1
13074   cat conftest.err >&5
13075   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13076   (exit $ac_status); } &&
13077          { ac_try='test -z "$ac_c_werror_flag"
13078                          || test ! -s conftest.err'
13079   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13080   (eval $ac_try) 2>&5
13081   ac_status=$?
13082   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13083   (exit $ac_status); }; } &&
13084          { ac_try='test -s conftest$ac_exeext'
13085   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13086   (eval $ac_try) 2>&5
13087   ac_status=$?
13088   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13089   (exit $ac_status); }; }; then
13090   ac_cv_lib_m_ceil=yes
13091 else
13092   echo "$as_me: failed program was:" >&5
13093 sed 's/^/| /' conftest.$ac_ext >&5
13094
13095 ac_cv_lib_m_ceil=no
13096 fi
13097 rm -f conftest.err conftest.$ac_objext \
13098       conftest$ac_exeext conftest.$ac_ext
13099 LIBS=$ac_check_lib_save_LIBS
13100 fi
13101 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceil" >&5
13102 echo "${ECHO_T}$ac_cv_lib_m_ceil" >&6
13103 if test $ac_cv_lib_m_ceil = yes; then
13104
13105 cat >>confdefs.h <<\_ACEOF
13106 #define HAVE_CEIL 1
13107 _ACEOF
13108
13109 fi
13110
13111 echo "$as_me:$LINENO: checking for ceill in -lm" >&5
13112 echo $ECHO_N "checking for ceill in -lm... $ECHO_C" >&6
13113 if test "${ac_cv_lib_m_ceill+set}" = set; then
13114   echo $ECHO_N "(cached) $ECHO_C" >&6
13115 else
13116   ac_check_lib_save_LIBS=$LIBS
13117 LIBS="-lm  $LIBS"
13118 if test x$gcc_no_link = xyes; then
13119   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13120 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13121    { (exit 1); exit 1; }; }
13122 fi
13123 cat >conftest.$ac_ext <<_ACEOF
13124 /* confdefs.h.  */
13125 _ACEOF
13126 cat confdefs.h >>conftest.$ac_ext
13127 cat >>conftest.$ac_ext <<_ACEOF
13128 /* end confdefs.h.  */
13129
13130 /* Override any gcc2 internal prototype to avoid an error.  */
13131 #ifdef __cplusplus
13132 extern "C"
13133 #endif
13134 /* We use char because int might match the return type of a gcc2
13135    builtin and then its argument prototype would still apply.  */
13136 char ceill ();
13137 int
13138 main ()
13139 {
13140 ceill ();
13141   ;
13142   return 0;
13143 }
13144 _ACEOF
13145 rm -f conftest.$ac_objext conftest$ac_exeext
13146 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13147   (eval $ac_link) 2>conftest.er1
13148   ac_status=$?
13149   grep -v '^ *+' conftest.er1 >conftest.err
13150   rm -f conftest.er1
13151   cat conftest.err >&5
13152   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13153   (exit $ac_status); } &&
13154          { ac_try='test -z "$ac_c_werror_flag"
13155                          || test ! -s conftest.err'
13156   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13157   (eval $ac_try) 2>&5
13158   ac_status=$?
13159   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13160   (exit $ac_status); }; } &&
13161          { ac_try='test -s conftest$ac_exeext'
13162   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13163   (eval $ac_try) 2>&5
13164   ac_status=$?
13165   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13166   (exit $ac_status); }; }; then
13167   ac_cv_lib_m_ceill=yes
13168 else
13169   echo "$as_me: failed program was:" >&5
13170 sed 's/^/| /' conftest.$ac_ext >&5
13171
13172 ac_cv_lib_m_ceill=no
13173 fi
13174 rm -f conftest.err conftest.$ac_objext \
13175       conftest$ac_exeext conftest.$ac_ext
13176 LIBS=$ac_check_lib_save_LIBS
13177 fi
13178 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceill" >&5
13179 echo "${ECHO_T}$ac_cv_lib_m_ceill" >&6
13180 if test $ac_cv_lib_m_ceill = yes; then
13181
13182 cat >>confdefs.h <<\_ACEOF
13183 #define HAVE_CEILL 1
13184 _ACEOF
13185
13186 fi
13187
13188 echo "$as_me:$LINENO: checking for copysignf in -lm" >&5
13189 echo $ECHO_N "checking for copysignf in -lm... $ECHO_C" >&6
13190 if test "${ac_cv_lib_m_copysignf+set}" = set; then
13191   echo $ECHO_N "(cached) $ECHO_C" >&6
13192 else
13193   ac_check_lib_save_LIBS=$LIBS
13194 LIBS="-lm  $LIBS"
13195 if test x$gcc_no_link = xyes; then
13196   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13197 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13198    { (exit 1); exit 1; }; }
13199 fi
13200 cat >conftest.$ac_ext <<_ACEOF
13201 /* confdefs.h.  */
13202 _ACEOF
13203 cat confdefs.h >>conftest.$ac_ext
13204 cat >>conftest.$ac_ext <<_ACEOF
13205 /* end confdefs.h.  */
13206
13207 /* Override any gcc2 internal prototype to avoid an error.  */
13208 #ifdef __cplusplus
13209 extern "C"
13210 #endif
13211 /* We use char because int might match the return type of a gcc2
13212    builtin and then its argument prototype would still apply.  */
13213 char copysignf ();
13214 int
13215 main ()
13216 {
13217 copysignf ();
13218   ;
13219   return 0;
13220 }
13221 _ACEOF
13222 rm -f conftest.$ac_objext conftest$ac_exeext
13223 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13224   (eval $ac_link) 2>conftest.er1
13225   ac_status=$?
13226   grep -v '^ *+' conftest.er1 >conftest.err
13227   rm -f conftest.er1
13228   cat conftest.err >&5
13229   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13230   (exit $ac_status); } &&
13231          { ac_try='test -z "$ac_c_werror_flag"
13232                          || test ! -s conftest.err'
13233   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13234   (eval $ac_try) 2>&5
13235   ac_status=$?
13236   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13237   (exit $ac_status); }; } &&
13238          { ac_try='test -s conftest$ac_exeext'
13239   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13240   (eval $ac_try) 2>&5
13241   ac_status=$?
13242   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13243   (exit $ac_status); }; }; then
13244   ac_cv_lib_m_copysignf=yes
13245 else
13246   echo "$as_me: failed program was:" >&5
13247 sed 's/^/| /' conftest.$ac_ext >&5
13248
13249 ac_cv_lib_m_copysignf=no
13250 fi
13251 rm -f conftest.err conftest.$ac_objext \
13252       conftest$ac_exeext conftest.$ac_ext
13253 LIBS=$ac_check_lib_save_LIBS
13254 fi
13255 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysignf" >&5
13256 echo "${ECHO_T}$ac_cv_lib_m_copysignf" >&6
13257 if test $ac_cv_lib_m_copysignf = yes; then
13258
13259 cat >>confdefs.h <<\_ACEOF
13260 #define HAVE_COPYSIGNF 1
13261 _ACEOF
13262
13263 fi
13264
13265 echo "$as_me:$LINENO: checking for copysign in -lm" >&5
13266 echo $ECHO_N "checking for copysign in -lm... $ECHO_C" >&6
13267 if test "${ac_cv_lib_m_copysign+set}" = set; then
13268   echo $ECHO_N "(cached) $ECHO_C" >&6
13269 else
13270   ac_check_lib_save_LIBS=$LIBS
13271 LIBS="-lm  $LIBS"
13272 if test x$gcc_no_link = xyes; then
13273   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13274 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13275    { (exit 1); exit 1; }; }
13276 fi
13277 cat >conftest.$ac_ext <<_ACEOF
13278 /* confdefs.h.  */
13279 _ACEOF
13280 cat confdefs.h >>conftest.$ac_ext
13281 cat >>conftest.$ac_ext <<_ACEOF
13282 /* end confdefs.h.  */
13283
13284 /* Override any gcc2 internal prototype to avoid an error.  */
13285 #ifdef __cplusplus
13286 extern "C"
13287 #endif
13288 /* We use char because int might match the return type of a gcc2
13289    builtin and then its argument prototype would still apply.  */
13290 char copysign ();
13291 int
13292 main ()
13293 {
13294 copysign ();
13295   ;
13296   return 0;
13297 }
13298 _ACEOF
13299 rm -f conftest.$ac_objext conftest$ac_exeext
13300 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13301   (eval $ac_link) 2>conftest.er1
13302   ac_status=$?
13303   grep -v '^ *+' conftest.er1 >conftest.err
13304   rm -f conftest.er1
13305   cat conftest.err >&5
13306   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13307   (exit $ac_status); } &&
13308          { ac_try='test -z "$ac_c_werror_flag"
13309                          || test ! -s conftest.err'
13310   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13311   (eval $ac_try) 2>&5
13312   ac_status=$?
13313   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13314   (exit $ac_status); }; } &&
13315          { ac_try='test -s conftest$ac_exeext'
13316   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13317   (eval $ac_try) 2>&5
13318   ac_status=$?
13319   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13320   (exit $ac_status); }; }; then
13321   ac_cv_lib_m_copysign=yes
13322 else
13323   echo "$as_me: failed program was:" >&5
13324 sed 's/^/| /' conftest.$ac_ext >&5
13325
13326 ac_cv_lib_m_copysign=no
13327 fi
13328 rm -f conftest.err conftest.$ac_objext \
13329       conftest$ac_exeext conftest.$ac_ext
13330 LIBS=$ac_check_lib_save_LIBS
13331 fi
13332 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysign" >&5
13333 echo "${ECHO_T}$ac_cv_lib_m_copysign" >&6
13334 if test $ac_cv_lib_m_copysign = yes; then
13335
13336 cat >>confdefs.h <<\_ACEOF
13337 #define HAVE_COPYSIGN 1
13338 _ACEOF
13339
13340 fi
13341
13342 echo "$as_me:$LINENO: checking for copysignl in -lm" >&5
13343 echo $ECHO_N "checking for copysignl in -lm... $ECHO_C" >&6
13344 if test "${ac_cv_lib_m_copysignl+set}" = set; then
13345   echo $ECHO_N "(cached) $ECHO_C" >&6
13346 else
13347   ac_check_lib_save_LIBS=$LIBS
13348 LIBS="-lm  $LIBS"
13349 if test x$gcc_no_link = xyes; then
13350   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13351 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13352    { (exit 1); exit 1; }; }
13353 fi
13354 cat >conftest.$ac_ext <<_ACEOF
13355 /* confdefs.h.  */
13356 _ACEOF
13357 cat confdefs.h >>conftest.$ac_ext
13358 cat >>conftest.$ac_ext <<_ACEOF
13359 /* end confdefs.h.  */
13360
13361 /* Override any gcc2 internal prototype to avoid an error.  */
13362 #ifdef __cplusplus
13363 extern "C"
13364 #endif
13365 /* We use char because int might match the return type of a gcc2
13366    builtin and then its argument prototype would still apply.  */
13367 char copysignl ();
13368 int
13369 main ()
13370 {
13371 copysignl ();
13372   ;
13373   return 0;
13374 }
13375 _ACEOF
13376 rm -f conftest.$ac_objext conftest$ac_exeext
13377 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13378   (eval $ac_link) 2>conftest.er1
13379   ac_status=$?
13380   grep -v '^ *+' conftest.er1 >conftest.err
13381   rm -f conftest.er1
13382   cat conftest.err >&5
13383   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13384   (exit $ac_status); } &&
13385          { ac_try='test -z "$ac_c_werror_flag"
13386                          || test ! -s conftest.err'
13387   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13388   (eval $ac_try) 2>&5
13389   ac_status=$?
13390   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13391   (exit $ac_status); }; } &&
13392          { ac_try='test -s conftest$ac_exeext'
13393   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13394   (eval $ac_try) 2>&5
13395   ac_status=$?
13396   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13397   (exit $ac_status); }; }; then
13398   ac_cv_lib_m_copysignl=yes
13399 else
13400   echo "$as_me: failed program was:" >&5
13401 sed 's/^/| /' conftest.$ac_ext >&5
13402
13403 ac_cv_lib_m_copysignl=no
13404 fi
13405 rm -f conftest.err conftest.$ac_objext \
13406       conftest$ac_exeext conftest.$ac_ext
13407 LIBS=$ac_check_lib_save_LIBS
13408 fi
13409 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysignl" >&5
13410 echo "${ECHO_T}$ac_cv_lib_m_copysignl" >&6
13411 if test $ac_cv_lib_m_copysignl = yes; then
13412
13413 cat >>confdefs.h <<\_ACEOF
13414 #define HAVE_COPYSIGNL 1
13415 _ACEOF
13416
13417 fi
13418
13419 echo "$as_me:$LINENO: checking for cosf in -lm" >&5
13420 echo $ECHO_N "checking for cosf in -lm... $ECHO_C" >&6
13421 if test "${ac_cv_lib_m_cosf+set}" = set; then
13422   echo $ECHO_N "(cached) $ECHO_C" >&6
13423 else
13424   ac_check_lib_save_LIBS=$LIBS
13425 LIBS="-lm  $LIBS"
13426 if test x$gcc_no_link = xyes; then
13427   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13428 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13429    { (exit 1); exit 1; }; }
13430 fi
13431 cat >conftest.$ac_ext <<_ACEOF
13432 /* confdefs.h.  */
13433 _ACEOF
13434 cat confdefs.h >>conftest.$ac_ext
13435 cat >>conftest.$ac_ext <<_ACEOF
13436 /* end confdefs.h.  */
13437
13438 /* Override any gcc2 internal prototype to avoid an error.  */
13439 #ifdef __cplusplus
13440 extern "C"
13441 #endif
13442 /* We use char because int might match the return type of a gcc2
13443    builtin and then its argument prototype would still apply.  */
13444 char cosf ();
13445 int
13446 main ()
13447 {
13448 cosf ();
13449   ;
13450   return 0;
13451 }
13452 _ACEOF
13453 rm -f conftest.$ac_objext conftest$ac_exeext
13454 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13455   (eval $ac_link) 2>conftest.er1
13456   ac_status=$?
13457   grep -v '^ *+' conftest.er1 >conftest.err
13458   rm -f conftest.er1
13459   cat conftest.err >&5
13460   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13461   (exit $ac_status); } &&
13462          { ac_try='test -z "$ac_c_werror_flag"
13463                          || test ! -s conftest.err'
13464   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13465   (eval $ac_try) 2>&5
13466   ac_status=$?
13467   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13468   (exit $ac_status); }; } &&
13469          { ac_try='test -s conftest$ac_exeext'
13470   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13471   (eval $ac_try) 2>&5
13472   ac_status=$?
13473   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13474   (exit $ac_status); }; }; then
13475   ac_cv_lib_m_cosf=yes
13476 else
13477   echo "$as_me: failed program was:" >&5
13478 sed 's/^/| /' conftest.$ac_ext >&5
13479
13480 ac_cv_lib_m_cosf=no
13481 fi
13482 rm -f conftest.err conftest.$ac_objext \
13483       conftest$ac_exeext conftest.$ac_ext
13484 LIBS=$ac_check_lib_save_LIBS
13485 fi
13486 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosf" >&5
13487 echo "${ECHO_T}$ac_cv_lib_m_cosf" >&6
13488 if test $ac_cv_lib_m_cosf = yes; then
13489
13490 cat >>confdefs.h <<\_ACEOF
13491 #define HAVE_COSF 1
13492 _ACEOF
13493
13494 fi
13495
13496 echo "$as_me:$LINENO: checking for cos in -lm" >&5
13497 echo $ECHO_N "checking for cos in -lm... $ECHO_C" >&6
13498 if test "${ac_cv_lib_m_cos+set}" = set; then
13499   echo $ECHO_N "(cached) $ECHO_C" >&6
13500 else
13501   ac_check_lib_save_LIBS=$LIBS
13502 LIBS="-lm  $LIBS"
13503 if test x$gcc_no_link = xyes; then
13504   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13505 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13506    { (exit 1); exit 1; }; }
13507 fi
13508 cat >conftest.$ac_ext <<_ACEOF
13509 /* confdefs.h.  */
13510 _ACEOF
13511 cat confdefs.h >>conftest.$ac_ext
13512 cat >>conftest.$ac_ext <<_ACEOF
13513 /* end confdefs.h.  */
13514
13515 /* Override any gcc2 internal prototype to avoid an error.  */
13516 #ifdef __cplusplus
13517 extern "C"
13518 #endif
13519 /* We use char because int might match the return type of a gcc2
13520    builtin and then its argument prototype would still apply.  */
13521 char cos ();
13522 int
13523 main ()
13524 {
13525 cos ();
13526   ;
13527   return 0;
13528 }
13529 _ACEOF
13530 rm -f conftest.$ac_objext conftest$ac_exeext
13531 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13532   (eval $ac_link) 2>conftest.er1
13533   ac_status=$?
13534   grep -v '^ *+' conftest.er1 >conftest.err
13535   rm -f conftest.er1
13536   cat conftest.err >&5
13537   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13538   (exit $ac_status); } &&
13539          { ac_try='test -z "$ac_c_werror_flag"
13540                          || test ! -s conftest.err'
13541   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13542   (eval $ac_try) 2>&5
13543   ac_status=$?
13544   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13545   (exit $ac_status); }; } &&
13546          { ac_try='test -s conftest$ac_exeext'
13547   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13548   (eval $ac_try) 2>&5
13549   ac_status=$?
13550   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13551   (exit $ac_status); }; }; then
13552   ac_cv_lib_m_cos=yes
13553 else
13554   echo "$as_me: failed program was:" >&5
13555 sed 's/^/| /' conftest.$ac_ext >&5
13556
13557 ac_cv_lib_m_cos=no
13558 fi
13559 rm -f conftest.err conftest.$ac_objext \
13560       conftest$ac_exeext conftest.$ac_ext
13561 LIBS=$ac_check_lib_save_LIBS
13562 fi
13563 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cos" >&5
13564 echo "${ECHO_T}$ac_cv_lib_m_cos" >&6
13565 if test $ac_cv_lib_m_cos = yes; then
13566
13567 cat >>confdefs.h <<\_ACEOF
13568 #define HAVE_COS 1
13569 _ACEOF
13570
13571 fi
13572
13573 echo "$as_me:$LINENO: checking for cosl in -lm" >&5
13574 echo $ECHO_N "checking for cosl in -lm... $ECHO_C" >&6
13575 if test "${ac_cv_lib_m_cosl+set}" = set; then
13576   echo $ECHO_N "(cached) $ECHO_C" >&6
13577 else
13578   ac_check_lib_save_LIBS=$LIBS
13579 LIBS="-lm  $LIBS"
13580 if test x$gcc_no_link = xyes; then
13581   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13582 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13583    { (exit 1); exit 1; }; }
13584 fi
13585 cat >conftest.$ac_ext <<_ACEOF
13586 /* confdefs.h.  */
13587 _ACEOF
13588 cat confdefs.h >>conftest.$ac_ext
13589 cat >>conftest.$ac_ext <<_ACEOF
13590 /* end confdefs.h.  */
13591
13592 /* Override any gcc2 internal prototype to avoid an error.  */
13593 #ifdef __cplusplus
13594 extern "C"
13595 #endif
13596 /* We use char because int might match the return type of a gcc2
13597    builtin and then its argument prototype would still apply.  */
13598 char cosl ();
13599 int
13600 main ()
13601 {
13602 cosl ();
13603   ;
13604   return 0;
13605 }
13606 _ACEOF
13607 rm -f conftest.$ac_objext conftest$ac_exeext
13608 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13609   (eval $ac_link) 2>conftest.er1
13610   ac_status=$?
13611   grep -v '^ *+' conftest.er1 >conftest.err
13612   rm -f conftest.er1
13613   cat conftest.err >&5
13614   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13615   (exit $ac_status); } &&
13616          { ac_try='test -z "$ac_c_werror_flag"
13617                          || test ! -s conftest.err'
13618   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13619   (eval $ac_try) 2>&5
13620   ac_status=$?
13621   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13622   (exit $ac_status); }; } &&
13623          { ac_try='test -s conftest$ac_exeext'
13624   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13625   (eval $ac_try) 2>&5
13626   ac_status=$?
13627   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13628   (exit $ac_status); }; }; then
13629   ac_cv_lib_m_cosl=yes
13630 else
13631   echo "$as_me: failed program was:" >&5
13632 sed 's/^/| /' conftest.$ac_ext >&5
13633
13634 ac_cv_lib_m_cosl=no
13635 fi
13636 rm -f conftest.err conftest.$ac_objext \
13637       conftest$ac_exeext conftest.$ac_ext
13638 LIBS=$ac_check_lib_save_LIBS
13639 fi
13640 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosl" >&5
13641 echo "${ECHO_T}$ac_cv_lib_m_cosl" >&6
13642 if test $ac_cv_lib_m_cosl = yes; then
13643
13644 cat >>confdefs.h <<\_ACEOF
13645 #define HAVE_COSL 1
13646 _ACEOF
13647
13648 fi
13649
13650 echo "$as_me:$LINENO: checking for ccosf in -lm" >&5
13651 echo $ECHO_N "checking for ccosf in -lm... $ECHO_C" >&6
13652 if test "${ac_cv_lib_m_ccosf+set}" = set; then
13653   echo $ECHO_N "(cached) $ECHO_C" >&6
13654 else
13655   ac_check_lib_save_LIBS=$LIBS
13656 LIBS="-lm  $LIBS"
13657 if test x$gcc_no_link = xyes; then
13658   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13659 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13660    { (exit 1); exit 1; }; }
13661 fi
13662 cat >conftest.$ac_ext <<_ACEOF
13663 /* confdefs.h.  */
13664 _ACEOF
13665 cat confdefs.h >>conftest.$ac_ext
13666 cat >>conftest.$ac_ext <<_ACEOF
13667 /* end confdefs.h.  */
13668
13669 /* Override any gcc2 internal prototype to avoid an error.  */
13670 #ifdef __cplusplus
13671 extern "C"
13672 #endif
13673 /* We use char because int might match the return type of a gcc2
13674    builtin and then its argument prototype would still apply.  */
13675 char ccosf ();
13676 int
13677 main ()
13678 {
13679 ccosf ();
13680   ;
13681   return 0;
13682 }
13683 _ACEOF
13684 rm -f conftest.$ac_objext conftest$ac_exeext
13685 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13686   (eval $ac_link) 2>conftest.er1
13687   ac_status=$?
13688   grep -v '^ *+' conftest.er1 >conftest.err
13689   rm -f conftest.er1
13690   cat conftest.err >&5
13691   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13692   (exit $ac_status); } &&
13693          { ac_try='test -z "$ac_c_werror_flag"
13694                          || test ! -s conftest.err'
13695   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13696   (eval $ac_try) 2>&5
13697   ac_status=$?
13698   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13699   (exit $ac_status); }; } &&
13700          { ac_try='test -s conftest$ac_exeext'
13701   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13702   (eval $ac_try) 2>&5
13703   ac_status=$?
13704   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13705   (exit $ac_status); }; }; then
13706   ac_cv_lib_m_ccosf=yes
13707 else
13708   echo "$as_me: failed program was:" >&5
13709 sed 's/^/| /' conftest.$ac_ext >&5
13710
13711 ac_cv_lib_m_ccosf=no
13712 fi
13713 rm -f conftest.err conftest.$ac_objext \
13714       conftest$ac_exeext conftest.$ac_ext
13715 LIBS=$ac_check_lib_save_LIBS
13716 fi
13717 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosf" >&5
13718 echo "${ECHO_T}$ac_cv_lib_m_ccosf" >&6
13719 if test $ac_cv_lib_m_ccosf = yes; then
13720
13721 cat >>confdefs.h <<\_ACEOF
13722 #define HAVE_CCOSF 1
13723 _ACEOF
13724
13725 fi
13726
13727 echo "$as_me:$LINENO: checking for ccos in -lm" >&5
13728 echo $ECHO_N "checking for ccos in -lm... $ECHO_C" >&6
13729 if test "${ac_cv_lib_m_ccos+set}" = set; then
13730   echo $ECHO_N "(cached) $ECHO_C" >&6
13731 else
13732   ac_check_lib_save_LIBS=$LIBS
13733 LIBS="-lm  $LIBS"
13734 if test x$gcc_no_link = xyes; then
13735   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13736 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13737    { (exit 1); exit 1; }; }
13738 fi
13739 cat >conftest.$ac_ext <<_ACEOF
13740 /* confdefs.h.  */
13741 _ACEOF
13742 cat confdefs.h >>conftest.$ac_ext
13743 cat >>conftest.$ac_ext <<_ACEOF
13744 /* end confdefs.h.  */
13745
13746 /* Override any gcc2 internal prototype to avoid an error.  */
13747 #ifdef __cplusplus
13748 extern "C"
13749 #endif
13750 /* We use char because int might match the return type of a gcc2
13751    builtin and then its argument prototype would still apply.  */
13752 char ccos ();
13753 int
13754 main ()
13755 {
13756 ccos ();
13757   ;
13758   return 0;
13759 }
13760 _ACEOF
13761 rm -f conftest.$ac_objext conftest$ac_exeext
13762 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13763   (eval $ac_link) 2>conftest.er1
13764   ac_status=$?
13765   grep -v '^ *+' conftest.er1 >conftest.err
13766   rm -f conftest.er1
13767   cat conftest.err >&5
13768   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13769   (exit $ac_status); } &&
13770          { ac_try='test -z "$ac_c_werror_flag"
13771                          || test ! -s conftest.err'
13772   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13773   (eval $ac_try) 2>&5
13774   ac_status=$?
13775   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13776   (exit $ac_status); }; } &&
13777          { ac_try='test -s conftest$ac_exeext'
13778   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13779   (eval $ac_try) 2>&5
13780   ac_status=$?
13781   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13782   (exit $ac_status); }; }; then
13783   ac_cv_lib_m_ccos=yes
13784 else
13785   echo "$as_me: failed program was:" >&5
13786 sed 's/^/| /' conftest.$ac_ext >&5
13787
13788 ac_cv_lib_m_ccos=no
13789 fi
13790 rm -f conftest.err conftest.$ac_objext \
13791       conftest$ac_exeext conftest.$ac_ext
13792 LIBS=$ac_check_lib_save_LIBS
13793 fi
13794 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccos" >&5
13795 echo "${ECHO_T}$ac_cv_lib_m_ccos" >&6
13796 if test $ac_cv_lib_m_ccos = yes; then
13797
13798 cat >>confdefs.h <<\_ACEOF
13799 #define HAVE_CCOS 1
13800 _ACEOF
13801
13802 fi
13803
13804 echo "$as_me:$LINENO: checking for ccosl in -lm" >&5
13805 echo $ECHO_N "checking for ccosl in -lm... $ECHO_C" >&6
13806 if test "${ac_cv_lib_m_ccosl+set}" = set; then
13807   echo $ECHO_N "(cached) $ECHO_C" >&6
13808 else
13809   ac_check_lib_save_LIBS=$LIBS
13810 LIBS="-lm  $LIBS"
13811 if test x$gcc_no_link = xyes; then
13812   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13813 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13814    { (exit 1); exit 1; }; }
13815 fi
13816 cat >conftest.$ac_ext <<_ACEOF
13817 /* confdefs.h.  */
13818 _ACEOF
13819 cat confdefs.h >>conftest.$ac_ext
13820 cat >>conftest.$ac_ext <<_ACEOF
13821 /* end confdefs.h.  */
13822
13823 /* Override any gcc2 internal prototype to avoid an error.  */
13824 #ifdef __cplusplus
13825 extern "C"
13826 #endif
13827 /* We use char because int might match the return type of a gcc2
13828    builtin and then its argument prototype would still apply.  */
13829 char ccosl ();
13830 int
13831 main ()
13832 {
13833 ccosl ();
13834   ;
13835   return 0;
13836 }
13837 _ACEOF
13838 rm -f conftest.$ac_objext conftest$ac_exeext
13839 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13840   (eval $ac_link) 2>conftest.er1
13841   ac_status=$?
13842   grep -v '^ *+' conftest.er1 >conftest.err
13843   rm -f conftest.er1
13844   cat conftest.err >&5
13845   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13846   (exit $ac_status); } &&
13847          { ac_try='test -z "$ac_c_werror_flag"
13848                          || test ! -s conftest.err'
13849   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13850   (eval $ac_try) 2>&5
13851   ac_status=$?
13852   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13853   (exit $ac_status); }; } &&
13854          { ac_try='test -s conftest$ac_exeext'
13855   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13856   (eval $ac_try) 2>&5
13857   ac_status=$?
13858   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13859   (exit $ac_status); }; }; then
13860   ac_cv_lib_m_ccosl=yes
13861 else
13862   echo "$as_me: failed program was:" >&5
13863 sed 's/^/| /' conftest.$ac_ext >&5
13864
13865 ac_cv_lib_m_ccosl=no
13866 fi
13867 rm -f conftest.err conftest.$ac_objext \
13868       conftest$ac_exeext conftest.$ac_ext
13869 LIBS=$ac_check_lib_save_LIBS
13870 fi
13871 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosl" >&5
13872 echo "${ECHO_T}$ac_cv_lib_m_ccosl" >&6
13873 if test $ac_cv_lib_m_ccosl = yes; then
13874
13875 cat >>confdefs.h <<\_ACEOF
13876 #define HAVE_CCOSL 1
13877 _ACEOF
13878
13879 fi
13880
13881 echo "$as_me:$LINENO: checking for coshf in -lm" >&5
13882 echo $ECHO_N "checking for coshf in -lm... $ECHO_C" >&6
13883 if test "${ac_cv_lib_m_coshf+set}" = set; then
13884   echo $ECHO_N "(cached) $ECHO_C" >&6
13885 else
13886   ac_check_lib_save_LIBS=$LIBS
13887 LIBS="-lm  $LIBS"
13888 if test x$gcc_no_link = xyes; then
13889   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13890 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13891    { (exit 1); exit 1; }; }
13892 fi
13893 cat >conftest.$ac_ext <<_ACEOF
13894 /* confdefs.h.  */
13895 _ACEOF
13896 cat confdefs.h >>conftest.$ac_ext
13897 cat >>conftest.$ac_ext <<_ACEOF
13898 /* end confdefs.h.  */
13899
13900 /* Override any gcc2 internal prototype to avoid an error.  */
13901 #ifdef __cplusplus
13902 extern "C"
13903 #endif
13904 /* We use char because int might match the return type of a gcc2
13905    builtin and then its argument prototype would still apply.  */
13906 char coshf ();
13907 int
13908 main ()
13909 {
13910 coshf ();
13911   ;
13912   return 0;
13913 }
13914 _ACEOF
13915 rm -f conftest.$ac_objext conftest$ac_exeext
13916 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13917   (eval $ac_link) 2>conftest.er1
13918   ac_status=$?
13919   grep -v '^ *+' conftest.er1 >conftest.err
13920   rm -f conftest.er1
13921   cat conftest.err >&5
13922   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13923   (exit $ac_status); } &&
13924          { ac_try='test -z "$ac_c_werror_flag"
13925                          || test ! -s conftest.err'
13926   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13927   (eval $ac_try) 2>&5
13928   ac_status=$?
13929   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13930   (exit $ac_status); }; } &&
13931          { ac_try='test -s conftest$ac_exeext'
13932   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13933   (eval $ac_try) 2>&5
13934   ac_status=$?
13935   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13936   (exit $ac_status); }; }; then
13937   ac_cv_lib_m_coshf=yes
13938 else
13939   echo "$as_me: failed program was:" >&5
13940 sed 's/^/| /' conftest.$ac_ext >&5
13941
13942 ac_cv_lib_m_coshf=no
13943 fi
13944 rm -f conftest.err conftest.$ac_objext \
13945       conftest$ac_exeext conftest.$ac_ext
13946 LIBS=$ac_check_lib_save_LIBS
13947 fi
13948 echo "$as_me:$LINENO: result: $ac_cv_lib_m_coshf" >&5
13949 echo "${ECHO_T}$ac_cv_lib_m_coshf" >&6
13950 if test $ac_cv_lib_m_coshf = yes; then
13951
13952 cat >>confdefs.h <<\_ACEOF
13953 #define HAVE_COSHF 1
13954 _ACEOF
13955
13956 fi
13957
13958 echo "$as_me:$LINENO: checking for cosh in -lm" >&5
13959 echo $ECHO_N "checking for cosh in -lm... $ECHO_C" >&6
13960 if test "${ac_cv_lib_m_cosh+set}" = set; then
13961   echo $ECHO_N "(cached) $ECHO_C" >&6
13962 else
13963   ac_check_lib_save_LIBS=$LIBS
13964 LIBS="-lm  $LIBS"
13965 if test x$gcc_no_link = xyes; then
13966   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13967 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13968    { (exit 1); exit 1; }; }
13969 fi
13970 cat >conftest.$ac_ext <<_ACEOF
13971 /* confdefs.h.  */
13972 _ACEOF
13973 cat confdefs.h >>conftest.$ac_ext
13974 cat >>conftest.$ac_ext <<_ACEOF
13975 /* end confdefs.h.  */
13976
13977 /* Override any gcc2 internal prototype to avoid an error.  */
13978 #ifdef __cplusplus
13979 extern "C"
13980 #endif
13981 /* We use char because int might match the return type of a gcc2
13982    builtin and then its argument prototype would still apply.  */
13983 char cosh ();
13984 int
13985 main ()
13986 {
13987 cosh ();
13988   ;
13989   return 0;
13990 }
13991 _ACEOF
13992 rm -f conftest.$ac_objext conftest$ac_exeext
13993 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13994   (eval $ac_link) 2>conftest.er1
13995   ac_status=$?
13996   grep -v '^ *+' conftest.er1 >conftest.err
13997   rm -f conftest.er1
13998   cat conftest.err >&5
13999   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14000   (exit $ac_status); } &&
14001          { ac_try='test -z "$ac_c_werror_flag"
14002                          || test ! -s conftest.err'
14003   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14004   (eval $ac_try) 2>&5
14005   ac_status=$?
14006   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14007   (exit $ac_status); }; } &&
14008          { ac_try='test -s conftest$ac_exeext'
14009   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14010   (eval $ac_try) 2>&5
14011   ac_status=$?
14012   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14013   (exit $ac_status); }; }; then
14014   ac_cv_lib_m_cosh=yes
14015 else
14016   echo "$as_me: failed program was:" >&5
14017 sed 's/^/| /' conftest.$ac_ext >&5
14018
14019 ac_cv_lib_m_cosh=no
14020 fi
14021 rm -f conftest.err conftest.$ac_objext \
14022       conftest$ac_exeext conftest.$ac_ext
14023 LIBS=$ac_check_lib_save_LIBS
14024 fi
14025 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosh" >&5
14026 echo "${ECHO_T}$ac_cv_lib_m_cosh" >&6
14027 if test $ac_cv_lib_m_cosh = yes; then
14028
14029 cat >>confdefs.h <<\_ACEOF
14030 #define HAVE_COSH 1
14031 _ACEOF
14032
14033 fi
14034
14035 echo "$as_me:$LINENO: checking for coshl in -lm" >&5
14036 echo $ECHO_N "checking for coshl in -lm... $ECHO_C" >&6
14037 if test "${ac_cv_lib_m_coshl+set}" = set; then
14038   echo $ECHO_N "(cached) $ECHO_C" >&6
14039 else
14040   ac_check_lib_save_LIBS=$LIBS
14041 LIBS="-lm  $LIBS"
14042 if test x$gcc_no_link = xyes; then
14043   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14044 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14045    { (exit 1); exit 1; }; }
14046 fi
14047 cat >conftest.$ac_ext <<_ACEOF
14048 /* confdefs.h.  */
14049 _ACEOF
14050 cat confdefs.h >>conftest.$ac_ext
14051 cat >>conftest.$ac_ext <<_ACEOF
14052 /* end confdefs.h.  */
14053
14054 /* Override any gcc2 internal prototype to avoid an error.  */
14055 #ifdef __cplusplus
14056 extern "C"
14057 #endif
14058 /* We use char because int might match the return type of a gcc2
14059    builtin and then its argument prototype would still apply.  */
14060 char coshl ();
14061 int
14062 main ()
14063 {
14064 coshl ();
14065   ;
14066   return 0;
14067 }
14068 _ACEOF
14069 rm -f conftest.$ac_objext conftest$ac_exeext
14070 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14071   (eval $ac_link) 2>conftest.er1
14072   ac_status=$?
14073   grep -v '^ *+' conftest.er1 >conftest.err
14074   rm -f conftest.er1
14075   cat conftest.err >&5
14076   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14077   (exit $ac_status); } &&
14078          { ac_try='test -z "$ac_c_werror_flag"
14079                          || test ! -s conftest.err'
14080   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14081   (eval $ac_try) 2>&5
14082   ac_status=$?
14083   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14084   (exit $ac_status); }; } &&
14085          { ac_try='test -s conftest$ac_exeext'
14086   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14087   (eval $ac_try) 2>&5
14088   ac_status=$?
14089   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14090   (exit $ac_status); }; }; then
14091   ac_cv_lib_m_coshl=yes
14092 else
14093   echo "$as_me: failed program was:" >&5
14094 sed 's/^/| /' conftest.$ac_ext >&5
14095
14096 ac_cv_lib_m_coshl=no
14097 fi
14098 rm -f conftest.err conftest.$ac_objext \
14099       conftest$ac_exeext conftest.$ac_ext
14100 LIBS=$ac_check_lib_save_LIBS
14101 fi
14102 echo "$as_me:$LINENO: result: $ac_cv_lib_m_coshl" >&5
14103 echo "${ECHO_T}$ac_cv_lib_m_coshl" >&6
14104 if test $ac_cv_lib_m_coshl = yes; then
14105
14106 cat >>confdefs.h <<\_ACEOF
14107 #define HAVE_COSHL 1
14108 _ACEOF
14109
14110 fi
14111
14112 echo "$as_me:$LINENO: checking for ccoshf in -lm" >&5
14113 echo $ECHO_N "checking for ccoshf in -lm... $ECHO_C" >&6
14114 if test "${ac_cv_lib_m_ccoshf+set}" = set; then
14115   echo $ECHO_N "(cached) $ECHO_C" >&6
14116 else
14117   ac_check_lib_save_LIBS=$LIBS
14118 LIBS="-lm  $LIBS"
14119 if test x$gcc_no_link = xyes; then
14120   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14121 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14122    { (exit 1); exit 1; }; }
14123 fi
14124 cat >conftest.$ac_ext <<_ACEOF
14125 /* confdefs.h.  */
14126 _ACEOF
14127 cat confdefs.h >>conftest.$ac_ext
14128 cat >>conftest.$ac_ext <<_ACEOF
14129 /* end confdefs.h.  */
14130
14131 /* Override any gcc2 internal prototype to avoid an error.  */
14132 #ifdef __cplusplus
14133 extern "C"
14134 #endif
14135 /* We use char because int might match the return type of a gcc2
14136    builtin and then its argument prototype would still apply.  */
14137 char ccoshf ();
14138 int
14139 main ()
14140 {
14141 ccoshf ();
14142   ;
14143   return 0;
14144 }
14145 _ACEOF
14146 rm -f conftest.$ac_objext conftest$ac_exeext
14147 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14148   (eval $ac_link) 2>conftest.er1
14149   ac_status=$?
14150   grep -v '^ *+' conftest.er1 >conftest.err
14151   rm -f conftest.er1
14152   cat conftest.err >&5
14153   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14154   (exit $ac_status); } &&
14155          { ac_try='test -z "$ac_c_werror_flag"
14156                          || test ! -s conftest.err'
14157   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14158   (eval $ac_try) 2>&5
14159   ac_status=$?
14160   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14161   (exit $ac_status); }; } &&
14162          { ac_try='test -s conftest$ac_exeext'
14163   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14164   (eval $ac_try) 2>&5
14165   ac_status=$?
14166   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14167   (exit $ac_status); }; }; then
14168   ac_cv_lib_m_ccoshf=yes
14169 else
14170   echo "$as_me: failed program was:" >&5
14171 sed 's/^/| /' conftest.$ac_ext >&5
14172
14173 ac_cv_lib_m_ccoshf=no
14174 fi
14175 rm -f conftest.err conftest.$ac_objext \
14176       conftest$ac_exeext conftest.$ac_ext
14177 LIBS=$ac_check_lib_save_LIBS
14178 fi
14179 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccoshf" >&5
14180 echo "${ECHO_T}$ac_cv_lib_m_ccoshf" >&6
14181 if test $ac_cv_lib_m_ccoshf = yes; then
14182
14183 cat >>confdefs.h <<\_ACEOF
14184 #define HAVE_CCOSHF 1
14185 _ACEOF
14186
14187 fi
14188
14189 echo "$as_me:$LINENO: checking for ccosh in -lm" >&5
14190 echo $ECHO_N "checking for ccosh in -lm... $ECHO_C" >&6
14191 if test "${ac_cv_lib_m_ccosh+set}" = set; then
14192   echo $ECHO_N "(cached) $ECHO_C" >&6
14193 else
14194   ac_check_lib_save_LIBS=$LIBS
14195 LIBS="-lm  $LIBS"
14196 if test x$gcc_no_link = xyes; then
14197   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14198 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14199    { (exit 1); exit 1; }; }
14200 fi
14201 cat >conftest.$ac_ext <<_ACEOF
14202 /* confdefs.h.  */
14203 _ACEOF
14204 cat confdefs.h >>conftest.$ac_ext
14205 cat >>conftest.$ac_ext <<_ACEOF
14206 /* end confdefs.h.  */
14207
14208 /* Override any gcc2 internal prototype to avoid an error.  */
14209 #ifdef __cplusplus
14210 extern "C"
14211 #endif
14212 /* We use char because int might match the return type of a gcc2
14213    builtin and then its argument prototype would still apply.  */
14214 char ccosh ();
14215 int
14216 main ()
14217 {
14218 ccosh ();
14219   ;
14220   return 0;
14221 }
14222 _ACEOF
14223 rm -f conftest.$ac_objext conftest$ac_exeext
14224 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14225   (eval $ac_link) 2>conftest.er1
14226   ac_status=$?
14227   grep -v '^ *+' conftest.er1 >conftest.err
14228   rm -f conftest.er1
14229   cat conftest.err >&5
14230   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14231   (exit $ac_status); } &&
14232          { ac_try='test -z "$ac_c_werror_flag"
14233                          || test ! -s conftest.err'
14234   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14235   (eval $ac_try) 2>&5
14236   ac_status=$?
14237   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14238   (exit $ac_status); }; } &&
14239          { ac_try='test -s conftest$ac_exeext'
14240   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14241   (eval $ac_try) 2>&5
14242   ac_status=$?
14243   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14244   (exit $ac_status); }; }; then
14245   ac_cv_lib_m_ccosh=yes
14246 else
14247   echo "$as_me: failed program was:" >&5
14248 sed 's/^/| /' conftest.$ac_ext >&5
14249
14250 ac_cv_lib_m_ccosh=no
14251 fi
14252 rm -f conftest.err conftest.$ac_objext \
14253       conftest$ac_exeext conftest.$ac_ext
14254 LIBS=$ac_check_lib_save_LIBS
14255 fi
14256 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosh" >&5
14257 echo "${ECHO_T}$ac_cv_lib_m_ccosh" >&6
14258 if test $ac_cv_lib_m_ccosh = yes; then
14259
14260 cat >>confdefs.h <<\_ACEOF
14261 #define HAVE_CCOSH 1
14262 _ACEOF
14263
14264 fi
14265
14266 echo "$as_me:$LINENO: checking for ccoshl in -lm" >&5
14267 echo $ECHO_N "checking for ccoshl in -lm... $ECHO_C" >&6
14268 if test "${ac_cv_lib_m_ccoshl+set}" = set; then
14269   echo $ECHO_N "(cached) $ECHO_C" >&6
14270 else
14271   ac_check_lib_save_LIBS=$LIBS
14272 LIBS="-lm  $LIBS"
14273 if test x$gcc_no_link = xyes; then
14274   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14275 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14276    { (exit 1); exit 1; }; }
14277 fi
14278 cat >conftest.$ac_ext <<_ACEOF
14279 /* confdefs.h.  */
14280 _ACEOF
14281 cat confdefs.h >>conftest.$ac_ext
14282 cat >>conftest.$ac_ext <<_ACEOF
14283 /* end confdefs.h.  */
14284
14285 /* Override any gcc2 internal prototype to avoid an error.  */
14286 #ifdef __cplusplus
14287 extern "C"
14288 #endif
14289 /* We use char because int might match the return type of a gcc2
14290    builtin and then its argument prototype would still apply.  */
14291 char ccoshl ();
14292 int
14293 main ()
14294 {
14295 ccoshl ();
14296   ;
14297   return 0;
14298 }
14299 _ACEOF
14300 rm -f conftest.$ac_objext conftest$ac_exeext
14301 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14302   (eval $ac_link) 2>conftest.er1
14303   ac_status=$?
14304   grep -v '^ *+' conftest.er1 >conftest.err
14305   rm -f conftest.er1
14306   cat conftest.err >&5
14307   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14308   (exit $ac_status); } &&
14309          { ac_try='test -z "$ac_c_werror_flag"
14310                          || test ! -s conftest.err'
14311   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14312   (eval $ac_try) 2>&5
14313   ac_status=$?
14314   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14315   (exit $ac_status); }; } &&
14316          { ac_try='test -s conftest$ac_exeext'
14317   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14318   (eval $ac_try) 2>&5
14319   ac_status=$?
14320   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14321   (exit $ac_status); }; }; then
14322   ac_cv_lib_m_ccoshl=yes
14323 else
14324   echo "$as_me: failed program was:" >&5
14325 sed 's/^/| /' conftest.$ac_ext >&5
14326
14327 ac_cv_lib_m_ccoshl=no
14328 fi
14329 rm -f conftest.err conftest.$ac_objext \
14330       conftest$ac_exeext conftest.$ac_ext
14331 LIBS=$ac_check_lib_save_LIBS
14332 fi
14333 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccoshl" >&5
14334 echo "${ECHO_T}$ac_cv_lib_m_ccoshl" >&6
14335 if test $ac_cv_lib_m_ccoshl = yes; then
14336
14337 cat >>confdefs.h <<\_ACEOF
14338 #define HAVE_CCOSHL 1
14339 _ACEOF
14340
14341 fi
14342
14343 echo "$as_me:$LINENO: checking for expf in -lm" >&5
14344 echo $ECHO_N "checking for expf in -lm... $ECHO_C" >&6
14345 if test "${ac_cv_lib_m_expf+set}" = set; then
14346   echo $ECHO_N "(cached) $ECHO_C" >&6
14347 else
14348   ac_check_lib_save_LIBS=$LIBS
14349 LIBS="-lm  $LIBS"
14350 if test x$gcc_no_link = xyes; then
14351   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14352 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14353    { (exit 1); exit 1; }; }
14354 fi
14355 cat >conftest.$ac_ext <<_ACEOF
14356 /* confdefs.h.  */
14357 _ACEOF
14358 cat confdefs.h >>conftest.$ac_ext
14359 cat >>conftest.$ac_ext <<_ACEOF
14360 /* end confdefs.h.  */
14361
14362 /* Override any gcc2 internal prototype to avoid an error.  */
14363 #ifdef __cplusplus
14364 extern "C"
14365 #endif
14366 /* We use char because int might match the return type of a gcc2
14367    builtin and then its argument prototype would still apply.  */
14368 char expf ();
14369 int
14370 main ()
14371 {
14372 expf ();
14373   ;
14374   return 0;
14375 }
14376 _ACEOF
14377 rm -f conftest.$ac_objext conftest$ac_exeext
14378 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14379   (eval $ac_link) 2>conftest.er1
14380   ac_status=$?
14381   grep -v '^ *+' conftest.er1 >conftest.err
14382   rm -f conftest.er1
14383   cat conftest.err >&5
14384   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14385   (exit $ac_status); } &&
14386          { ac_try='test -z "$ac_c_werror_flag"
14387                          || test ! -s conftest.err'
14388   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14389   (eval $ac_try) 2>&5
14390   ac_status=$?
14391   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14392   (exit $ac_status); }; } &&
14393          { ac_try='test -s conftest$ac_exeext'
14394   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14395   (eval $ac_try) 2>&5
14396   ac_status=$?
14397   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14398   (exit $ac_status); }; }; then
14399   ac_cv_lib_m_expf=yes
14400 else
14401   echo "$as_me: failed program was:" >&5
14402 sed 's/^/| /' conftest.$ac_ext >&5
14403
14404 ac_cv_lib_m_expf=no
14405 fi
14406 rm -f conftest.err conftest.$ac_objext \
14407       conftest$ac_exeext conftest.$ac_ext
14408 LIBS=$ac_check_lib_save_LIBS
14409 fi
14410 echo "$as_me:$LINENO: result: $ac_cv_lib_m_expf" >&5
14411 echo "${ECHO_T}$ac_cv_lib_m_expf" >&6
14412 if test $ac_cv_lib_m_expf = yes; then
14413
14414 cat >>confdefs.h <<\_ACEOF
14415 #define HAVE_EXPF 1
14416 _ACEOF
14417
14418 fi
14419
14420 echo "$as_me:$LINENO: checking for exp in -lm" >&5
14421 echo $ECHO_N "checking for exp in -lm... $ECHO_C" >&6
14422 if test "${ac_cv_lib_m_exp+set}" = set; then
14423   echo $ECHO_N "(cached) $ECHO_C" >&6
14424 else
14425   ac_check_lib_save_LIBS=$LIBS
14426 LIBS="-lm  $LIBS"
14427 if test x$gcc_no_link = xyes; then
14428   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14429 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14430    { (exit 1); exit 1; }; }
14431 fi
14432 cat >conftest.$ac_ext <<_ACEOF
14433 /* confdefs.h.  */
14434 _ACEOF
14435 cat confdefs.h >>conftest.$ac_ext
14436 cat >>conftest.$ac_ext <<_ACEOF
14437 /* end confdefs.h.  */
14438
14439 /* Override any gcc2 internal prototype to avoid an error.  */
14440 #ifdef __cplusplus
14441 extern "C"
14442 #endif
14443 /* We use char because int might match the return type of a gcc2
14444    builtin and then its argument prototype would still apply.  */
14445 char exp ();
14446 int
14447 main ()
14448 {
14449 exp ();
14450   ;
14451   return 0;
14452 }
14453 _ACEOF
14454 rm -f conftest.$ac_objext conftest$ac_exeext
14455 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14456   (eval $ac_link) 2>conftest.er1
14457   ac_status=$?
14458   grep -v '^ *+' conftest.er1 >conftest.err
14459   rm -f conftest.er1
14460   cat conftest.err >&5
14461   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14462   (exit $ac_status); } &&
14463          { ac_try='test -z "$ac_c_werror_flag"
14464                          || test ! -s conftest.err'
14465   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14466   (eval $ac_try) 2>&5
14467   ac_status=$?
14468   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14469   (exit $ac_status); }; } &&
14470          { ac_try='test -s conftest$ac_exeext'
14471   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14472   (eval $ac_try) 2>&5
14473   ac_status=$?
14474   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14475   (exit $ac_status); }; }; then
14476   ac_cv_lib_m_exp=yes
14477 else
14478   echo "$as_me: failed program was:" >&5
14479 sed 's/^/| /' conftest.$ac_ext >&5
14480
14481 ac_cv_lib_m_exp=no
14482 fi
14483 rm -f conftest.err conftest.$ac_objext \
14484       conftest$ac_exeext conftest.$ac_ext
14485 LIBS=$ac_check_lib_save_LIBS
14486 fi
14487 echo "$as_me:$LINENO: result: $ac_cv_lib_m_exp" >&5
14488 echo "${ECHO_T}$ac_cv_lib_m_exp" >&6
14489 if test $ac_cv_lib_m_exp = yes; then
14490
14491 cat >>confdefs.h <<\_ACEOF
14492 #define HAVE_EXP 1
14493 _ACEOF
14494
14495 fi
14496
14497 echo "$as_me:$LINENO: checking for expl in -lm" >&5
14498 echo $ECHO_N "checking for expl in -lm... $ECHO_C" >&6
14499 if test "${ac_cv_lib_m_expl+set}" = set; then
14500   echo $ECHO_N "(cached) $ECHO_C" >&6
14501 else
14502   ac_check_lib_save_LIBS=$LIBS
14503 LIBS="-lm  $LIBS"
14504 if test x$gcc_no_link = xyes; then
14505   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14506 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14507    { (exit 1); exit 1; }; }
14508 fi
14509 cat >conftest.$ac_ext <<_ACEOF
14510 /* confdefs.h.  */
14511 _ACEOF
14512 cat confdefs.h >>conftest.$ac_ext
14513 cat >>conftest.$ac_ext <<_ACEOF
14514 /* end confdefs.h.  */
14515
14516 /* Override any gcc2 internal prototype to avoid an error.  */
14517 #ifdef __cplusplus
14518 extern "C"
14519 #endif
14520 /* We use char because int might match the return type of a gcc2
14521    builtin and then its argument prototype would still apply.  */
14522 char expl ();
14523 int
14524 main ()
14525 {
14526 expl ();
14527   ;
14528   return 0;
14529 }
14530 _ACEOF
14531 rm -f conftest.$ac_objext conftest$ac_exeext
14532 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14533   (eval $ac_link) 2>conftest.er1
14534   ac_status=$?
14535   grep -v '^ *+' conftest.er1 >conftest.err
14536   rm -f conftest.er1
14537   cat conftest.err >&5
14538   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14539   (exit $ac_status); } &&
14540          { ac_try='test -z "$ac_c_werror_flag"
14541                          || test ! -s conftest.err'
14542   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14543   (eval $ac_try) 2>&5
14544   ac_status=$?
14545   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14546   (exit $ac_status); }; } &&
14547          { ac_try='test -s conftest$ac_exeext'
14548   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14549   (eval $ac_try) 2>&5
14550   ac_status=$?
14551   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14552   (exit $ac_status); }; }; then
14553   ac_cv_lib_m_expl=yes
14554 else
14555   echo "$as_me: failed program was:" >&5
14556 sed 's/^/| /' conftest.$ac_ext >&5
14557
14558 ac_cv_lib_m_expl=no
14559 fi
14560 rm -f conftest.err conftest.$ac_objext \
14561       conftest$ac_exeext conftest.$ac_ext
14562 LIBS=$ac_check_lib_save_LIBS
14563 fi
14564 echo "$as_me:$LINENO: result: $ac_cv_lib_m_expl" >&5
14565 echo "${ECHO_T}$ac_cv_lib_m_expl" >&6
14566 if test $ac_cv_lib_m_expl = yes; then
14567
14568 cat >>confdefs.h <<\_ACEOF
14569 #define HAVE_EXPL 1
14570 _ACEOF
14571
14572 fi
14573
14574 echo "$as_me:$LINENO: checking for cexpf in -lm" >&5
14575 echo $ECHO_N "checking for cexpf in -lm... $ECHO_C" >&6
14576 if test "${ac_cv_lib_m_cexpf+set}" = set; then
14577   echo $ECHO_N "(cached) $ECHO_C" >&6
14578 else
14579   ac_check_lib_save_LIBS=$LIBS
14580 LIBS="-lm  $LIBS"
14581 if test x$gcc_no_link = xyes; then
14582   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14583 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14584    { (exit 1); exit 1; }; }
14585 fi
14586 cat >conftest.$ac_ext <<_ACEOF
14587 /* confdefs.h.  */
14588 _ACEOF
14589 cat confdefs.h >>conftest.$ac_ext
14590 cat >>conftest.$ac_ext <<_ACEOF
14591 /* end confdefs.h.  */
14592
14593 /* Override any gcc2 internal prototype to avoid an error.  */
14594 #ifdef __cplusplus
14595 extern "C"
14596 #endif
14597 /* We use char because int might match the return type of a gcc2
14598    builtin and then its argument prototype would still apply.  */
14599 char cexpf ();
14600 int
14601 main ()
14602 {
14603 cexpf ();
14604   ;
14605   return 0;
14606 }
14607 _ACEOF
14608 rm -f conftest.$ac_objext conftest$ac_exeext
14609 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14610   (eval $ac_link) 2>conftest.er1
14611   ac_status=$?
14612   grep -v '^ *+' conftest.er1 >conftest.err
14613   rm -f conftest.er1
14614   cat conftest.err >&5
14615   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14616   (exit $ac_status); } &&
14617          { ac_try='test -z "$ac_c_werror_flag"
14618                          || test ! -s conftest.err'
14619   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14620   (eval $ac_try) 2>&5
14621   ac_status=$?
14622   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14623   (exit $ac_status); }; } &&
14624          { ac_try='test -s conftest$ac_exeext'
14625   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14626   (eval $ac_try) 2>&5
14627   ac_status=$?
14628   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14629   (exit $ac_status); }; }; then
14630   ac_cv_lib_m_cexpf=yes
14631 else
14632   echo "$as_me: failed program was:" >&5
14633 sed 's/^/| /' conftest.$ac_ext >&5
14634
14635 ac_cv_lib_m_cexpf=no
14636 fi
14637 rm -f conftest.err conftest.$ac_objext \
14638       conftest$ac_exeext conftest.$ac_ext
14639 LIBS=$ac_check_lib_save_LIBS
14640 fi
14641 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexpf" >&5
14642 echo "${ECHO_T}$ac_cv_lib_m_cexpf" >&6
14643 if test $ac_cv_lib_m_cexpf = yes; then
14644
14645 cat >>confdefs.h <<\_ACEOF
14646 #define HAVE_CEXPF 1
14647 _ACEOF
14648
14649 fi
14650
14651 echo "$as_me:$LINENO: checking for cexp in -lm" >&5
14652 echo $ECHO_N "checking for cexp in -lm... $ECHO_C" >&6
14653 if test "${ac_cv_lib_m_cexp+set}" = set; then
14654   echo $ECHO_N "(cached) $ECHO_C" >&6
14655 else
14656   ac_check_lib_save_LIBS=$LIBS
14657 LIBS="-lm  $LIBS"
14658 if test x$gcc_no_link = xyes; then
14659   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14660 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14661    { (exit 1); exit 1; }; }
14662 fi
14663 cat >conftest.$ac_ext <<_ACEOF
14664 /* confdefs.h.  */
14665 _ACEOF
14666 cat confdefs.h >>conftest.$ac_ext
14667 cat >>conftest.$ac_ext <<_ACEOF
14668 /* end confdefs.h.  */
14669
14670 /* Override any gcc2 internal prototype to avoid an error.  */
14671 #ifdef __cplusplus
14672 extern "C"
14673 #endif
14674 /* We use char because int might match the return type of a gcc2
14675    builtin and then its argument prototype would still apply.  */
14676 char cexp ();
14677 int
14678 main ()
14679 {
14680 cexp ();
14681   ;
14682   return 0;
14683 }
14684 _ACEOF
14685 rm -f conftest.$ac_objext conftest$ac_exeext
14686 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14687   (eval $ac_link) 2>conftest.er1
14688   ac_status=$?
14689   grep -v '^ *+' conftest.er1 >conftest.err
14690   rm -f conftest.er1
14691   cat conftest.err >&5
14692   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14693   (exit $ac_status); } &&
14694          { ac_try='test -z "$ac_c_werror_flag"
14695                          || test ! -s conftest.err'
14696   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14697   (eval $ac_try) 2>&5
14698   ac_status=$?
14699   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14700   (exit $ac_status); }; } &&
14701          { ac_try='test -s conftest$ac_exeext'
14702   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14703   (eval $ac_try) 2>&5
14704   ac_status=$?
14705   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14706   (exit $ac_status); }; }; then
14707   ac_cv_lib_m_cexp=yes
14708 else
14709   echo "$as_me: failed program was:" >&5
14710 sed 's/^/| /' conftest.$ac_ext >&5
14711
14712 ac_cv_lib_m_cexp=no
14713 fi
14714 rm -f conftest.err conftest.$ac_objext \
14715       conftest$ac_exeext conftest.$ac_ext
14716 LIBS=$ac_check_lib_save_LIBS
14717 fi
14718 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexp" >&5
14719 echo "${ECHO_T}$ac_cv_lib_m_cexp" >&6
14720 if test $ac_cv_lib_m_cexp = yes; then
14721
14722 cat >>confdefs.h <<\_ACEOF
14723 #define HAVE_CEXP 1
14724 _ACEOF
14725
14726 fi
14727
14728 echo "$as_me:$LINENO: checking for cexpl in -lm" >&5
14729 echo $ECHO_N "checking for cexpl in -lm... $ECHO_C" >&6
14730 if test "${ac_cv_lib_m_cexpl+set}" = set; then
14731   echo $ECHO_N "(cached) $ECHO_C" >&6
14732 else
14733   ac_check_lib_save_LIBS=$LIBS
14734 LIBS="-lm  $LIBS"
14735 if test x$gcc_no_link = xyes; then
14736   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14737 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14738    { (exit 1); exit 1; }; }
14739 fi
14740 cat >conftest.$ac_ext <<_ACEOF
14741 /* confdefs.h.  */
14742 _ACEOF
14743 cat confdefs.h >>conftest.$ac_ext
14744 cat >>conftest.$ac_ext <<_ACEOF
14745 /* end confdefs.h.  */
14746
14747 /* Override any gcc2 internal prototype to avoid an error.  */
14748 #ifdef __cplusplus
14749 extern "C"
14750 #endif
14751 /* We use char because int might match the return type of a gcc2
14752    builtin and then its argument prototype would still apply.  */
14753 char cexpl ();
14754 int
14755 main ()
14756 {
14757 cexpl ();
14758   ;
14759   return 0;
14760 }
14761 _ACEOF
14762 rm -f conftest.$ac_objext conftest$ac_exeext
14763 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14764   (eval $ac_link) 2>conftest.er1
14765   ac_status=$?
14766   grep -v '^ *+' conftest.er1 >conftest.err
14767   rm -f conftest.er1
14768   cat conftest.err >&5
14769   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14770   (exit $ac_status); } &&
14771          { ac_try='test -z "$ac_c_werror_flag"
14772                          || test ! -s conftest.err'
14773   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14774   (eval $ac_try) 2>&5
14775   ac_status=$?
14776   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14777   (exit $ac_status); }; } &&
14778          { ac_try='test -s conftest$ac_exeext'
14779   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14780   (eval $ac_try) 2>&5
14781   ac_status=$?
14782   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14783   (exit $ac_status); }; }; then
14784   ac_cv_lib_m_cexpl=yes
14785 else
14786   echo "$as_me: failed program was:" >&5
14787 sed 's/^/| /' conftest.$ac_ext >&5
14788
14789 ac_cv_lib_m_cexpl=no
14790 fi
14791 rm -f conftest.err conftest.$ac_objext \
14792       conftest$ac_exeext conftest.$ac_ext
14793 LIBS=$ac_check_lib_save_LIBS
14794 fi
14795 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexpl" >&5
14796 echo "${ECHO_T}$ac_cv_lib_m_cexpl" >&6
14797 if test $ac_cv_lib_m_cexpl = yes; then
14798
14799 cat >>confdefs.h <<\_ACEOF
14800 #define HAVE_CEXPL 1
14801 _ACEOF
14802
14803 fi
14804
14805 echo "$as_me:$LINENO: checking for fabsf in -lm" >&5
14806 echo $ECHO_N "checking for fabsf in -lm... $ECHO_C" >&6
14807 if test "${ac_cv_lib_m_fabsf+set}" = set; then
14808   echo $ECHO_N "(cached) $ECHO_C" >&6
14809 else
14810   ac_check_lib_save_LIBS=$LIBS
14811 LIBS="-lm  $LIBS"
14812 if test x$gcc_no_link = xyes; then
14813   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14814 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14815    { (exit 1); exit 1; }; }
14816 fi
14817 cat >conftest.$ac_ext <<_ACEOF
14818 /* confdefs.h.  */
14819 _ACEOF
14820 cat confdefs.h >>conftest.$ac_ext
14821 cat >>conftest.$ac_ext <<_ACEOF
14822 /* end confdefs.h.  */
14823
14824 /* Override any gcc2 internal prototype to avoid an error.  */
14825 #ifdef __cplusplus
14826 extern "C"
14827 #endif
14828 /* We use char because int might match the return type of a gcc2
14829    builtin and then its argument prototype would still apply.  */
14830 char fabsf ();
14831 int
14832 main ()
14833 {
14834 fabsf ();
14835   ;
14836   return 0;
14837 }
14838 _ACEOF
14839 rm -f conftest.$ac_objext conftest$ac_exeext
14840 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14841   (eval $ac_link) 2>conftest.er1
14842   ac_status=$?
14843   grep -v '^ *+' conftest.er1 >conftest.err
14844   rm -f conftest.er1
14845   cat conftest.err >&5
14846   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14847   (exit $ac_status); } &&
14848          { ac_try='test -z "$ac_c_werror_flag"
14849                          || test ! -s conftest.err'
14850   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14851   (eval $ac_try) 2>&5
14852   ac_status=$?
14853   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14854   (exit $ac_status); }; } &&
14855          { ac_try='test -s conftest$ac_exeext'
14856   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14857   (eval $ac_try) 2>&5
14858   ac_status=$?
14859   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14860   (exit $ac_status); }; }; then
14861   ac_cv_lib_m_fabsf=yes
14862 else
14863   echo "$as_me: failed program was:" >&5
14864 sed 's/^/| /' conftest.$ac_ext >&5
14865
14866 ac_cv_lib_m_fabsf=no
14867 fi
14868 rm -f conftest.err conftest.$ac_objext \
14869       conftest$ac_exeext conftest.$ac_ext
14870 LIBS=$ac_check_lib_save_LIBS
14871 fi
14872 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabsf" >&5
14873 echo "${ECHO_T}$ac_cv_lib_m_fabsf" >&6
14874 if test $ac_cv_lib_m_fabsf = yes; then
14875
14876 cat >>confdefs.h <<\_ACEOF
14877 #define HAVE_FABSF 1
14878 _ACEOF
14879
14880 fi
14881
14882 echo "$as_me:$LINENO: checking for fabs in -lm" >&5
14883 echo $ECHO_N "checking for fabs in -lm... $ECHO_C" >&6
14884 if test "${ac_cv_lib_m_fabs+set}" = set; then
14885   echo $ECHO_N "(cached) $ECHO_C" >&6
14886 else
14887   ac_check_lib_save_LIBS=$LIBS
14888 LIBS="-lm  $LIBS"
14889 if test x$gcc_no_link = xyes; then
14890   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14891 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14892    { (exit 1); exit 1; }; }
14893 fi
14894 cat >conftest.$ac_ext <<_ACEOF
14895 /* confdefs.h.  */
14896 _ACEOF
14897 cat confdefs.h >>conftest.$ac_ext
14898 cat >>conftest.$ac_ext <<_ACEOF
14899 /* end confdefs.h.  */
14900
14901 /* Override any gcc2 internal prototype to avoid an error.  */
14902 #ifdef __cplusplus
14903 extern "C"
14904 #endif
14905 /* We use char because int might match the return type of a gcc2
14906    builtin and then its argument prototype would still apply.  */
14907 char fabs ();
14908 int
14909 main ()
14910 {
14911 fabs ();
14912   ;
14913   return 0;
14914 }
14915 _ACEOF
14916 rm -f conftest.$ac_objext conftest$ac_exeext
14917 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14918   (eval $ac_link) 2>conftest.er1
14919   ac_status=$?
14920   grep -v '^ *+' conftest.er1 >conftest.err
14921   rm -f conftest.er1
14922   cat conftest.err >&5
14923   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14924   (exit $ac_status); } &&
14925          { ac_try='test -z "$ac_c_werror_flag"
14926                          || test ! -s conftest.err'
14927   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14928   (eval $ac_try) 2>&5
14929   ac_status=$?
14930   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14931   (exit $ac_status); }; } &&
14932          { ac_try='test -s conftest$ac_exeext'
14933   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14934   (eval $ac_try) 2>&5
14935   ac_status=$?
14936   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14937   (exit $ac_status); }; }; then
14938   ac_cv_lib_m_fabs=yes
14939 else
14940   echo "$as_me: failed program was:" >&5
14941 sed 's/^/| /' conftest.$ac_ext >&5
14942
14943 ac_cv_lib_m_fabs=no
14944 fi
14945 rm -f conftest.err conftest.$ac_objext \
14946       conftest$ac_exeext conftest.$ac_ext
14947 LIBS=$ac_check_lib_save_LIBS
14948 fi
14949 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabs" >&5
14950 echo "${ECHO_T}$ac_cv_lib_m_fabs" >&6
14951 if test $ac_cv_lib_m_fabs = yes; then
14952
14953 cat >>confdefs.h <<\_ACEOF
14954 #define HAVE_FABS 1
14955 _ACEOF
14956
14957 fi
14958
14959 echo "$as_me:$LINENO: checking for fabsl in -lm" >&5
14960 echo $ECHO_N "checking for fabsl in -lm... $ECHO_C" >&6
14961 if test "${ac_cv_lib_m_fabsl+set}" = set; then
14962   echo $ECHO_N "(cached) $ECHO_C" >&6
14963 else
14964   ac_check_lib_save_LIBS=$LIBS
14965 LIBS="-lm  $LIBS"
14966 if test x$gcc_no_link = xyes; then
14967   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14968 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14969    { (exit 1); exit 1; }; }
14970 fi
14971 cat >conftest.$ac_ext <<_ACEOF
14972 /* confdefs.h.  */
14973 _ACEOF
14974 cat confdefs.h >>conftest.$ac_ext
14975 cat >>conftest.$ac_ext <<_ACEOF
14976 /* end confdefs.h.  */
14977
14978 /* Override any gcc2 internal prototype to avoid an error.  */
14979 #ifdef __cplusplus
14980 extern "C"
14981 #endif
14982 /* We use char because int might match the return type of a gcc2
14983    builtin and then its argument prototype would still apply.  */
14984 char fabsl ();
14985 int
14986 main ()
14987 {
14988 fabsl ();
14989   ;
14990   return 0;
14991 }
14992 _ACEOF
14993 rm -f conftest.$ac_objext conftest$ac_exeext
14994 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14995   (eval $ac_link) 2>conftest.er1
14996   ac_status=$?
14997   grep -v '^ *+' conftest.er1 >conftest.err
14998   rm -f conftest.er1
14999   cat conftest.err >&5
15000   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15001   (exit $ac_status); } &&
15002          { ac_try='test -z "$ac_c_werror_flag"
15003                          || test ! -s conftest.err'
15004   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15005   (eval $ac_try) 2>&5
15006   ac_status=$?
15007   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15008   (exit $ac_status); }; } &&
15009          { ac_try='test -s conftest$ac_exeext'
15010   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15011   (eval $ac_try) 2>&5
15012   ac_status=$?
15013   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15014   (exit $ac_status); }; }; then
15015   ac_cv_lib_m_fabsl=yes
15016 else
15017   echo "$as_me: failed program was:" >&5
15018 sed 's/^/| /' conftest.$ac_ext >&5
15019
15020 ac_cv_lib_m_fabsl=no
15021 fi
15022 rm -f conftest.err conftest.$ac_objext \
15023       conftest$ac_exeext conftest.$ac_ext
15024 LIBS=$ac_check_lib_save_LIBS
15025 fi
15026 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabsl" >&5
15027 echo "${ECHO_T}$ac_cv_lib_m_fabsl" >&6
15028 if test $ac_cv_lib_m_fabsl = yes; then
15029
15030 cat >>confdefs.h <<\_ACEOF
15031 #define HAVE_FABSL 1
15032 _ACEOF
15033
15034 fi
15035
15036 echo "$as_me:$LINENO: checking for cabsf in -lm" >&5
15037 echo $ECHO_N "checking for cabsf in -lm... $ECHO_C" >&6
15038 if test "${ac_cv_lib_m_cabsf+set}" = set; then
15039   echo $ECHO_N "(cached) $ECHO_C" >&6
15040 else
15041   ac_check_lib_save_LIBS=$LIBS
15042 LIBS="-lm  $LIBS"
15043 if test x$gcc_no_link = xyes; then
15044   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15045 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15046    { (exit 1); exit 1; }; }
15047 fi
15048 cat >conftest.$ac_ext <<_ACEOF
15049 /* confdefs.h.  */
15050 _ACEOF
15051 cat confdefs.h >>conftest.$ac_ext
15052 cat >>conftest.$ac_ext <<_ACEOF
15053 /* end confdefs.h.  */
15054
15055 /* Override any gcc2 internal prototype to avoid an error.  */
15056 #ifdef __cplusplus
15057 extern "C"
15058 #endif
15059 /* We use char because int might match the return type of a gcc2
15060    builtin and then its argument prototype would still apply.  */
15061 char cabsf ();
15062 int
15063 main ()
15064 {
15065 cabsf ();
15066   ;
15067   return 0;
15068 }
15069 _ACEOF
15070 rm -f conftest.$ac_objext conftest$ac_exeext
15071 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15072   (eval $ac_link) 2>conftest.er1
15073   ac_status=$?
15074   grep -v '^ *+' conftest.er1 >conftest.err
15075   rm -f conftest.er1
15076   cat conftest.err >&5
15077   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15078   (exit $ac_status); } &&
15079          { ac_try='test -z "$ac_c_werror_flag"
15080                          || test ! -s conftest.err'
15081   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15082   (eval $ac_try) 2>&5
15083   ac_status=$?
15084   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15085   (exit $ac_status); }; } &&
15086          { ac_try='test -s conftest$ac_exeext'
15087   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15088   (eval $ac_try) 2>&5
15089   ac_status=$?
15090   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15091   (exit $ac_status); }; }; then
15092   ac_cv_lib_m_cabsf=yes
15093 else
15094   echo "$as_me: failed program was:" >&5
15095 sed 's/^/| /' conftest.$ac_ext >&5
15096
15097 ac_cv_lib_m_cabsf=no
15098 fi
15099 rm -f conftest.err conftest.$ac_objext \
15100       conftest$ac_exeext conftest.$ac_ext
15101 LIBS=$ac_check_lib_save_LIBS
15102 fi
15103 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabsf" >&5
15104 echo "${ECHO_T}$ac_cv_lib_m_cabsf" >&6
15105 if test $ac_cv_lib_m_cabsf = yes; then
15106
15107 cat >>confdefs.h <<\_ACEOF
15108 #define HAVE_CABSF 1
15109 _ACEOF
15110
15111 fi
15112
15113 echo "$as_me:$LINENO: checking for cabs in -lm" >&5
15114 echo $ECHO_N "checking for cabs in -lm... $ECHO_C" >&6
15115 if test "${ac_cv_lib_m_cabs+set}" = set; then
15116   echo $ECHO_N "(cached) $ECHO_C" >&6
15117 else
15118   ac_check_lib_save_LIBS=$LIBS
15119 LIBS="-lm  $LIBS"
15120 if test x$gcc_no_link = xyes; then
15121   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15122 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15123    { (exit 1); exit 1; }; }
15124 fi
15125 cat >conftest.$ac_ext <<_ACEOF
15126 /* confdefs.h.  */
15127 _ACEOF
15128 cat confdefs.h >>conftest.$ac_ext
15129 cat >>conftest.$ac_ext <<_ACEOF
15130 /* end confdefs.h.  */
15131
15132 /* Override any gcc2 internal prototype to avoid an error.  */
15133 #ifdef __cplusplus
15134 extern "C"
15135 #endif
15136 /* We use char because int might match the return type of a gcc2
15137    builtin and then its argument prototype would still apply.  */
15138 char cabs ();
15139 int
15140 main ()
15141 {
15142 cabs ();
15143   ;
15144   return 0;
15145 }
15146 _ACEOF
15147 rm -f conftest.$ac_objext conftest$ac_exeext
15148 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15149   (eval $ac_link) 2>conftest.er1
15150   ac_status=$?
15151   grep -v '^ *+' conftest.er1 >conftest.err
15152   rm -f conftest.er1
15153   cat conftest.err >&5
15154   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15155   (exit $ac_status); } &&
15156          { ac_try='test -z "$ac_c_werror_flag"
15157                          || test ! -s conftest.err'
15158   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15159   (eval $ac_try) 2>&5
15160   ac_status=$?
15161   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15162   (exit $ac_status); }; } &&
15163          { ac_try='test -s conftest$ac_exeext'
15164   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15165   (eval $ac_try) 2>&5
15166   ac_status=$?
15167   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15168   (exit $ac_status); }; }; then
15169   ac_cv_lib_m_cabs=yes
15170 else
15171   echo "$as_me: failed program was:" >&5
15172 sed 's/^/| /' conftest.$ac_ext >&5
15173
15174 ac_cv_lib_m_cabs=no
15175 fi
15176 rm -f conftest.err conftest.$ac_objext \
15177       conftest$ac_exeext conftest.$ac_ext
15178 LIBS=$ac_check_lib_save_LIBS
15179 fi
15180 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabs" >&5
15181 echo "${ECHO_T}$ac_cv_lib_m_cabs" >&6
15182 if test $ac_cv_lib_m_cabs = yes; then
15183
15184 cat >>confdefs.h <<\_ACEOF
15185 #define HAVE_CABS 1
15186 _ACEOF
15187
15188 fi
15189
15190 echo "$as_me:$LINENO: checking for cabsl in -lm" >&5
15191 echo $ECHO_N "checking for cabsl in -lm... $ECHO_C" >&6
15192 if test "${ac_cv_lib_m_cabsl+set}" = set; then
15193   echo $ECHO_N "(cached) $ECHO_C" >&6
15194 else
15195   ac_check_lib_save_LIBS=$LIBS
15196 LIBS="-lm  $LIBS"
15197 if test x$gcc_no_link = xyes; then
15198   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15199 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15200    { (exit 1); exit 1; }; }
15201 fi
15202 cat >conftest.$ac_ext <<_ACEOF
15203 /* confdefs.h.  */
15204 _ACEOF
15205 cat confdefs.h >>conftest.$ac_ext
15206 cat >>conftest.$ac_ext <<_ACEOF
15207 /* end confdefs.h.  */
15208
15209 /* Override any gcc2 internal prototype to avoid an error.  */
15210 #ifdef __cplusplus
15211 extern "C"
15212 #endif
15213 /* We use char because int might match the return type of a gcc2
15214    builtin and then its argument prototype would still apply.  */
15215 char cabsl ();
15216 int
15217 main ()
15218 {
15219 cabsl ();
15220   ;
15221   return 0;
15222 }
15223 _ACEOF
15224 rm -f conftest.$ac_objext conftest$ac_exeext
15225 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15226   (eval $ac_link) 2>conftest.er1
15227   ac_status=$?
15228   grep -v '^ *+' conftest.er1 >conftest.err
15229   rm -f conftest.er1
15230   cat conftest.err >&5
15231   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15232   (exit $ac_status); } &&
15233          { ac_try='test -z "$ac_c_werror_flag"
15234                          || test ! -s conftest.err'
15235   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15236   (eval $ac_try) 2>&5
15237   ac_status=$?
15238   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15239   (exit $ac_status); }; } &&
15240          { ac_try='test -s conftest$ac_exeext'
15241   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15242   (eval $ac_try) 2>&5
15243   ac_status=$?
15244   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15245   (exit $ac_status); }; }; then
15246   ac_cv_lib_m_cabsl=yes
15247 else
15248   echo "$as_me: failed program was:" >&5
15249 sed 's/^/| /' conftest.$ac_ext >&5
15250
15251 ac_cv_lib_m_cabsl=no
15252 fi
15253 rm -f conftest.err conftest.$ac_objext \
15254       conftest$ac_exeext conftest.$ac_ext
15255 LIBS=$ac_check_lib_save_LIBS
15256 fi
15257 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabsl" >&5
15258 echo "${ECHO_T}$ac_cv_lib_m_cabsl" >&6
15259 if test $ac_cv_lib_m_cabsl = yes; then
15260
15261 cat >>confdefs.h <<\_ACEOF
15262 #define HAVE_CABSL 1
15263 _ACEOF
15264
15265 fi
15266
15267 echo "$as_me:$LINENO: checking for floorf in -lm" >&5
15268 echo $ECHO_N "checking for floorf in -lm... $ECHO_C" >&6
15269 if test "${ac_cv_lib_m_floorf+set}" = set; then
15270   echo $ECHO_N "(cached) $ECHO_C" >&6
15271 else
15272   ac_check_lib_save_LIBS=$LIBS
15273 LIBS="-lm  $LIBS"
15274 if test x$gcc_no_link = xyes; then
15275   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15276 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15277    { (exit 1); exit 1; }; }
15278 fi
15279 cat >conftest.$ac_ext <<_ACEOF
15280 /* confdefs.h.  */
15281 _ACEOF
15282 cat confdefs.h >>conftest.$ac_ext
15283 cat >>conftest.$ac_ext <<_ACEOF
15284 /* end confdefs.h.  */
15285
15286 /* Override any gcc2 internal prototype to avoid an error.  */
15287 #ifdef __cplusplus
15288 extern "C"
15289 #endif
15290 /* We use char because int might match the return type of a gcc2
15291    builtin and then its argument prototype would still apply.  */
15292 char floorf ();
15293 int
15294 main ()
15295 {
15296 floorf ();
15297   ;
15298   return 0;
15299 }
15300 _ACEOF
15301 rm -f conftest.$ac_objext conftest$ac_exeext
15302 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15303   (eval $ac_link) 2>conftest.er1
15304   ac_status=$?
15305   grep -v '^ *+' conftest.er1 >conftest.err
15306   rm -f conftest.er1
15307   cat conftest.err >&5
15308   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15309   (exit $ac_status); } &&
15310          { ac_try='test -z "$ac_c_werror_flag"
15311                          || test ! -s conftest.err'
15312   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15313   (eval $ac_try) 2>&5
15314   ac_status=$?
15315   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15316   (exit $ac_status); }; } &&
15317          { ac_try='test -s conftest$ac_exeext'
15318   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15319   (eval $ac_try) 2>&5
15320   ac_status=$?
15321   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15322   (exit $ac_status); }; }; then
15323   ac_cv_lib_m_floorf=yes
15324 else
15325   echo "$as_me: failed program was:" >&5
15326 sed 's/^/| /' conftest.$ac_ext >&5
15327
15328 ac_cv_lib_m_floorf=no
15329 fi
15330 rm -f conftest.err conftest.$ac_objext \
15331       conftest$ac_exeext conftest.$ac_ext
15332 LIBS=$ac_check_lib_save_LIBS
15333 fi
15334 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floorf" >&5
15335 echo "${ECHO_T}$ac_cv_lib_m_floorf" >&6
15336 if test $ac_cv_lib_m_floorf = yes; then
15337
15338 cat >>confdefs.h <<\_ACEOF
15339 #define HAVE_FLOORF 1
15340 _ACEOF
15341
15342 fi
15343
15344 echo "$as_me:$LINENO: checking for floor in -lm" >&5
15345 echo $ECHO_N "checking for floor in -lm... $ECHO_C" >&6
15346 if test "${ac_cv_lib_m_floor+set}" = set; then
15347   echo $ECHO_N "(cached) $ECHO_C" >&6
15348 else
15349   ac_check_lib_save_LIBS=$LIBS
15350 LIBS="-lm  $LIBS"
15351 if test x$gcc_no_link = xyes; then
15352   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15353 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15354    { (exit 1); exit 1; }; }
15355 fi
15356 cat >conftest.$ac_ext <<_ACEOF
15357 /* confdefs.h.  */
15358 _ACEOF
15359 cat confdefs.h >>conftest.$ac_ext
15360 cat >>conftest.$ac_ext <<_ACEOF
15361 /* end confdefs.h.  */
15362
15363 /* Override any gcc2 internal prototype to avoid an error.  */
15364 #ifdef __cplusplus
15365 extern "C"
15366 #endif
15367 /* We use char because int might match the return type of a gcc2
15368    builtin and then its argument prototype would still apply.  */
15369 char floor ();
15370 int
15371 main ()
15372 {
15373 floor ();
15374   ;
15375   return 0;
15376 }
15377 _ACEOF
15378 rm -f conftest.$ac_objext conftest$ac_exeext
15379 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15380   (eval $ac_link) 2>conftest.er1
15381   ac_status=$?
15382   grep -v '^ *+' conftest.er1 >conftest.err
15383   rm -f conftest.er1
15384   cat conftest.err >&5
15385   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15386   (exit $ac_status); } &&
15387          { ac_try='test -z "$ac_c_werror_flag"
15388                          || test ! -s conftest.err'
15389   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15390   (eval $ac_try) 2>&5
15391   ac_status=$?
15392   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15393   (exit $ac_status); }; } &&
15394          { ac_try='test -s conftest$ac_exeext'
15395   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15396   (eval $ac_try) 2>&5
15397   ac_status=$?
15398   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15399   (exit $ac_status); }; }; then
15400   ac_cv_lib_m_floor=yes
15401 else
15402   echo "$as_me: failed program was:" >&5
15403 sed 's/^/| /' conftest.$ac_ext >&5
15404
15405 ac_cv_lib_m_floor=no
15406 fi
15407 rm -f conftest.err conftest.$ac_objext \
15408       conftest$ac_exeext conftest.$ac_ext
15409 LIBS=$ac_check_lib_save_LIBS
15410 fi
15411 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floor" >&5
15412 echo "${ECHO_T}$ac_cv_lib_m_floor" >&6
15413 if test $ac_cv_lib_m_floor = yes; then
15414
15415 cat >>confdefs.h <<\_ACEOF
15416 #define HAVE_FLOOR 1
15417 _ACEOF
15418
15419 fi
15420
15421 echo "$as_me:$LINENO: checking for floorl in -lm" >&5
15422 echo $ECHO_N "checking for floorl in -lm... $ECHO_C" >&6
15423 if test "${ac_cv_lib_m_floorl+set}" = set; then
15424   echo $ECHO_N "(cached) $ECHO_C" >&6
15425 else
15426   ac_check_lib_save_LIBS=$LIBS
15427 LIBS="-lm  $LIBS"
15428 if test x$gcc_no_link = xyes; then
15429   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15430 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15431    { (exit 1); exit 1; }; }
15432 fi
15433 cat >conftest.$ac_ext <<_ACEOF
15434 /* confdefs.h.  */
15435 _ACEOF
15436 cat confdefs.h >>conftest.$ac_ext
15437 cat >>conftest.$ac_ext <<_ACEOF
15438 /* end confdefs.h.  */
15439
15440 /* Override any gcc2 internal prototype to avoid an error.  */
15441 #ifdef __cplusplus
15442 extern "C"
15443 #endif
15444 /* We use char because int might match the return type of a gcc2
15445    builtin and then its argument prototype would still apply.  */
15446 char floorl ();
15447 int
15448 main ()
15449 {
15450 floorl ();
15451   ;
15452   return 0;
15453 }
15454 _ACEOF
15455 rm -f conftest.$ac_objext conftest$ac_exeext
15456 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15457   (eval $ac_link) 2>conftest.er1
15458   ac_status=$?
15459   grep -v '^ *+' conftest.er1 >conftest.err
15460   rm -f conftest.er1
15461   cat conftest.err >&5
15462   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15463   (exit $ac_status); } &&
15464          { ac_try='test -z "$ac_c_werror_flag"
15465                          || test ! -s conftest.err'
15466   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15467   (eval $ac_try) 2>&5
15468   ac_status=$?
15469   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15470   (exit $ac_status); }; } &&
15471          { ac_try='test -s conftest$ac_exeext'
15472   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15473   (eval $ac_try) 2>&5
15474   ac_status=$?
15475   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15476   (exit $ac_status); }; }; then
15477   ac_cv_lib_m_floorl=yes
15478 else
15479   echo "$as_me: failed program was:" >&5
15480 sed 's/^/| /' conftest.$ac_ext >&5
15481
15482 ac_cv_lib_m_floorl=no
15483 fi
15484 rm -f conftest.err conftest.$ac_objext \
15485       conftest$ac_exeext conftest.$ac_ext
15486 LIBS=$ac_check_lib_save_LIBS
15487 fi
15488 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floorl" >&5
15489 echo "${ECHO_T}$ac_cv_lib_m_floorl" >&6
15490 if test $ac_cv_lib_m_floorl = yes; then
15491
15492 cat >>confdefs.h <<\_ACEOF
15493 #define HAVE_FLOORL 1
15494 _ACEOF
15495
15496 fi
15497
15498 echo "$as_me:$LINENO: checking for fmodf in -lm" >&5
15499 echo $ECHO_N "checking for fmodf in -lm... $ECHO_C" >&6
15500 if test "${ac_cv_lib_m_fmodf+set}" = set; then
15501   echo $ECHO_N "(cached) $ECHO_C" >&6
15502 else
15503   ac_check_lib_save_LIBS=$LIBS
15504 LIBS="-lm  $LIBS"
15505 if test x$gcc_no_link = xyes; then
15506   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15507 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15508    { (exit 1); exit 1; }; }
15509 fi
15510 cat >conftest.$ac_ext <<_ACEOF
15511 /* confdefs.h.  */
15512 _ACEOF
15513 cat confdefs.h >>conftest.$ac_ext
15514 cat >>conftest.$ac_ext <<_ACEOF
15515 /* end confdefs.h.  */
15516
15517 /* Override any gcc2 internal prototype to avoid an error.  */
15518 #ifdef __cplusplus
15519 extern "C"
15520 #endif
15521 /* We use char because int might match the return type of a gcc2
15522    builtin and then its argument prototype would still apply.  */
15523 char fmodf ();
15524 int
15525 main ()
15526 {
15527 fmodf ();
15528   ;
15529   return 0;
15530 }
15531 _ACEOF
15532 rm -f conftest.$ac_objext conftest$ac_exeext
15533 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15534   (eval $ac_link) 2>conftest.er1
15535   ac_status=$?
15536   grep -v '^ *+' conftest.er1 >conftest.err
15537   rm -f conftest.er1
15538   cat conftest.err >&5
15539   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15540   (exit $ac_status); } &&
15541          { ac_try='test -z "$ac_c_werror_flag"
15542                          || test ! -s conftest.err'
15543   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15544   (eval $ac_try) 2>&5
15545   ac_status=$?
15546   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15547   (exit $ac_status); }; } &&
15548          { ac_try='test -s conftest$ac_exeext'
15549   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15550   (eval $ac_try) 2>&5
15551   ac_status=$?
15552   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15553   (exit $ac_status); }; }; then
15554   ac_cv_lib_m_fmodf=yes
15555 else
15556   echo "$as_me: failed program was:" >&5
15557 sed 's/^/| /' conftest.$ac_ext >&5
15558
15559 ac_cv_lib_m_fmodf=no
15560 fi
15561 rm -f conftest.err conftest.$ac_objext \
15562       conftest$ac_exeext conftest.$ac_ext
15563 LIBS=$ac_check_lib_save_LIBS
15564 fi
15565 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fmodf" >&5
15566 echo "${ECHO_T}$ac_cv_lib_m_fmodf" >&6
15567 if test $ac_cv_lib_m_fmodf = yes; then
15568
15569 cat >>confdefs.h <<\_ACEOF
15570 #define HAVE_FMODF 1
15571 _ACEOF
15572
15573 fi
15574
15575 echo "$as_me:$LINENO: checking for fmod in -lm" >&5
15576 echo $ECHO_N "checking for fmod in -lm... $ECHO_C" >&6
15577 if test "${ac_cv_lib_m_fmod+set}" = set; then
15578   echo $ECHO_N "(cached) $ECHO_C" >&6
15579 else
15580   ac_check_lib_save_LIBS=$LIBS
15581 LIBS="-lm  $LIBS"
15582 if test x$gcc_no_link = xyes; then
15583   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15584 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15585    { (exit 1); exit 1; }; }
15586 fi
15587 cat >conftest.$ac_ext <<_ACEOF
15588 /* confdefs.h.  */
15589 _ACEOF
15590 cat confdefs.h >>conftest.$ac_ext
15591 cat >>conftest.$ac_ext <<_ACEOF
15592 /* end confdefs.h.  */
15593
15594 /* Override any gcc2 internal prototype to avoid an error.  */
15595 #ifdef __cplusplus
15596 extern "C"
15597 #endif
15598 /* We use char because int might match the return type of a gcc2
15599    builtin and then its argument prototype would still apply.  */
15600 char fmod ();
15601 int
15602 main ()
15603 {
15604 fmod ();
15605   ;
15606   return 0;
15607 }
15608 _ACEOF
15609 rm -f conftest.$ac_objext conftest$ac_exeext
15610 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15611   (eval $ac_link) 2>conftest.er1
15612   ac_status=$?
15613   grep -v '^ *+' conftest.er1 >conftest.err
15614   rm -f conftest.er1
15615   cat conftest.err >&5
15616   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15617   (exit $ac_status); } &&
15618          { ac_try='test -z "$ac_c_werror_flag"
15619                          || test ! -s conftest.err'
15620   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15621   (eval $ac_try) 2>&5
15622   ac_status=$?
15623   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15624   (exit $ac_status); }; } &&
15625          { ac_try='test -s conftest$ac_exeext'
15626   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15627   (eval $ac_try) 2>&5
15628   ac_status=$?
15629   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15630   (exit $ac_status); }; }; then
15631   ac_cv_lib_m_fmod=yes
15632 else
15633   echo "$as_me: failed program was:" >&5
15634 sed 's/^/| /' conftest.$ac_ext >&5
15635
15636 ac_cv_lib_m_fmod=no
15637 fi
15638 rm -f conftest.err conftest.$ac_objext \
15639       conftest$ac_exeext conftest.$ac_ext
15640 LIBS=$ac_check_lib_save_LIBS
15641 fi
15642 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fmod" >&5
15643 echo "${ECHO_T}$ac_cv_lib_m_fmod" >&6
15644 if test $ac_cv_lib_m_fmod = yes; then
15645
15646 cat >>confdefs.h <<\_ACEOF
15647 #define HAVE_FMOD 1
15648 _ACEOF
15649
15650 fi
15651
15652 echo "$as_me:$LINENO: checking for fmodl in -lm" >&5
15653 echo $ECHO_N "checking for fmodl in -lm... $ECHO_C" >&6
15654 if test "${ac_cv_lib_m_fmodl+set}" = set; then
15655   echo $ECHO_N "(cached) $ECHO_C" >&6
15656 else
15657   ac_check_lib_save_LIBS=$LIBS
15658 LIBS="-lm  $LIBS"
15659 if test x$gcc_no_link = xyes; then
15660   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15661 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15662    { (exit 1); exit 1; }; }
15663 fi
15664 cat >conftest.$ac_ext <<_ACEOF
15665 /* confdefs.h.  */
15666 _ACEOF
15667 cat confdefs.h >>conftest.$ac_ext
15668 cat >>conftest.$ac_ext <<_ACEOF
15669 /* end confdefs.h.  */
15670
15671 /* Override any gcc2 internal prototype to avoid an error.  */
15672 #ifdef __cplusplus
15673 extern "C"
15674 #endif
15675 /* We use char because int might match the return type of a gcc2
15676    builtin and then its argument prototype would still apply.  */
15677 char fmodl ();
15678 int
15679 main ()
15680 {
15681 fmodl ();
15682   ;
15683   return 0;
15684 }
15685 _ACEOF
15686 rm -f conftest.$ac_objext conftest$ac_exeext
15687 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15688   (eval $ac_link) 2>conftest.er1
15689   ac_status=$?
15690   grep -v '^ *+' conftest.er1 >conftest.err
15691   rm -f conftest.er1
15692   cat conftest.err >&5
15693   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15694   (exit $ac_status); } &&
15695          { ac_try='test -z "$ac_c_werror_flag"
15696                          || test ! -s conftest.err'
15697   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15698   (eval $ac_try) 2>&5
15699   ac_status=$?
15700   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15701   (exit $ac_status); }; } &&
15702          { ac_try='test -s conftest$ac_exeext'
15703   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15704   (eval $ac_try) 2>&5
15705   ac_status=$?
15706   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15707   (exit $ac_status); }; }; then
15708   ac_cv_lib_m_fmodl=yes
15709 else
15710   echo "$as_me: failed program was:" >&5
15711 sed 's/^/| /' conftest.$ac_ext >&5
15712
15713 ac_cv_lib_m_fmodl=no
15714 fi
15715 rm -f conftest.err conftest.$ac_objext \
15716       conftest$ac_exeext conftest.$ac_ext
15717 LIBS=$ac_check_lib_save_LIBS
15718 fi
15719 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fmodl" >&5
15720 echo "${ECHO_T}$ac_cv_lib_m_fmodl" >&6
15721 if test $ac_cv_lib_m_fmodl = yes; then
15722
15723 cat >>confdefs.h <<\_ACEOF
15724 #define HAVE_FMODL 1
15725 _ACEOF
15726
15727 fi
15728
15729 echo "$as_me:$LINENO: checking for frexpf in -lm" >&5
15730 echo $ECHO_N "checking for frexpf in -lm... $ECHO_C" >&6
15731 if test "${ac_cv_lib_m_frexpf+set}" = set; then
15732   echo $ECHO_N "(cached) $ECHO_C" >&6
15733 else
15734   ac_check_lib_save_LIBS=$LIBS
15735 LIBS="-lm  $LIBS"
15736 if test x$gcc_no_link = xyes; then
15737   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15738 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15739    { (exit 1); exit 1; }; }
15740 fi
15741 cat >conftest.$ac_ext <<_ACEOF
15742 /* confdefs.h.  */
15743 _ACEOF
15744 cat confdefs.h >>conftest.$ac_ext
15745 cat >>conftest.$ac_ext <<_ACEOF
15746 /* end confdefs.h.  */
15747
15748 /* Override any gcc2 internal prototype to avoid an error.  */
15749 #ifdef __cplusplus
15750 extern "C"
15751 #endif
15752 /* We use char because int might match the return type of a gcc2
15753    builtin and then its argument prototype would still apply.  */
15754 char frexpf ();
15755 int
15756 main ()
15757 {
15758 frexpf ();
15759   ;
15760   return 0;
15761 }
15762 _ACEOF
15763 rm -f conftest.$ac_objext conftest$ac_exeext
15764 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15765   (eval $ac_link) 2>conftest.er1
15766   ac_status=$?
15767   grep -v '^ *+' conftest.er1 >conftest.err
15768   rm -f conftest.er1
15769   cat conftest.err >&5
15770   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15771   (exit $ac_status); } &&
15772          { ac_try='test -z "$ac_c_werror_flag"
15773                          || test ! -s conftest.err'
15774   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15775   (eval $ac_try) 2>&5
15776   ac_status=$?
15777   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15778   (exit $ac_status); }; } &&
15779          { ac_try='test -s conftest$ac_exeext'
15780   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15781   (eval $ac_try) 2>&5
15782   ac_status=$?
15783   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15784   (exit $ac_status); }; }; then
15785   ac_cv_lib_m_frexpf=yes
15786 else
15787   echo "$as_me: failed program was:" >&5
15788 sed 's/^/| /' conftest.$ac_ext >&5
15789
15790 ac_cv_lib_m_frexpf=no
15791 fi
15792 rm -f conftest.err conftest.$ac_objext \
15793       conftest$ac_exeext conftest.$ac_ext
15794 LIBS=$ac_check_lib_save_LIBS
15795 fi
15796 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexpf" >&5
15797 echo "${ECHO_T}$ac_cv_lib_m_frexpf" >&6
15798 if test $ac_cv_lib_m_frexpf = yes; then
15799
15800 cat >>confdefs.h <<\_ACEOF
15801 #define HAVE_FREXPF 1
15802 _ACEOF
15803
15804 fi
15805
15806 echo "$as_me:$LINENO: checking for frexp in -lm" >&5
15807 echo $ECHO_N "checking for frexp in -lm... $ECHO_C" >&6
15808 if test "${ac_cv_lib_m_frexp+set}" = set; then
15809   echo $ECHO_N "(cached) $ECHO_C" >&6
15810 else
15811   ac_check_lib_save_LIBS=$LIBS
15812 LIBS="-lm  $LIBS"
15813 if test x$gcc_no_link = xyes; then
15814   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15815 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15816    { (exit 1); exit 1; }; }
15817 fi
15818 cat >conftest.$ac_ext <<_ACEOF
15819 /* confdefs.h.  */
15820 _ACEOF
15821 cat confdefs.h >>conftest.$ac_ext
15822 cat >>conftest.$ac_ext <<_ACEOF
15823 /* end confdefs.h.  */
15824
15825 /* Override any gcc2 internal prototype to avoid an error.  */
15826 #ifdef __cplusplus
15827 extern "C"
15828 #endif
15829 /* We use char because int might match the return type of a gcc2
15830    builtin and then its argument prototype would still apply.  */
15831 char frexp ();
15832 int
15833 main ()
15834 {
15835 frexp ();
15836   ;
15837   return 0;
15838 }
15839 _ACEOF
15840 rm -f conftest.$ac_objext conftest$ac_exeext
15841 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15842   (eval $ac_link) 2>conftest.er1
15843   ac_status=$?
15844   grep -v '^ *+' conftest.er1 >conftest.err
15845   rm -f conftest.er1
15846   cat conftest.err >&5
15847   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15848   (exit $ac_status); } &&
15849          { ac_try='test -z "$ac_c_werror_flag"
15850                          || test ! -s conftest.err'
15851   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15852   (eval $ac_try) 2>&5
15853   ac_status=$?
15854   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15855   (exit $ac_status); }; } &&
15856          { ac_try='test -s conftest$ac_exeext'
15857   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15858   (eval $ac_try) 2>&5
15859   ac_status=$?
15860   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15861   (exit $ac_status); }; }; then
15862   ac_cv_lib_m_frexp=yes
15863 else
15864   echo "$as_me: failed program was:" >&5
15865 sed 's/^/| /' conftest.$ac_ext >&5
15866
15867 ac_cv_lib_m_frexp=no
15868 fi
15869 rm -f conftest.err conftest.$ac_objext \
15870       conftest$ac_exeext conftest.$ac_ext
15871 LIBS=$ac_check_lib_save_LIBS
15872 fi
15873 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexp" >&5
15874 echo "${ECHO_T}$ac_cv_lib_m_frexp" >&6
15875 if test $ac_cv_lib_m_frexp = yes; then
15876
15877 cat >>confdefs.h <<\_ACEOF
15878 #define HAVE_FREXP 1
15879 _ACEOF
15880
15881 fi
15882
15883 echo "$as_me:$LINENO: checking for frexpl in -lm" >&5
15884 echo $ECHO_N "checking for frexpl in -lm... $ECHO_C" >&6
15885 if test "${ac_cv_lib_m_frexpl+set}" = set; then
15886   echo $ECHO_N "(cached) $ECHO_C" >&6
15887 else
15888   ac_check_lib_save_LIBS=$LIBS
15889 LIBS="-lm  $LIBS"
15890 if test x$gcc_no_link = xyes; then
15891   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15892 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15893    { (exit 1); exit 1; }; }
15894 fi
15895 cat >conftest.$ac_ext <<_ACEOF
15896 /* confdefs.h.  */
15897 _ACEOF
15898 cat confdefs.h >>conftest.$ac_ext
15899 cat >>conftest.$ac_ext <<_ACEOF
15900 /* end confdefs.h.  */
15901
15902 /* Override any gcc2 internal prototype to avoid an error.  */
15903 #ifdef __cplusplus
15904 extern "C"
15905 #endif
15906 /* We use char because int might match the return type of a gcc2
15907    builtin and then its argument prototype would still apply.  */
15908 char frexpl ();
15909 int
15910 main ()
15911 {
15912 frexpl ();
15913   ;
15914   return 0;
15915 }
15916 _ACEOF
15917 rm -f conftest.$ac_objext conftest$ac_exeext
15918 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15919   (eval $ac_link) 2>conftest.er1
15920   ac_status=$?
15921   grep -v '^ *+' conftest.er1 >conftest.err
15922   rm -f conftest.er1
15923   cat conftest.err >&5
15924   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15925   (exit $ac_status); } &&
15926          { ac_try='test -z "$ac_c_werror_flag"
15927                          || test ! -s conftest.err'
15928   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15929   (eval $ac_try) 2>&5
15930   ac_status=$?
15931   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15932   (exit $ac_status); }; } &&
15933          { ac_try='test -s conftest$ac_exeext'
15934   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15935   (eval $ac_try) 2>&5
15936   ac_status=$?
15937   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15938   (exit $ac_status); }; }; then
15939   ac_cv_lib_m_frexpl=yes
15940 else
15941   echo "$as_me: failed program was:" >&5
15942 sed 's/^/| /' conftest.$ac_ext >&5
15943
15944 ac_cv_lib_m_frexpl=no
15945 fi
15946 rm -f conftest.err conftest.$ac_objext \
15947       conftest$ac_exeext conftest.$ac_ext
15948 LIBS=$ac_check_lib_save_LIBS
15949 fi
15950 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexpl" >&5
15951 echo "${ECHO_T}$ac_cv_lib_m_frexpl" >&6
15952 if test $ac_cv_lib_m_frexpl = yes; then
15953
15954 cat >>confdefs.h <<\_ACEOF
15955 #define HAVE_FREXPL 1
15956 _ACEOF
15957
15958 fi
15959
15960 echo "$as_me:$LINENO: checking for hypotf in -lm" >&5
15961 echo $ECHO_N "checking for hypotf in -lm... $ECHO_C" >&6
15962 if test "${ac_cv_lib_m_hypotf+set}" = set; then
15963   echo $ECHO_N "(cached) $ECHO_C" >&6
15964 else
15965   ac_check_lib_save_LIBS=$LIBS
15966 LIBS="-lm  $LIBS"
15967 if test x$gcc_no_link = xyes; then
15968   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15969 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15970    { (exit 1); exit 1; }; }
15971 fi
15972 cat >conftest.$ac_ext <<_ACEOF
15973 /* confdefs.h.  */
15974 _ACEOF
15975 cat confdefs.h >>conftest.$ac_ext
15976 cat >>conftest.$ac_ext <<_ACEOF
15977 /* end confdefs.h.  */
15978
15979 /* Override any gcc2 internal prototype to avoid an error.  */
15980 #ifdef __cplusplus
15981 extern "C"
15982 #endif
15983 /* We use char because int might match the return type of a gcc2
15984    builtin and then its argument prototype would still apply.  */
15985 char hypotf ();
15986 int
15987 main ()
15988 {
15989 hypotf ();
15990   ;
15991   return 0;
15992 }
15993 _ACEOF
15994 rm -f conftest.$ac_objext conftest$ac_exeext
15995 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15996   (eval $ac_link) 2>conftest.er1
15997   ac_status=$?
15998   grep -v '^ *+' conftest.er1 >conftest.err
15999   rm -f conftest.er1
16000   cat conftest.err >&5
16001   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16002   (exit $ac_status); } &&
16003          { ac_try='test -z "$ac_c_werror_flag"
16004                          || test ! -s conftest.err'
16005   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16006   (eval $ac_try) 2>&5
16007   ac_status=$?
16008   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16009   (exit $ac_status); }; } &&
16010          { ac_try='test -s conftest$ac_exeext'
16011   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16012   (eval $ac_try) 2>&5
16013   ac_status=$?
16014   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16015   (exit $ac_status); }; }; then
16016   ac_cv_lib_m_hypotf=yes
16017 else
16018   echo "$as_me: failed program was:" >&5
16019 sed 's/^/| /' conftest.$ac_ext >&5
16020
16021 ac_cv_lib_m_hypotf=no
16022 fi
16023 rm -f conftest.err conftest.$ac_objext \
16024       conftest$ac_exeext conftest.$ac_ext
16025 LIBS=$ac_check_lib_save_LIBS
16026 fi
16027 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypotf" >&5
16028 echo "${ECHO_T}$ac_cv_lib_m_hypotf" >&6
16029 if test $ac_cv_lib_m_hypotf = yes; then
16030
16031 cat >>confdefs.h <<\_ACEOF
16032 #define HAVE_HYPOTF 1
16033 _ACEOF
16034
16035 fi
16036
16037 echo "$as_me:$LINENO: checking for hypot in -lm" >&5
16038 echo $ECHO_N "checking for hypot in -lm... $ECHO_C" >&6
16039 if test "${ac_cv_lib_m_hypot+set}" = set; then
16040   echo $ECHO_N "(cached) $ECHO_C" >&6
16041 else
16042   ac_check_lib_save_LIBS=$LIBS
16043 LIBS="-lm  $LIBS"
16044 if test x$gcc_no_link = xyes; then
16045   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16046 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16047    { (exit 1); exit 1; }; }
16048 fi
16049 cat >conftest.$ac_ext <<_ACEOF
16050 /* confdefs.h.  */
16051 _ACEOF
16052 cat confdefs.h >>conftest.$ac_ext
16053 cat >>conftest.$ac_ext <<_ACEOF
16054 /* end confdefs.h.  */
16055
16056 /* Override any gcc2 internal prototype to avoid an error.  */
16057 #ifdef __cplusplus
16058 extern "C"
16059 #endif
16060 /* We use char because int might match the return type of a gcc2
16061    builtin and then its argument prototype would still apply.  */
16062 char hypot ();
16063 int
16064 main ()
16065 {
16066 hypot ();
16067   ;
16068   return 0;
16069 }
16070 _ACEOF
16071 rm -f conftest.$ac_objext conftest$ac_exeext
16072 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16073   (eval $ac_link) 2>conftest.er1
16074   ac_status=$?
16075   grep -v '^ *+' conftest.er1 >conftest.err
16076   rm -f conftest.er1
16077   cat conftest.err >&5
16078   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16079   (exit $ac_status); } &&
16080          { ac_try='test -z "$ac_c_werror_flag"
16081                          || test ! -s conftest.err'
16082   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16083   (eval $ac_try) 2>&5
16084   ac_status=$?
16085   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16086   (exit $ac_status); }; } &&
16087          { ac_try='test -s conftest$ac_exeext'
16088   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16089   (eval $ac_try) 2>&5
16090   ac_status=$?
16091   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16092   (exit $ac_status); }; }; then
16093   ac_cv_lib_m_hypot=yes
16094 else
16095   echo "$as_me: failed program was:" >&5
16096 sed 's/^/| /' conftest.$ac_ext >&5
16097
16098 ac_cv_lib_m_hypot=no
16099 fi
16100 rm -f conftest.err conftest.$ac_objext \
16101       conftest$ac_exeext conftest.$ac_ext
16102 LIBS=$ac_check_lib_save_LIBS
16103 fi
16104 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypot" >&5
16105 echo "${ECHO_T}$ac_cv_lib_m_hypot" >&6
16106 if test $ac_cv_lib_m_hypot = yes; then
16107
16108 cat >>confdefs.h <<\_ACEOF
16109 #define HAVE_HYPOT 1
16110 _ACEOF
16111
16112 fi
16113
16114 echo "$as_me:$LINENO: checking for hypotl in -lm" >&5
16115 echo $ECHO_N "checking for hypotl in -lm... $ECHO_C" >&6
16116 if test "${ac_cv_lib_m_hypotl+set}" = set; then
16117   echo $ECHO_N "(cached) $ECHO_C" >&6
16118 else
16119   ac_check_lib_save_LIBS=$LIBS
16120 LIBS="-lm  $LIBS"
16121 if test x$gcc_no_link = xyes; then
16122   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16123 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16124    { (exit 1); exit 1; }; }
16125 fi
16126 cat >conftest.$ac_ext <<_ACEOF
16127 /* confdefs.h.  */
16128 _ACEOF
16129 cat confdefs.h >>conftest.$ac_ext
16130 cat >>conftest.$ac_ext <<_ACEOF
16131 /* end confdefs.h.  */
16132
16133 /* Override any gcc2 internal prototype to avoid an error.  */
16134 #ifdef __cplusplus
16135 extern "C"
16136 #endif
16137 /* We use char because int might match the return type of a gcc2
16138    builtin and then its argument prototype would still apply.  */
16139 char hypotl ();
16140 int
16141 main ()
16142 {
16143 hypotl ();
16144   ;
16145   return 0;
16146 }
16147 _ACEOF
16148 rm -f conftest.$ac_objext conftest$ac_exeext
16149 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16150   (eval $ac_link) 2>conftest.er1
16151   ac_status=$?
16152   grep -v '^ *+' conftest.er1 >conftest.err
16153   rm -f conftest.er1
16154   cat conftest.err >&5
16155   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16156   (exit $ac_status); } &&
16157          { ac_try='test -z "$ac_c_werror_flag"
16158                          || test ! -s conftest.err'
16159   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16160   (eval $ac_try) 2>&5
16161   ac_status=$?
16162   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16163   (exit $ac_status); }; } &&
16164          { ac_try='test -s conftest$ac_exeext'
16165   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16166   (eval $ac_try) 2>&5
16167   ac_status=$?
16168   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16169   (exit $ac_status); }; }; then
16170   ac_cv_lib_m_hypotl=yes
16171 else
16172   echo "$as_me: failed program was:" >&5
16173 sed 's/^/| /' conftest.$ac_ext >&5
16174
16175 ac_cv_lib_m_hypotl=no
16176 fi
16177 rm -f conftest.err conftest.$ac_objext \
16178       conftest$ac_exeext conftest.$ac_ext
16179 LIBS=$ac_check_lib_save_LIBS
16180 fi
16181 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypotl" >&5
16182 echo "${ECHO_T}$ac_cv_lib_m_hypotl" >&6
16183 if test $ac_cv_lib_m_hypotl = yes; then
16184
16185 cat >>confdefs.h <<\_ACEOF
16186 #define HAVE_HYPOTL 1
16187 _ACEOF
16188
16189 fi
16190
16191 echo "$as_me:$LINENO: checking for ldexpf in -lm" >&5
16192 echo $ECHO_N "checking for ldexpf in -lm... $ECHO_C" >&6
16193 if test "${ac_cv_lib_m_ldexpf+set}" = set; then
16194   echo $ECHO_N "(cached) $ECHO_C" >&6
16195 else
16196   ac_check_lib_save_LIBS=$LIBS
16197 LIBS="-lm  $LIBS"
16198 if test x$gcc_no_link = xyes; then
16199   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16200 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16201    { (exit 1); exit 1; }; }
16202 fi
16203 cat >conftest.$ac_ext <<_ACEOF
16204 /* confdefs.h.  */
16205 _ACEOF
16206 cat confdefs.h >>conftest.$ac_ext
16207 cat >>conftest.$ac_ext <<_ACEOF
16208 /* end confdefs.h.  */
16209
16210 /* Override any gcc2 internal prototype to avoid an error.  */
16211 #ifdef __cplusplus
16212 extern "C"
16213 #endif
16214 /* We use char because int might match the return type of a gcc2
16215    builtin and then its argument prototype would still apply.  */
16216 char ldexpf ();
16217 int
16218 main ()
16219 {
16220 ldexpf ();
16221   ;
16222   return 0;
16223 }
16224 _ACEOF
16225 rm -f conftest.$ac_objext conftest$ac_exeext
16226 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16227   (eval $ac_link) 2>conftest.er1
16228   ac_status=$?
16229   grep -v '^ *+' conftest.er1 >conftest.err
16230   rm -f conftest.er1
16231   cat conftest.err >&5
16232   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16233   (exit $ac_status); } &&
16234          { ac_try='test -z "$ac_c_werror_flag"
16235                          || test ! -s conftest.err'
16236   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16237   (eval $ac_try) 2>&5
16238   ac_status=$?
16239   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16240   (exit $ac_status); }; } &&
16241          { ac_try='test -s conftest$ac_exeext'
16242   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16243   (eval $ac_try) 2>&5
16244   ac_status=$?
16245   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16246   (exit $ac_status); }; }; then
16247   ac_cv_lib_m_ldexpf=yes
16248 else
16249   echo "$as_me: failed program was:" >&5
16250 sed 's/^/| /' conftest.$ac_ext >&5
16251
16252 ac_cv_lib_m_ldexpf=no
16253 fi
16254 rm -f conftest.err conftest.$ac_objext \
16255       conftest$ac_exeext conftest.$ac_ext
16256 LIBS=$ac_check_lib_save_LIBS
16257 fi
16258 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ldexpf" >&5
16259 echo "${ECHO_T}$ac_cv_lib_m_ldexpf" >&6
16260 if test $ac_cv_lib_m_ldexpf = yes; then
16261
16262 cat >>confdefs.h <<\_ACEOF
16263 #define HAVE_LDEXPF 1
16264 _ACEOF
16265
16266 fi
16267
16268 echo "$as_me:$LINENO: checking for ldexp in -lm" >&5
16269 echo $ECHO_N "checking for ldexp in -lm... $ECHO_C" >&6
16270 if test "${ac_cv_lib_m_ldexp+set}" = set; then
16271   echo $ECHO_N "(cached) $ECHO_C" >&6
16272 else
16273   ac_check_lib_save_LIBS=$LIBS
16274 LIBS="-lm  $LIBS"
16275 if test x$gcc_no_link = xyes; then
16276   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16277 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16278    { (exit 1); exit 1; }; }
16279 fi
16280 cat >conftest.$ac_ext <<_ACEOF
16281 /* confdefs.h.  */
16282 _ACEOF
16283 cat confdefs.h >>conftest.$ac_ext
16284 cat >>conftest.$ac_ext <<_ACEOF
16285 /* end confdefs.h.  */
16286
16287 /* Override any gcc2 internal prototype to avoid an error.  */
16288 #ifdef __cplusplus
16289 extern "C"
16290 #endif
16291 /* We use char because int might match the return type of a gcc2
16292    builtin and then its argument prototype would still apply.  */
16293 char ldexp ();
16294 int
16295 main ()
16296 {
16297 ldexp ();
16298   ;
16299   return 0;
16300 }
16301 _ACEOF
16302 rm -f conftest.$ac_objext conftest$ac_exeext
16303 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16304   (eval $ac_link) 2>conftest.er1
16305   ac_status=$?
16306   grep -v '^ *+' conftest.er1 >conftest.err
16307   rm -f conftest.er1
16308   cat conftest.err >&5
16309   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16310   (exit $ac_status); } &&
16311          { ac_try='test -z "$ac_c_werror_flag"
16312                          || test ! -s conftest.err'
16313   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16314   (eval $ac_try) 2>&5
16315   ac_status=$?
16316   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16317   (exit $ac_status); }; } &&
16318          { ac_try='test -s conftest$ac_exeext'
16319   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16320   (eval $ac_try) 2>&5
16321   ac_status=$?
16322   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16323   (exit $ac_status); }; }; then
16324   ac_cv_lib_m_ldexp=yes
16325 else
16326   echo "$as_me: failed program was:" >&5
16327 sed 's/^/| /' conftest.$ac_ext >&5
16328
16329 ac_cv_lib_m_ldexp=no
16330 fi
16331 rm -f conftest.err conftest.$ac_objext \
16332       conftest$ac_exeext conftest.$ac_ext
16333 LIBS=$ac_check_lib_save_LIBS
16334 fi
16335 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ldexp" >&5
16336 echo "${ECHO_T}$ac_cv_lib_m_ldexp" >&6
16337 if test $ac_cv_lib_m_ldexp = yes; then
16338
16339 cat >>confdefs.h <<\_ACEOF
16340 #define HAVE_LDEXP 1
16341 _ACEOF
16342
16343 fi
16344
16345 echo "$as_me:$LINENO: checking for ldexpl in -lm" >&5
16346 echo $ECHO_N "checking for ldexpl in -lm... $ECHO_C" >&6
16347 if test "${ac_cv_lib_m_ldexpl+set}" = set; then
16348   echo $ECHO_N "(cached) $ECHO_C" >&6
16349 else
16350   ac_check_lib_save_LIBS=$LIBS
16351 LIBS="-lm  $LIBS"
16352 if test x$gcc_no_link = xyes; then
16353   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16354 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16355    { (exit 1); exit 1; }; }
16356 fi
16357 cat >conftest.$ac_ext <<_ACEOF
16358 /* confdefs.h.  */
16359 _ACEOF
16360 cat confdefs.h >>conftest.$ac_ext
16361 cat >>conftest.$ac_ext <<_ACEOF
16362 /* end confdefs.h.  */
16363
16364 /* Override any gcc2 internal prototype to avoid an error.  */
16365 #ifdef __cplusplus
16366 extern "C"
16367 #endif
16368 /* We use char because int might match the return type of a gcc2
16369    builtin and then its argument prototype would still apply.  */
16370 char ldexpl ();
16371 int
16372 main ()
16373 {
16374 ldexpl ();
16375   ;
16376   return 0;
16377 }
16378 _ACEOF
16379 rm -f conftest.$ac_objext conftest$ac_exeext
16380 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16381   (eval $ac_link) 2>conftest.er1
16382   ac_status=$?
16383   grep -v '^ *+' conftest.er1 >conftest.err
16384   rm -f conftest.er1
16385   cat conftest.err >&5
16386   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16387   (exit $ac_status); } &&
16388          { ac_try='test -z "$ac_c_werror_flag"
16389                          || test ! -s conftest.err'
16390   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16391   (eval $ac_try) 2>&5
16392   ac_status=$?
16393   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16394   (exit $ac_status); }; } &&
16395          { ac_try='test -s conftest$ac_exeext'
16396   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16397   (eval $ac_try) 2>&5
16398   ac_status=$?
16399   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16400   (exit $ac_status); }; }; then
16401   ac_cv_lib_m_ldexpl=yes
16402 else
16403   echo "$as_me: failed program was:" >&5
16404 sed 's/^/| /' conftest.$ac_ext >&5
16405
16406 ac_cv_lib_m_ldexpl=no
16407 fi
16408 rm -f conftest.err conftest.$ac_objext \
16409       conftest$ac_exeext conftest.$ac_ext
16410 LIBS=$ac_check_lib_save_LIBS
16411 fi
16412 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ldexpl" >&5
16413 echo "${ECHO_T}$ac_cv_lib_m_ldexpl" >&6
16414 if test $ac_cv_lib_m_ldexpl = yes; then
16415
16416 cat >>confdefs.h <<\_ACEOF
16417 #define HAVE_LDEXPL 1
16418 _ACEOF
16419
16420 fi
16421
16422 echo "$as_me:$LINENO: checking for logf in -lm" >&5
16423 echo $ECHO_N "checking for logf in -lm... $ECHO_C" >&6
16424 if test "${ac_cv_lib_m_logf+set}" = set; then
16425   echo $ECHO_N "(cached) $ECHO_C" >&6
16426 else
16427   ac_check_lib_save_LIBS=$LIBS
16428 LIBS="-lm  $LIBS"
16429 if test x$gcc_no_link = xyes; then
16430   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16431 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16432    { (exit 1); exit 1; }; }
16433 fi
16434 cat >conftest.$ac_ext <<_ACEOF
16435 /* confdefs.h.  */
16436 _ACEOF
16437 cat confdefs.h >>conftest.$ac_ext
16438 cat >>conftest.$ac_ext <<_ACEOF
16439 /* end confdefs.h.  */
16440
16441 /* Override any gcc2 internal prototype to avoid an error.  */
16442 #ifdef __cplusplus
16443 extern "C"
16444 #endif
16445 /* We use char because int might match the return type of a gcc2
16446    builtin and then its argument prototype would still apply.  */
16447 char logf ();
16448 int
16449 main ()
16450 {
16451 logf ();
16452   ;
16453   return 0;
16454 }
16455 _ACEOF
16456 rm -f conftest.$ac_objext conftest$ac_exeext
16457 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16458   (eval $ac_link) 2>conftest.er1
16459   ac_status=$?
16460   grep -v '^ *+' conftest.er1 >conftest.err
16461   rm -f conftest.er1
16462   cat conftest.err >&5
16463   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16464   (exit $ac_status); } &&
16465          { ac_try='test -z "$ac_c_werror_flag"
16466                          || test ! -s conftest.err'
16467   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16468   (eval $ac_try) 2>&5
16469   ac_status=$?
16470   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16471   (exit $ac_status); }; } &&
16472          { ac_try='test -s conftest$ac_exeext'
16473   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16474   (eval $ac_try) 2>&5
16475   ac_status=$?
16476   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16477   (exit $ac_status); }; }; then
16478   ac_cv_lib_m_logf=yes
16479 else
16480   echo "$as_me: failed program was:" >&5
16481 sed 's/^/| /' conftest.$ac_ext >&5
16482
16483 ac_cv_lib_m_logf=no
16484 fi
16485 rm -f conftest.err conftest.$ac_objext \
16486       conftest$ac_exeext conftest.$ac_ext
16487 LIBS=$ac_check_lib_save_LIBS
16488 fi
16489 echo "$as_me:$LINENO: result: $ac_cv_lib_m_logf" >&5
16490 echo "${ECHO_T}$ac_cv_lib_m_logf" >&6
16491 if test $ac_cv_lib_m_logf = yes; then
16492
16493 cat >>confdefs.h <<\_ACEOF
16494 #define HAVE_LOGF 1
16495 _ACEOF
16496
16497 fi
16498
16499 echo "$as_me:$LINENO: checking for log in -lm" >&5
16500 echo $ECHO_N "checking for log in -lm... $ECHO_C" >&6
16501 if test "${ac_cv_lib_m_log+set}" = set; then
16502   echo $ECHO_N "(cached) $ECHO_C" >&6
16503 else
16504   ac_check_lib_save_LIBS=$LIBS
16505 LIBS="-lm  $LIBS"
16506 if test x$gcc_no_link = xyes; then
16507   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16508 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16509    { (exit 1); exit 1; }; }
16510 fi
16511 cat >conftest.$ac_ext <<_ACEOF
16512 /* confdefs.h.  */
16513 _ACEOF
16514 cat confdefs.h >>conftest.$ac_ext
16515 cat >>conftest.$ac_ext <<_ACEOF
16516 /* end confdefs.h.  */
16517
16518 /* Override any gcc2 internal prototype to avoid an error.  */
16519 #ifdef __cplusplus
16520 extern "C"
16521 #endif
16522 /* We use char because int might match the return type of a gcc2
16523    builtin and then its argument prototype would still apply.  */
16524 char log ();
16525 int
16526 main ()
16527 {
16528 log ();
16529   ;
16530   return 0;
16531 }
16532 _ACEOF
16533 rm -f conftest.$ac_objext conftest$ac_exeext
16534 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16535   (eval $ac_link) 2>conftest.er1
16536   ac_status=$?
16537   grep -v '^ *+' conftest.er1 >conftest.err
16538   rm -f conftest.er1
16539   cat conftest.err >&5
16540   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16541   (exit $ac_status); } &&
16542          { ac_try='test -z "$ac_c_werror_flag"
16543                          || test ! -s conftest.err'
16544   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16545   (eval $ac_try) 2>&5
16546   ac_status=$?
16547   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16548   (exit $ac_status); }; } &&
16549          { ac_try='test -s conftest$ac_exeext'
16550   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16551   (eval $ac_try) 2>&5
16552   ac_status=$?
16553   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16554   (exit $ac_status); }; }; then
16555   ac_cv_lib_m_log=yes
16556 else
16557   echo "$as_me: failed program was:" >&5
16558 sed 's/^/| /' conftest.$ac_ext >&5
16559
16560 ac_cv_lib_m_log=no
16561 fi
16562 rm -f conftest.err conftest.$ac_objext \
16563       conftest$ac_exeext conftest.$ac_ext
16564 LIBS=$ac_check_lib_save_LIBS
16565 fi
16566 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log" >&5
16567 echo "${ECHO_T}$ac_cv_lib_m_log" >&6
16568 if test $ac_cv_lib_m_log = yes; then
16569
16570 cat >>confdefs.h <<\_ACEOF
16571 #define HAVE_LOG 1
16572 _ACEOF
16573
16574 fi
16575
16576 echo "$as_me:$LINENO: checking for logl in -lm" >&5
16577 echo $ECHO_N "checking for logl in -lm... $ECHO_C" >&6
16578 if test "${ac_cv_lib_m_logl+set}" = set; then
16579   echo $ECHO_N "(cached) $ECHO_C" >&6
16580 else
16581   ac_check_lib_save_LIBS=$LIBS
16582 LIBS="-lm  $LIBS"
16583 if test x$gcc_no_link = xyes; then
16584   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16585 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16586    { (exit 1); exit 1; }; }
16587 fi
16588 cat >conftest.$ac_ext <<_ACEOF
16589 /* confdefs.h.  */
16590 _ACEOF
16591 cat confdefs.h >>conftest.$ac_ext
16592 cat >>conftest.$ac_ext <<_ACEOF
16593 /* end confdefs.h.  */
16594
16595 /* Override any gcc2 internal prototype to avoid an error.  */
16596 #ifdef __cplusplus
16597 extern "C"
16598 #endif
16599 /* We use char because int might match the return type of a gcc2
16600    builtin and then its argument prototype would still apply.  */
16601 char logl ();
16602 int
16603 main ()
16604 {
16605 logl ();
16606   ;
16607   return 0;
16608 }
16609 _ACEOF
16610 rm -f conftest.$ac_objext conftest$ac_exeext
16611 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16612   (eval $ac_link) 2>conftest.er1
16613   ac_status=$?
16614   grep -v '^ *+' conftest.er1 >conftest.err
16615   rm -f conftest.er1
16616   cat conftest.err >&5
16617   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16618   (exit $ac_status); } &&
16619          { ac_try='test -z "$ac_c_werror_flag"
16620                          || test ! -s conftest.err'
16621   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16622   (eval $ac_try) 2>&5
16623   ac_status=$?
16624   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16625   (exit $ac_status); }; } &&
16626          { ac_try='test -s conftest$ac_exeext'
16627   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16628   (eval $ac_try) 2>&5
16629   ac_status=$?
16630   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16631   (exit $ac_status); }; }; then
16632   ac_cv_lib_m_logl=yes
16633 else
16634   echo "$as_me: failed program was:" >&5
16635 sed 's/^/| /' conftest.$ac_ext >&5
16636
16637 ac_cv_lib_m_logl=no
16638 fi
16639 rm -f conftest.err conftest.$ac_objext \
16640       conftest$ac_exeext conftest.$ac_ext
16641 LIBS=$ac_check_lib_save_LIBS
16642 fi
16643 echo "$as_me:$LINENO: result: $ac_cv_lib_m_logl" >&5
16644 echo "${ECHO_T}$ac_cv_lib_m_logl" >&6
16645 if test $ac_cv_lib_m_logl = yes; then
16646
16647 cat >>confdefs.h <<\_ACEOF
16648 #define HAVE_LOGL 1
16649 _ACEOF
16650
16651 fi
16652
16653 echo "$as_me:$LINENO: checking for clogf in -lm" >&5
16654 echo $ECHO_N "checking for clogf in -lm... $ECHO_C" >&6
16655 if test "${ac_cv_lib_m_clogf+set}" = set; then
16656   echo $ECHO_N "(cached) $ECHO_C" >&6
16657 else
16658   ac_check_lib_save_LIBS=$LIBS
16659 LIBS="-lm  $LIBS"
16660 if test x$gcc_no_link = xyes; then
16661   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16662 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16663    { (exit 1); exit 1; }; }
16664 fi
16665 cat >conftest.$ac_ext <<_ACEOF
16666 /* confdefs.h.  */
16667 _ACEOF
16668 cat confdefs.h >>conftest.$ac_ext
16669 cat >>conftest.$ac_ext <<_ACEOF
16670 /* end confdefs.h.  */
16671
16672 /* Override any gcc2 internal prototype to avoid an error.  */
16673 #ifdef __cplusplus
16674 extern "C"
16675 #endif
16676 /* We use char because int might match the return type of a gcc2
16677    builtin and then its argument prototype would still apply.  */
16678 char clogf ();
16679 int
16680 main ()
16681 {
16682 clogf ();
16683   ;
16684   return 0;
16685 }
16686 _ACEOF
16687 rm -f conftest.$ac_objext conftest$ac_exeext
16688 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16689   (eval $ac_link) 2>conftest.er1
16690   ac_status=$?
16691   grep -v '^ *+' conftest.er1 >conftest.err
16692   rm -f conftest.er1
16693   cat conftest.err >&5
16694   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16695   (exit $ac_status); } &&
16696          { ac_try='test -z "$ac_c_werror_flag"
16697                          || test ! -s conftest.err'
16698   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16699   (eval $ac_try) 2>&5
16700   ac_status=$?
16701   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16702   (exit $ac_status); }; } &&
16703          { ac_try='test -s conftest$ac_exeext'
16704   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16705   (eval $ac_try) 2>&5
16706   ac_status=$?
16707   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16708   (exit $ac_status); }; }; then
16709   ac_cv_lib_m_clogf=yes
16710 else
16711   echo "$as_me: failed program was:" >&5
16712 sed 's/^/| /' conftest.$ac_ext >&5
16713
16714 ac_cv_lib_m_clogf=no
16715 fi
16716 rm -f conftest.err conftest.$ac_objext \
16717       conftest$ac_exeext conftest.$ac_ext
16718 LIBS=$ac_check_lib_save_LIBS
16719 fi
16720 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clogf" >&5
16721 echo "${ECHO_T}$ac_cv_lib_m_clogf" >&6
16722 if test $ac_cv_lib_m_clogf = yes; then
16723
16724 cat >>confdefs.h <<\_ACEOF
16725 #define HAVE_CLOGF 1
16726 _ACEOF
16727
16728 fi
16729
16730 echo "$as_me:$LINENO: checking for clog in -lm" >&5
16731 echo $ECHO_N "checking for clog in -lm... $ECHO_C" >&6
16732 if test "${ac_cv_lib_m_clog+set}" = set; then
16733   echo $ECHO_N "(cached) $ECHO_C" >&6
16734 else
16735   ac_check_lib_save_LIBS=$LIBS
16736 LIBS="-lm  $LIBS"
16737 if test x$gcc_no_link = xyes; then
16738   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16739 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16740    { (exit 1); exit 1; }; }
16741 fi
16742 cat >conftest.$ac_ext <<_ACEOF
16743 /* confdefs.h.  */
16744 _ACEOF
16745 cat confdefs.h >>conftest.$ac_ext
16746 cat >>conftest.$ac_ext <<_ACEOF
16747 /* end confdefs.h.  */
16748
16749 /* Override any gcc2 internal prototype to avoid an error.  */
16750 #ifdef __cplusplus
16751 extern "C"
16752 #endif
16753 /* We use char because int might match the return type of a gcc2
16754    builtin and then its argument prototype would still apply.  */
16755 char clog ();
16756 int
16757 main ()
16758 {
16759 clog ();
16760   ;
16761   return 0;
16762 }
16763 _ACEOF
16764 rm -f conftest.$ac_objext conftest$ac_exeext
16765 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16766   (eval $ac_link) 2>conftest.er1
16767   ac_status=$?
16768   grep -v '^ *+' conftest.er1 >conftest.err
16769   rm -f conftest.er1
16770   cat conftest.err >&5
16771   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16772   (exit $ac_status); } &&
16773          { ac_try='test -z "$ac_c_werror_flag"
16774                          || test ! -s conftest.err'
16775   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16776   (eval $ac_try) 2>&5
16777   ac_status=$?
16778   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16779   (exit $ac_status); }; } &&
16780          { ac_try='test -s conftest$ac_exeext'
16781   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16782   (eval $ac_try) 2>&5
16783   ac_status=$?
16784   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16785   (exit $ac_status); }; }; then
16786   ac_cv_lib_m_clog=yes
16787 else
16788   echo "$as_me: failed program was:" >&5
16789 sed 's/^/| /' conftest.$ac_ext >&5
16790
16791 ac_cv_lib_m_clog=no
16792 fi
16793 rm -f conftest.err conftest.$ac_objext \
16794       conftest$ac_exeext conftest.$ac_ext
16795 LIBS=$ac_check_lib_save_LIBS
16796 fi
16797 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog" >&5
16798 echo "${ECHO_T}$ac_cv_lib_m_clog" >&6
16799 if test $ac_cv_lib_m_clog = yes; then
16800
16801 cat >>confdefs.h <<\_ACEOF
16802 #define HAVE_CLOG 1
16803 _ACEOF
16804
16805 fi
16806
16807 echo "$as_me:$LINENO: checking for clogl in -lm" >&5
16808 echo $ECHO_N "checking for clogl in -lm... $ECHO_C" >&6
16809 if test "${ac_cv_lib_m_clogl+set}" = set; then
16810   echo $ECHO_N "(cached) $ECHO_C" >&6
16811 else
16812   ac_check_lib_save_LIBS=$LIBS
16813 LIBS="-lm  $LIBS"
16814 if test x$gcc_no_link = xyes; then
16815   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16816 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16817    { (exit 1); exit 1; }; }
16818 fi
16819 cat >conftest.$ac_ext <<_ACEOF
16820 /* confdefs.h.  */
16821 _ACEOF
16822 cat confdefs.h >>conftest.$ac_ext
16823 cat >>conftest.$ac_ext <<_ACEOF
16824 /* end confdefs.h.  */
16825
16826 /* Override any gcc2 internal prototype to avoid an error.  */
16827 #ifdef __cplusplus
16828 extern "C"
16829 #endif
16830 /* We use char because int might match the return type of a gcc2
16831    builtin and then its argument prototype would still apply.  */
16832 char clogl ();
16833 int
16834 main ()
16835 {
16836 clogl ();
16837   ;
16838   return 0;
16839 }
16840 _ACEOF
16841 rm -f conftest.$ac_objext conftest$ac_exeext
16842 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16843   (eval $ac_link) 2>conftest.er1
16844   ac_status=$?
16845   grep -v '^ *+' conftest.er1 >conftest.err
16846   rm -f conftest.er1
16847   cat conftest.err >&5
16848   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16849   (exit $ac_status); } &&
16850          { ac_try='test -z "$ac_c_werror_flag"
16851                          || test ! -s conftest.err'
16852   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16853   (eval $ac_try) 2>&5
16854   ac_status=$?
16855   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16856   (exit $ac_status); }; } &&
16857          { ac_try='test -s conftest$ac_exeext'
16858   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16859   (eval $ac_try) 2>&5
16860   ac_status=$?
16861   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16862   (exit $ac_status); }; }; then
16863   ac_cv_lib_m_clogl=yes
16864 else
16865   echo "$as_me: failed program was:" >&5
16866 sed 's/^/| /' conftest.$ac_ext >&5
16867
16868 ac_cv_lib_m_clogl=no
16869 fi
16870 rm -f conftest.err conftest.$ac_objext \
16871       conftest$ac_exeext conftest.$ac_ext
16872 LIBS=$ac_check_lib_save_LIBS
16873 fi
16874 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clogl" >&5
16875 echo "${ECHO_T}$ac_cv_lib_m_clogl" >&6
16876 if test $ac_cv_lib_m_clogl = yes; then
16877
16878 cat >>confdefs.h <<\_ACEOF
16879 #define HAVE_CLOGL 1
16880 _ACEOF
16881
16882 fi
16883
16884 echo "$as_me:$LINENO: checking for log10f in -lm" >&5
16885 echo $ECHO_N "checking for log10f in -lm... $ECHO_C" >&6
16886 if test "${ac_cv_lib_m_log10f+set}" = set; then
16887   echo $ECHO_N "(cached) $ECHO_C" >&6
16888 else
16889   ac_check_lib_save_LIBS=$LIBS
16890 LIBS="-lm  $LIBS"
16891 if test x$gcc_no_link = xyes; then
16892   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16893 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16894    { (exit 1); exit 1; }; }
16895 fi
16896 cat >conftest.$ac_ext <<_ACEOF
16897 /* confdefs.h.  */
16898 _ACEOF
16899 cat confdefs.h >>conftest.$ac_ext
16900 cat >>conftest.$ac_ext <<_ACEOF
16901 /* end confdefs.h.  */
16902
16903 /* Override any gcc2 internal prototype to avoid an error.  */
16904 #ifdef __cplusplus
16905 extern "C"
16906 #endif
16907 /* We use char because int might match the return type of a gcc2
16908    builtin and then its argument prototype would still apply.  */
16909 char log10f ();
16910 int
16911 main ()
16912 {
16913 log10f ();
16914   ;
16915   return 0;
16916 }
16917 _ACEOF
16918 rm -f conftest.$ac_objext conftest$ac_exeext
16919 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16920   (eval $ac_link) 2>conftest.er1
16921   ac_status=$?
16922   grep -v '^ *+' conftest.er1 >conftest.err
16923   rm -f conftest.er1
16924   cat conftest.err >&5
16925   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16926   (exit $ac_status); } &&
16927          { ac_try='test -z "$ac_c_werror_flag"
16928                          || test ! -s conftest.err'
16929   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16930   (eval $ac_try) 2>&5
16931   ac_status=$?
16932   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16933   (exit $ac_status); }; } &&
16934          { ac_try='test -s conftest$ac_exeext'
16935   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16936   (eval $ac_try) 2>&5
16937   ac_status=$?
16938   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16939   (exit $ac_status); }; }; then
16940   ac_cv_lib_m_log10f=yes
16941 else
16942   echo "$as_me: failed program was:" >&5
16943 sed 's/^/| /' conftest.$ac_ext >&5
16944
16945 ac_cv_lib_m_log10f=no
16946 fi
16947 rm -f conftest.err conftest.$ac_objext \
16948       conftest$ac_exeext conftest.$ac_ext
16949 LIBS=$ac_check_lib_save_LIBS
16950 fi
16951 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10f" >&5
16952 echo "${ECHO_T}$ac_cv_lib_m_log10f" >&6
16953 if test $ac_cv_lib_m_log10f = yes; then
16954
16955 cat >>confdefs.h <<\_ACEOF
16956 #define HAVE_LOG10F 1
16957 _ACEOF
16958
16959 fi
16960
16961 echo "$as_me:$LINENO: checking for log10 in -lm" >&5
16962 echo $ECHO_N "checking for log10 in -lm... $ECHO_C" >&6
16963 if test "${ac_cv_lib_m_log10+set}" = set; then
16964   echo $ECHO_N "(cached) $ECHO_C" >&6
16965 else
16966   ac_check_lib_save_LIBS=$LIBS
16967 LIBS="-lm  $LIBS"
16968 if test x$gcc_no_link = xyes; then
16969   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16970 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16971    { (exit 1); exit 1; }; }
16972 fi
16973 cat >conftest.$ac_ext <<_ACEOF
16974 /* confdefs.h.  */
16975 _ACEOF
16976 cat confdefs.h >>conftest.$ac_ext
16977 cat >>conftest.$ac_ext <<_ACEOF
16978 /* end confdefs.h.  */
16979
16980 /* Override any gcc2 internal prototype to avoid an error.  */
16981 #ifdef __cplusplus
16982 extern "C"
16983 #endif
16984 /* We use char because int might match the return type of a gcc2
16985    builtin and then its argument prototype would still apply.  */
16986 char log10 ();
16987 int
16988 main ()
16989 {
16990 log10 ();
16991   ;
16992   return 0;
16993 }
16994 _ACEOF
16995 rm -f conftest.$ac_objext conftest$ac_exeext
16996 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16997   (eval $ac_link) 2>conftest.er1
16998   ac_status=$?
16999   grep -v '^ *+' conftest.er1 >conftest.err
17000   rm -f conftest.er1
17001   cat conftest.err >&5
17002   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17003   (exit $ac_status); } &&
17004          { ac_try='test -z "$ac_c_werror_flag"
17005                          || test ! -s conftest.err'
17006   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17007   (eval $ac_try) 2>&5
17008   ac_status=$?
17009   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17010   (exit $ac_status); }; } &&
17011          { ac_try='test -s conftest$ac_exeext'
17012   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17013   (eval $ac_try) 2>&5
17014   ac_status=$?
17015   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17016   (exit $ac_status); }; }; then
17017   ac_cv_lib_m_log10=yes
17018 else
17019   echo "$as_me: failed program was:" >&5
17020 sed 's/^/| /' conftest.$ac_ext >&5
17021
17022 ac_cv_lib_m_log10=no
17023 fi
17024 rm -f conftest.err conftest.$ac_objext \
17025       conftest$ac_exeext conftest.$ac_ext
17026 LIBS=$ac_check_lib_save_LIBS
17027 fi
17028 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10" >&5
17029 echo "${ECHO_T}$ac_cv_lib_m_log10" >&6
17030 if test $ac_cv_lib_m_log10 = yes; then
17031
17032 cat >>confdefs.h <<\_ACEOF
17033 #define HAVE_LOG10 1
17034 _ACEOF
17035
17036 fi
17037
17038 echo "$as_me:$LINENO: checking for log10l in -lm" >&5
17039 echo $ECHO_N "checking for log10l in -lm... $ECHO_C" >&6
17040 if test "${ac_cv_lib_m_log10l+set}" = set; then
17041   echo $ECHO_N "(cached) $ECHO_C" >&6
17042 else
17043   ac_check_lib_save_LIBS=$LIBS
17044 LIBS="-lm  $LIBS"
17045 if test x$gcc_no_link = xyes; then
17046   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17047 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17048    { (exit 1); exit 1; }; }
17049 fi
17050 cat >conftest.$ac_ext <<_ACEOF
17051 /* confdefs.h.  */
17052 _ACEOF
17053 cat confdefs.h >>conftest.$ac_ext
17054 cat >>conftest.$ac_ext <<_ACEOF
17055 /* end confdefs.h.  */
17056
17057 /* Override any gcc2 internal prototype to avoid an error.  */
17058 #ifdef __cplusplus
17059 extern "C"
17060 #endif
17061 /* We use char because int might match the return type of a gcc2
17062    builtin and then its argument prototype would still apply.  */
17063 char log10l ();
17064 int
17065 main ()
17066 {
17067 log10l ();
17068   ;
17069   return 0;
17070 }
17071 _ACEOF
17072 rm -f conftest.$ac_objext conftest$ac_exeext
17073 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17074   (eval $ac_link) 2>conftest.er1
17075   ac_status=$?
17076   grep -v '^ *+' conftest.er1 >conftest.err
17077   rm -f conftest.er1
17078   cat conftest.err >&5
17079   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17080   (exit $ac_status); } &&
17081          { ac_try='test -z "$ac_c_werror_flag"
17082                          || test ! -s conftest.err'
17083   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17084   (eval $ac_try) 2>&5
17085   ac_status=$?
17086   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17087   (exit $ac_status); }; } &&
17088          { ac_try='test -s conftest$ac_exeext'
17089   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17090   (eval $ac_try) 2>&5
17091   ac_status=$?
17092   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17093   (exit $ac_status); }; }; then
17094   ac_cv_lib_m_log10l=yes
17095 else
17096   echo "$as_me: failed program was:" >&5
17097 sed 's/^/| /' conftest.$ac_ext >&5
17098
17099 ac_cv_lib_m_log10l=no
17100 fi
17101 rm -f conftest.err conftest.$ac_objext \
17102       conftest$ac_exeext conftest.$ac_ext
17103 LIBS=$ac_check_lib_save_LIBS
17104 fi
17105 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10l" >&5
17106 echo "${ECHO_T}$ac_cv_lib_m_log10l" >&6
17107 if test $ac_cv_lib_m_log10l = yes; then
17108
17109 cat >>confdefs.h <<\_ACEOF
17110 #define HAVE_LOG10L 1
17111 _ACEOF
17112
17113 fi
17114
17115 echo "$as_me:$LINENO: checking for clog10f in -lm" >&5
17116 echo $ECHO_N "checking for clog10f in -lm... $ECHO_C" >&6
17117 if test "${ac_cv_lib_m_clog10f+set}" = set; then
17118   echo $ECHO_N "(cached) $ECHO_C" >&6
17119 else
17120   ac_check_lib_save_LIBS=$LIBS
17121 LIBS="-lm  $LIBS"
17122 if test x$gcc_no_link = xyes; then
17123   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17124 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17125    { (exit 1); exit 1; }; }
17126 fi
17127 cat >conftest.$ac_ext <<_ACEOF
17128 /* confdefs.h.  */
17129 _ACEOF
17130 cat confdefs.h >>conftest.$ac_ext
17131 cat >>conftest.$ac_ext <<_ACEOF
17132 /* end confdefs.h.  */
17133
17134 /* Override any gcc2 internal prototype to avoid an error.  */
17135 #ifdef __cplusplus
17136 extern "C"
17137 #endif
17138 /* We use char because int might match the return type of a gcc2
17139    builtin and then its argument prototype would still apply.  */
17140 char clog10f ();
17141 int
17142 main ()
17143 {
17144 clog10f ();
17145   ;
17146   return 0;
17147 }
17148 _ACEOF
17149 rm -f conftest.$ac_objext conftest$ac_exeext
17150 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17151   (eval $ac_link) 2>conftest.er1
17152   ac_status=$?
17153   grep -v '^ *+' conftest.er1 >conftest.err
17154   rm -f conftest.er1
17155   cat conftest.err >&5
17156   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17157   (exit $ac_status); } &&
17158          { ac_try='test -z "$ac_c_werror_flag"
17159                          || test ! -s conftest.err'
17160   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17161   (eval $ac_try) 2>&5
17162   ac_status=$?
17163   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17164   (exit $ac_status); }; } &&
17165          { ac_try='test -s conftest$ac_exeext'
17166   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17167   (eval $ac_try) 2>&5
17168   ac_status=$?
17169   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17170   (exit $ac_status); }; }; then
17171   ac_cv_lib_m_clog10f=yes
17172 else
17173   echo "$as_me: failed program was:" >&5
17174 sed 's/^/| /' conftest.$ac_ext >&5
17175
17176 ac_cv_lib_m_clog10f=no
17177 fi
17178 rm -f conftest.err conftest.$ac_objext \
17179       conftest$ac_exeext conftest.$ac_ext
17180 LIBS=$ac_check_lib_save_LIBS
17181 fi
17182 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10f" >&5
17183 echo "${ECHO_T}$ac_cv_lib_m_clog10f" >&6
17184 if test $ac_cv_lib_m_clog10f = yes; then
17185
17186 cat >>confdefs.h <<\_ACEOF
17187 #define HAVE_CLOG10F 1
17188 _ACEOF
17189
17190 fi
17191
17192 echo "$as_me:$LINENO: checking for clog10 in -lm" >&5
17193 echo $ECHO_N "checking for clog10 in -lm... $ECHO_C" >&6
17194 if test "${ac_cv_lib_m_clog10+set}" = set; then
17195   echo $ECHO_N "(cached) $ECHO_C" >&6
17196 else
17197   ac_check_lib_save_LIBS=$LIBS
17198 LIBS="-lm  $LIBS"
17199 if test x$gcc_no_link = xyes; then
17200   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17201 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17202    { (exit 1); exit 1; }; }
17203 fi
17204 cat >conftest.$ac_ext <<_ACEOF
17205 /* confdefs.h.  */
17206 _ACEOF
17207 cat confdefs.h >>conftest.$ac_ext
17208 cat >>conftest.$ac_ext <<_ACEOF
17209 /* end confdefs.h.  */
17210
17211 /* Override any gcc2 internal prototype to avoid an error.  */
17212 #ifdef __cplusplus
17213 extern "C"
17214 #endif
17215 /* We use char because int might match the return type of a gcc2
17216    builtin and then its argument prototype would still apply.  */
17217 char clog10 ();
17218 int
17219 main ()
17220 {
17221 clog10 ();
17222   ;
17223   return 0;
17224 }
17225 _ACEOF
17226 rm -f conftest.$ac_objext conftest$ac_exeext
17227 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17228   (eval $ac_link) 2>conftest.er1
17229   ac_status=$?
17230   grep -v '^ *+' conftest.er1 >conftest.err
17231   rm -f conftest.er1
17232   cat conftest.err >&5
17233   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17234   (exit $ac_status); } &&
17235          { ac_try='test -z "$ac_c_werror_flag"
17236                          || test ! -s conftest.err'
17237   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17238   (eval $ac_try) 2>&5
17239   ac_status=$?
17240   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17241   (exit $ac_status); }; } &&
17242          { ac_try='test -s conftest$ac_exeext'
17243   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17244   (eval $ac_try) 2>&5
17245   ac_status=$?
17246   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17247   (exit $ac_status); }; }; then
17248   ac_cv_lib_m_clog10=yes
17249 else
17250   echo "$as_me: failed program was:" >&5
17251 sed 's/^/| /' conftest.$ac_ext >&5
17252
17253 ac_cv_lib_m_clog10=no
17254 fi
17255 rm -f conftest.err conftest.$ac_objext \
17256       conftest$ac_exeext conftest.$ac_ext
17257 LIBS=$ac_check_lib_save_LIBS
17258 fi
17259 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10" >&5
17260 echo "${ECHO_T}$ac_cv_lib_m_clog10" >&6
17261 if test $ac_cv_lib_m_clog10 = yes; then
17262
17263 cat >>confdefs.h <<\_ACEOF
17264 #define HAVE_CLOG10 1
17265 _ACEOF
17266
17267 fi
17268
17269 echo "$as_me:$LINENO: checking for clog10l in -lm" >&5
17270 echo $ECHO_N "checking for clog10l in -lm... $ECHO_C" >&6
17271 if test "${ac_cv_lib_m_clog10l+set}" = set; then
17272   echo $ECHO_N "(cached) $ECHO_C" >&6
17273 else
17274   ac_check_lib_save_LIBS=$LIBS
17275 LIBS="-lm  $LIBS"
17276 if test x$gcc_no_link = xyes; then
17277   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17278 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17279    { (exit 1); exit 1; }; }
17280 fi
17281 cat >conftest.$ac_ext <<_ACEOF
17282 /* confdefs.h.  */
17283 _ACEOF
17284 cat confdefs.h >>conftest.$ac_ext
17285 cat >>conftest.$ac_ext <<_ACEOF
17286 /* end confdefs.h.  */
17287
17288 /* Override any gcc2 internal prototype to avoid an error.  */
17289 #ifdef __cplusplus
17290 extern "C"
17291 #endif
17292 /* We use char because int might match the return type of a gcc2
17293    builtin and then its argument prototype would still apply.  */
17294 char clog10l ();
17295 int
17296 main ()
17297 {
17298 clog10l ();
17299   ;
17300   return 0;
17301 }
17302 _ACEOF
17303 rm -f conftest.$ac_objext conftest$ac_exeext
17304 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17305   (eval $ac_link) 2>conftest.er1
17306   ac_status=$?
17307   grep -v '^ *+' conftest.er1 >conftest.err
17308   rm -f conftest.er1
17309   cat conftest.err >&5
17310   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17311   (exit $ac_status); } &&
17312          { ac_try='test -z "$ac_c_werror_flag"
17313                          || test ! -s conftest.err'
17314   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17315   (eval $ac_try) 2>&5
17316   ac_status=$?
17317   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17318   (exit $ac_status); }; } &&
17319          { ac_try='test -s conftest$ac_exeext'
17320   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17321   (eval $ac_try) 2>&5
17322   ac_status=$?
17323   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17324   (exit $ac_status); }; }; then
17325   ac_cv_lib_m_clog10l=yes
17326 else
17327   echo "$as_me: failed program was:" >&5
17328 sed 's/^/| /' conftest.$ac_ext >&5
17329
17330 ac_cv_lib_m_clog10l=no
17331 fi
17332 rm -f conftest.err conftest.$ac_objext \
17333       conftest$ac_exeext conftest.$ac_ext
17334 LIBS=$ac_check_lib_save_LIBS
17335 fi
17336 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10l" >&5
17337 echo "${ECHO_T}$ac_cv_lib_m_clog10l" >&6
17338 if test $ac_cv_lib_m_clog10l = yes; then
17339
17340 cat >>confdefs.h <<\_ACEOF
17341 #define HAVE_CLOG10L 1
17342 _ACEOF
17343
17344 fi
17345
17346 echo "$as_me:$LINENO: checking for nextafterf in -lm" >&5
17347 echo $ECHO_N "checking for nextafterf in -lm... $ECHO_C" >&6
17348 if test "${ac_cv_lib_m_nextafterf+set}" = set; then
17349   echo $ECHO_N "(cached) $ECHO_C" >&6
17350 else
17351   ac_check_lib_save_LIBS=$LIBS
17352 LIBS="-lm  $LIBS"
17353 if test x$gcc_no_link = xyes; then
17354   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17355 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17356    { (exit 1); exit 1; }; }
17357 fi
17358 cat >conftest.$ac_ext <<_ACEOF
17359 /* confdefs.h.  */
17360 _ACEOF
17361 cat confdefs.h >>conftest.$ac_ext
17362 cat >>conftest.$ac_ext <<_ACEOF
17363 /* end confdefs.h.  */
17364
17365 /* Override any gcc2 internal prototype to avoid an error.  */
17366 #ifdef __cplusplus
17367 extern "C"
17368 #endif
17369 /* We use char because int might match the return type of a gcc2
17370    builtin and then its argument prototype would still apply.  */
17371 char nextafterf ();
17372 int
17373 main ()
17374 {
17375 nextafterf ();
17376   ;
17377   return 0;
17378 }
17379 _ACEOF
17380 rm -f conftest.$ac_objext conftest$ac_exeext
17381 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17382   (eval $ac_link) 2>conftest.er1
17383   ac_status=$?
17384   grep -v '^ *+' conftest.er1 >conftest.err
17385   rm -f conftest.er1
17386   cat conftest.err >&5
17387   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17388   (exit $ac_status); } &&
17389          { ac_try='test -z "$ac_c_werror_flag"
17390                          || test ! -s conftest.err'
17391   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17392   (eval $ac_try) 2>&5
17393   ac_status=$?
17394   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17395   (exit $ac_status); }; } &&
17396          { ac_try='test -s conftest$ac_exeext'
17397   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17398   (eval $ac_try) 2>&5
17399   ac_status=$?
17400   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17401   (exit $ac_status); }; }; then
17402   ac_cv_lib_m_nextafterf=yes
17403 else
17404   echo "$as_me: failed program was:" >&5
17405 sed 's/^/| /' conftest.$ac_ext >&5
17406
17407 ac_cv_lib_m_nextafterf=no
17408 fi
17409 rm -f conftest.err conftest.$ac_objext \
17410       conftest$ac_exeext conftest.$ac_ext
17411 LIBS=$ac_check_lib_save_LIBS
17412 fi
17413 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafterf" >&5
17414 echo "${ECHO_T}$ac_cv_lib_m_nextafterf" >&6
17415 if test $ac_cv_lib_m_nextafterf = yes; then
17416
17417 cat >>confdefs.h <<\_ACEOF
17418 #define HAVE_NEXTAFTERF 1
17419 _ACEOF
17420
17421 fi
17422
17423 echo "$as_me:$LINENO: checking for nextafter in -lm" >&5
17424 echo $ECHO_N "checking for nextafter in -lm... $ECHO_C" >&6
17425 if test "${ac_cv_lib_m_nextafter+set}" = set; then
17426   echo $ECHO_N "(cached) $ECHO_C" >&6
17427 else
17428   ac_check_lib_save_LIBS=$LIBS
17429 LIBS="-lm  $LIBS"
17430 if test x$gcc_no_link = xyes; then
17431   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17432 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17433    { (exit 1); exit 1; }; }
17434 fi
17435 cat >conftest.$ac_ext <<_ACEOF
17436 /* confdefs.h.  */
17437 _ACEOF
17438 cat confdefs.h >>conftest.$ac_ext
17439 cat >>conftest.$ac_ext <<_ACEOF
17440 /* end confdefs.h.  */
17441
17442 /* Override any gcc2 internal prototype to avoid an error.  */
17443 #ifdef __cplusplus
17444 extern "C"
17445 #endif
17446 /* We use char because int might match the return type of a gcc2
17447    builtin and then its argument prototype would still apply.  */
17448 char nextafter ();
17449 int
17450 main ()
17451 {
17452 nextafter ();
17453   ;
17454   return 0;
17455 }
17456 _ACEOF
17457 rm -f conftest.$ac_objext conftest$ac_exeext
17458 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17459   (eval $ac_link) 2>conftest.er1
17460   ac_status=$?
17461   grep -v '^ *+' conftest.er1 >conftest.err
17462   rm -f conftest.er1
17463   cat conftest.err >&5
17464   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17465   (exit $ac_status); } &&
17466          { ac_try='test -z "$ac_c_werror_flag"
17467                          || test ! -s conftest.err'
17468   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17469   (eval $ac_try) 2>&5
17470   ac_status=$?
17471   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17472   (exit $ac_status); }; } &&
17473          { ac_try='test -s conftest$ac_exeext'
17474   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17475   (eval $ac_try) 2>&5
17476   ac_status=$?
17477   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17478   (exit $ac_status); }; }; then
17479   ac_cv_lib_m_nextafter=yes
17480 else
17481   echo "$as_me: failed program was:" >&5
17482 sed 's/^/| /' conftest.$ac_ext >&5
17483
17484 ac_cv_lib_m_nextafter=no
17485 fi
17486 rm -f conftest.err conftest.$ac_objext \
17487       conftest$ac_exeext conftest.$ac_ext
17488 LIBS=$ac_check_lib_save_LIBS
17489 fi
17490 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafter" >&5
17491 echo "${ECHO_T}$ac_cv_lib_m_nextafter" >&6
17492 if test $ac_cv_lib_m_nextafter = yes; then
17493
17494 cat >>confdefs.h <<\_ACEOF
17495 #define HAVE_NEXTAFTER 1
17496 _ACEOF
17497
17498 fi
17499
17500 echo "$as_me:$LINENO: checking for nextafterl in -lm" >&5
17501 echo $ECHO_N "checking for nextafterl in -lm... $ECHO_C" >&6
17502 if test "${ac_cv_lib_m_nextafterl+set}" = set; then
17503   echo $ECHO_N "(cached) $ECHO_C" >&6
17504 else
17505   ac_check_lib_save_LIBS=$LIBS
17506 LIBS="-lm  $LIBS"
17507 if test x$gcc_no_link = xyes; then
17508   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17509 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17510    { (exit 1); exit 1; }; }
17511 fi
17512 cat >conftest.$ac_ext <<_ACEOF
17513 /* confdefs.h.  */
17514 _ACEOF
17515 cat confdefs.h >>conftest.$ac_ext
17516 cat >>conftest.$ac_ext <<_ACEOF
17517 /* end confdefs.h.  */
17518
17519 /* Override any gcc2 internal prototype to avoid an error.  */
17520 #ifdef __cplusplus
17521 extern "C"
17522 #endif
17523 /* We use char because int might match the return type of a gcc2
17524    builtin and then its argument prototype would still apply.  */
17525 char nextafterl ();
17526 int
17527 main ()
17528 {
17529 nextafterl ();
17530   ;
17531   return 0;
17532 }
17533 _ACEOF
17534 rm -f conftest.$ac_objext conftest$ac_exeext
17535 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17536   (eval $ac_link) 2>conftest.er1
17537   ac_status=$?
17538   grep -v '^ *+' conftest.er1 >conftest.err
17539   rm -f conftest.er1
17540   cat conftest.err >&5
17541   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17542   (exit $ac_status); } &&
17543          { ac_try='test -z "$ac_c_werror_flag"
17544                          || test ! -s conftest.err'
17545   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17546   (eval $ac_try) 2>&5
17547   ac_status=$?
17548   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17549   (exit $ac_status); }; } &&
17550          { ac_try='test -s conftest$ac_exeext'
17551   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17552   (eval $ac_try) 2>&5
17553   ac_status=$?
17554   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17555   (exit $ac_status); }; }; then
17556   ac_cv_lib_m_nextafterl=yes
17557 else
17558   echo "$as_me: failed program was:" >&5
17559 sed 's/^/| /' conftest.$ac_ext >&5
17560
17561 ac_cv_lib_m_nextafterl=no
17562 fi
17563 rm -f conftest.err conftest.$ac_objext \
17564       conftest$ac_exeext conftest.$ac_ext
17565 LIBS=$ac_check_lib_save_LIBS
17566 fi
17567 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafterl" >&5
17568 echo "${ECHO_T}$ac_cv_lib_m_nextafterl" >&6
17569 if test $ac_cv_lib_m_nextafterl = yes; then
17570
17571 cat >>confdefs.h <<\_ACEOF
17572 #define HAVE_NEXTAFTERL 1
17573 _ACEOF
17574
17575 fi
17576
17577 echo "$as_me:$LINENO: checking for powf in -lm" >&5
17578 echo $ECHO_N "checking for powf in -lm... $ECHO_C" >&6
17579 if test "${ac_cv_lib_m_powf+set}" = set; then
17580   echo $ECHO_N "(cached) $ECHO_C" >&6
17581 else
17582   ac_check_lib_save_LIBS=$LIBS
17583 LIBS="-lm  $LIBS"
17584 if test x$gcc_no_link = xyes; then
17585   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17586 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17587    { (exit 1); exit 1; }; }
17588 fi
17589 cat >conftest.$ac_ext <<_ACEOF
17590 /* confdefs.h.  */
17591 _ACEOF
17592 cat confdefs.h >>conftest.$ac_ext
17593 cat >>conftest.$ac_ext <<_ACEOF
17594 /* end confdefs.h.  */
17595
17596 /* Override any gcc2 internal prototype to avoid an error.  */
17597 #ifdef __cplusplus
17598 extern "C"
17599 #endif
17600 /* We use char because int might match the return type of a gcc2
17601    builtin and then its argument prototype would still apply.  */
17602 char powf ();
17603 int
17604 main ()
17605 {
17606 powf ();
17607   ;
17608   return 0;
17609 }
17610 _ACEOF
17611 rm -f conftest.$ac_objext conftest$ac_exeext
17612 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17613   (eval $ac_link) 2>conftest.er1
17614   ac_status=$?
17615   grep -v '^ *+' conftest.er1 >conftest.err
17616   rm -f conftest.er1
17617   cat conftest.err >&5
17618   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17619   (exit $ac_status); } &&
17620          { ac_try='test -z "$ac_c_werror_flag"
17621                          || test ! -s conftest.err'
17622   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17623   (eval $ac_try) 2>&5
17624   ac_status=$?
17625   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17626   (exit $ac_status); }; } &&
17627          { ac_try='test -s conftest$ac_exeext'
17628   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17629   (eval $ac_try) 2>&5
17630   ac_status=$?
17631   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17632   (exit $ac_status); }; }; then
17633   ac_cv_lib_m_powf=yes
17634 else
17635   echo "$as_me: failed program was:" >&5
17636 sed 's/^/| /' conftest.$ac_ext >&5
17637
17638 ac_cv_lib_m_powf=no
17639 fi
17640 rm -f conftest.err conftest.$ac_objext \
17641       conftest$ac_exeext conftest.$ac_ext
17642 LIBS=$ac_check_lib_save_LIBS
17643 fi
17644 echo "$as_me:$LINENO: result: $ac_cv_lib_m_powf" >&5
17645 echo "${ECHO_T}$ac_cv_lib_m_powf" >&6
17646 if test $ac_cv_lib_m_powf = yes; then
17647
17648 cat >>confdefs.h <<\_ACEOF
17649 #define HAVE_POWF 1
17650 _ACEOF
17651
17652 fi
17653
17654 echo "$as_me:$LINENO: checking for pow in -lm" >&5
17655 echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
17656 if test "${ac_cv_lib_m_pow+set}" = set; then
17657   echo $ECHO_N "(cached) $ECHO_C" >&6
17658 else
17659   ac_check_lib_save_LIBS=$LIBS
17660 LIBS="-lm  $LIBS"
17661 if test x$gcc_no_link = xyes; then
17662   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17663 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17664    { (exit 1); exit 1; }; }
17665 fi
17666 cat >conftest.$ac_ext <<_ACEOF
17667 /* confdefs.h.  */
17668 _ACEOF
17669 cat confdefs.h >>conftest.$ac_ext
17670 cat >>conftest.$ac_ext <<_ACEOF
17671 /* end confdefs.h.  */
17672
17673 /* Override any gcc2 internal prototype to avoid an error.  */
17674 #ifdef __cplusplus
17675 extern "C"
17676 #endif
17677 /* We use char because int might match the return type of a gcc2
17678    builtin and then its argument prototype would still apply.  */
17679 char pow ();
17680 int
17681 main ()
17682 {
17683 pow ();
17684   ;
17685   return 0;
17686 }
17687 _ACEOF
17688 rm -f conftest.$ac_objext conftest$ac_exeext
17689 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17690   (eval $ac_link) 2>conftest.er1
17691   ac_status=$?
17692   grep -v '^ *+' conftest.er1 >conftest.err
17693   rm -f conftest.er1
17694   cat conftest.err >&5
17695   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17696   (exit $ac_status); } &&
17697          { ac_try='test -z "$ac_c_werror_flag"
17698                          || test ! -s conftest.err'
17699   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17700   (eval $ac_try) 2>&5
17701   ac_status=$?
17702   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17703   (exit $ac_status); }; } &&
17704          { ac_try='test -s conftest$ac_exeext'
17705   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17706   (eval $ac_try) 2>&5
17707   ac_status=$?
17708   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17709   (exit $ac_status); }; }; then
17710   ac_cv_lib_m_pow=yes
17711 else
17712   echo "$as_me: failed program was:" >&5
17713 sed 's/^/| /' conftest.$ac_ext >&5
17714
17715 ac_cv_lib_m_pow=no
17716 fi
17717 rm -f conftest.err conftest.$ac_objext \
17718       conftest$ac_exeext conftest.$ac_ext
17719 LIBS=$ac_check_lib_save_LIBS
17720 fi
17721 echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
17722 echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
17723 if test $ac_cv_lib_m_pow = yes; then
17724
17725 cat >>confdefs.h <<\_ACEOF
17726 #define HAVE_POW 1
17727 _ACEOF
17728
17729 fi
17730
17731 echo "$as_me:$LINENO: checking for powl in -lm" >&5
17732 echo $ECHO_N "checking for powl in -lm... $ECHO_C" >&6
17733 if test "${ac_cv_lib_m_powl+set}" = set; then
17734   echo $ECHO_N "(cached) $ECHO_C" >&6
17735 else
17736   ac_check_lib_save_LIBS=$LIBS
17737 LIBS="-lm  $LIBS"
17738 if test x$gcc_no_link = xyes; then
17739   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17740 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17741    { (exit 1); exit 1; }; }
17742 fi
17743 cat >conftest.$ac_ext <<_ACEOF
17744 /* confdefs.h.  */
17745 _ACEOF
17746 cat confdefs.h >>conftest.$ac_ext
17747 cat >>conftest.$ac_ext <<_ACEOF
17748 /* end confdefs.h.  */
17749
17750 /* Override any gcc2 internal prototype to avoid an error.  */
17751 #ifdef __cplusplus
17752 extern "C"
17753 #endif
17754 /* We use char because int might match the return type of a gcc2
17755    builtin and then its argument prototype would still apply.  */
17756 char powl ();
17757 int
17758 main ()
17759 {
17760 powl ();
17761   ;
17762   return 0;
17763 }
17764 _ACEOF
17765 rm -f conftest.$ac_objext conftest$ac_exeext
17766 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17767   (eval $ac_link) 2>conftest.er1
17768   ac_status=$?
17769   grep -v '^ *+' conftest.er1 >conftest.err
17770   rm -f conftest.er1
17771   cat conftest.err >&5
17772   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17773   (exit $ac_status); } &&
17774          { ac_try='test -z "$ac_c_werror_flag"
17775                          || test ! -s conftest.err'
17776   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17777   (eval $ac_try) 2>&5
17778   ac_status=$?
17779   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17780   (exit $ac_status); }; } &&
17781          { ac_try='test -s conftest$ac_exeext'
17782   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17783   (eval $ac_try) 2>&5
17784   ac_status=$?
17785   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17786   (exit $ac_status); }; }; then
17787   ac_cv_lib_m_powl=yes
17788 else
17789   echo "$as_me: failed program was:" >&5
17790 sed 's/^/| /' conftest.$ac_ext >&5
17791
17792 ac_cv_lib_m_powl=no
17793 fi
17794 rm -f conftest.err conftest.$ac_objext \
17795       conftest$ac_exeext conftest.$ac_ext
17796 LIBS=$ac_check_lib_save_LIBS
17797 fi
17798 echo "$as_me:$LINENO: result: $ac_cv_lib_m_powl" >&5
17799 echo "${ECHO_T}$ac_cv_lib_m_powl" >&6
17800 if test $ac_cv_lib_m_powl = yes; then
17801
17802 cat >>confdefs.h <<\_ACEOF
17803 #define HAVE_POWL 1
17804 _ACEOF
17805
17806 fi
17807
17808 echo "$as_me:$LINENO: checking for cpowf in -lm" >&5
17809 echo $ECHO_N "checking for cpowf in -lm... $ECHO_C" >&6
17810 if test "${ac_cv_lib_m_cpowf+set}" = set; then
17811   echo $ECHO_N "(cached) $ECHO_C" >&6
17812 else
17813   ac_check_lib_save_LIBS=$LIBS
17814 LIBS="-lm  $LIBS"
17815 if test x$gcc_no_link = xyes; then
17816   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17817 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17818    { (exit 1); exit 1; }; }
17819 fi
17820 cat >conftest.$ac_ext <<_ACEOF
17821 /* confdefs.h.  */
17822 _ACEOF
17823 cat confdefs.h >>conftest.$ac_ext
17824 cat >>conftest.$ac_ext <<_ACEOF
17825 /* end confdefs.h.  */
17826
17827 /* Override any gcc2 internal prototype to avoid an error.  */
17828 #ifdef __cplusplus
17829 extern "C"
17830 #endif
17831 /* We use char because int might match the return type of a gcc2
17832    builtin and then its argument prototype would still apply.  */
17833 char cpowf ();
17834 int
17835 main ()
17836 {
17837 cpowf ();
17838   ;
17839   return 0;
17840 }
17841 _ACEOF
17842 rm -f conftest.$ac_objext conftest$ac_exeext
17843 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17844   (eval $ac_link) 2>conftest.er1
17845   ac_status=$?
17846   grep -v '^ *+' conftest.er1 >conftest.err
17847   rm -f conftest.er1
17848   cat conftest.err >&5
17849   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17850   (exit $ac_status); } &&
17851          { ac_try='test -z "$ac_c_werror_flag"
17852                          || test ! -s conftest.err'
17853   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17854   (eval $ac_try) 2>&5
17855   ac_status=$?
17856   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17857   (exit $ac_status); }; } &&
17858          { ac_try='test -s conftest$ac_exeext'
17859   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17860   (eval $ac_try) 2>&5
17861   ac_status=$?
17862   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17863   (exit $ac_status); }; }; then
17864   ac_cv_lib_m_cpowf=yes
17865 else
17866   echo "$as_me: failed program was:" >&5
17867 sed 's/^/| /' conftest.$ac_ext >&5
17868
17869 ac_cv_lib_m_cpowf=no
17870 fi
17871 rm -f conftest.err conftest.$ac_objext \
17872       conftest$ac_exeext conftest.$ac_ext
17873 LIBS=$ac_check_lib_save_LIBS
17874 fi
17875 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpowf" >&5
17876 echo "${ECHO_T}$ac_cv_lib_m_cpowf" >&6
17877 if test $ac_cv_lib_m_cpowf = yes; then
17878
17879 cat >>confdefs.h <<\_ACEOF
17880 #define HAVE_CPOWF 1
17881 _ACEOF
17882
17883 fi
17884
17885 echo "$as_me:$LINENO: checking for cpow in -lm" >&5
17886 echo $ECHO_N "checking for cpow in -lm... $ECHO_C" >&6
17887 if test "${ac_cv_lib_m_cpow+set}" = set; then
17888   echo $ECHO_N "(cached) $ECHO_C" >&6
17889 else
17890   ac_check_lib_save_LIBS=$LIBS
17891 LIBS="-lm  $LIBS"
17892 if test x$gcc_no_link = xyes; then
17893   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17894 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17895    { (exit 1); exit 1; }; }
17896 fi
17897 cat >conftest.$ac_ext <<_ACEOF
17898 /* confdefs.h.  */
17899 _ACEOF
17900 cat confdefs.h >>conftest.$ac_ext
17901 cat >>conftest.$ac_ext <<_ACEOF
17902 /* end confdefs.h.  */
17903
17904 /* Override any gcc2 internal prototype to avoid an error.  */
17905 #ifdef __cplusplus
17906 extern "C"
17907 #endif
17908 /* We use char because int might match the return type of a gcc2
17909    builtin and then its argument prototype would still apply.  */
17910 char cpow ();
17911 int
17912 main ()
17913 {
17914 cpow ();
17915   ;
17916   return 0;
17917 }
17918 _ACEOF
17919 rm -f conftest.$ac_objext conftest$ac_exeext
17920 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17921   (eval $ac_link) 2>conftest.er1
17922   ac_status=$?
17923   grep -v '^ *+' conftest.er1 >conftest.err
17924   rm -f conftest.er1
17925   cat conftest.err >&5
17926   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17927   (exit $ac_status); } &&
17928          { ac_try='test -z "$ac_c_werror_flag"
17929                          || test ! -s conftest.err'
17930   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17931   (eval $ac_try) 2>&5
17932   ac_status=$?
17933   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17934   (exit $ac_status); }; } &&
17935          { ac_try='test -s conftest$ac_exeext'
17936   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17937   (eval $ac_try) 2>&5
17938   ac_status=$?
17939   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17940   (exit $ac_status); }; }; then
17941   ac_cv_lib_m_cpow=yes
17942 else
17943   echo "$as_me: failed program was:" >&5
17944 sed 's/^/| /' conftest.$ac_ext >&5
17945
17946 ac_cv_lib_m_cpow=no
17947 fi
17948 rm -f conftest.err conftest.$ac_objext \
17949       conftest$ac_exeext conftest.$ac_ext
17950 LIBS=$ac_check_lib_save_LIBS
17951 fi
17952 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpow" >&5
17953 echo "${ECHO_T}$ac_cv_lib_m_cpow" >&6
17954 if test $ac_cv_lib_m_cpow = yes; then
17955
17956 cat >>confdefs.h <<\_ACEOF
17957 #define HAVE_CPOW 1
17958 _ACEOF
17959
17960 fi
17961
17962 echo "$as_me:$LINENO: checking for cpowl in -lm" >&5
17963 echo $ECHO_N "checking for cpowl in -lm... $ECHO_C" >&6
17964 if test "${ac_cv_lib_m_cpowl+set}" = set; then
17965   echo $ECHO_N "(cached) $ECHO_C" >&6
17966 else
17967   ac_check_lib_save_LIBS=$LIBS
17968 LIBS="-lm  $LIBS"
17969 if test x$gcc_no_link = xyes; then
17970   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17971 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17972    { (exit 1); exit 1; }; }
17973 fi
17974 cat >conftest.$ac_ext <<_ACEOF
17975 /* confdefs.h.  */
17976 _ACEOF
17977 cat confdefs.h >>conftest.$ac_ext
17978 cat >>conftest.$ac_ext <<_ACEOF
17979 /* end confdefs.h.  */
17980
17981 /* Override any gcc2 internal prototype to avoid an error.  */
17982 #ifdef __cplusplus
17983 extern "C"
17984 #endif
17985 /* We use char because int might match the return type of a gcc2
17986    builtin and then its argument prototype would still apply.  */
17987 char cpowl ();
17988 int
17989 main ()
17990 {
17991 cpowl ();
17992   ;
17993   return 0;
17994 }
17995 _ACEOF
17996 rm -f conftest.$ac_objext conftest$ac_exeext
17997 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17998   (eval $ac_link) 2>conftest.er1
17999   ac_status=$?
18000   grep -v '^ *+' conftest.er1 >conftest.err
18001   rm -f conftest.er1
18002   cat conftest.err >&5
18003   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18004   (exit $ac_status); } &&
18005          { ac_try='test -z "$ac_c_werror_flag"
18006                          || test ! -s conftest.err'
18007   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18008   (eval $ac_try) 2>&5
18009   ac_status=$?
18010   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18011   (exit $ac_status); }; } &&
18012          { ac_try='test -s conftest$ac_exeext'
18013   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18014   (eval $ac_try) 2>&5
18015   ac_status=$?
18016   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18017   (exit $ac_status); }; }; then
18018   ac_cv_lib_m_cpowl=yes
18019 else
18020   echo "$as_me: failed program was:" >&5
18021 sed 's/^/| /' conftest.$ac_ext >&5
18022
18023 ac_cv_lib_m_cpowl=no
18024 fi
18025 rm -f conftest.err conftest.$ac_objext \
18026       conftest$ac_exeext conftest.$ac_ext
18027 LIBS=$ac_check_lib_save_LIBS
18028 fi
18029 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpowl" >&5
18030 echo "${ECHO_T}$ac_cv_lib_m_cpowl" >&6
18031 if test $ac_cv_lib_m_cpowl = yes; then
18032
18033 cat >>confdefs.h <<\_ACEOF
18034 #define HAVE_CPOWL 1
18035 _ACEOF
18036
18037 fi
18038
18039 echo "$as_me:$LINENO: checking for roundf in -lm" >&5
18040 echo $ECHO_N "checking for roundf in -lm... $ECHO_C" >&6
18041 if test "${ac_cv_lib_m_roundf+set}" = set; then
18042   echo $ECHO_N "(cached) $ECHO_C" >&6
18043 else
18044   ac_check_lib_save_LIBS=$LIBS
18045 LIBS="-lm  $LIBS"
18046 if test x$gcc_no_link = xyes; then
18047   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18048 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18049    { (exit 1); exit 1; }; }
18050 fi
18051 cat >conftest.$ac_ext <<_ACEOF
18052 /* confdefs.h.  */
18053 _ACEOF
18054 cat confdefs.h >>conftest.$ac_ext
18055 cat >>conftest.$ac_ext <<_ACEOF
18056 /* end confdefs.h.  */
18057
18058 /* Override any gcc2 internal prototype to avoid an error.  */
18059 #ifdef __cplusplus
18060 extern "C"
18061 #endif
18062 /* We use char because int might match the return type of a gcc2
18063    builtin and then its argument prototype would still apply.  */
18064 char roundf ();
18065 int
18066 main ()
18067 {
18068 roundf ();
18069   ;
18070   return 0;
18071 }
18072 _ACEOF
18073 rm -f conftest.$ac_objext conftest$ac_exeext
18074 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18075   (eval $ac_link) 2>conftest.er1
18076   ac_status=$?
18077   grep -v '^ *+' conftest.er1 >conftest.err
18078   rm -f conftest.er1
18079   cat conftest.err >&5
18080   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18081   (exit $ac_status); } &&
18082          { ac_try='test -z "$ac_c_werror_flag"
18083                          || test ! -s conftest.err'
18084   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18085   (eval $ac_try) 2>&5
18086   ac_status=$?
18087   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18088   (exit $ac_status); }; } &&
18089          { ac_try='test -s conftest$ac_exeext'
18090   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18091   (eval $ac_try) 2>&5
18092   ac_status=$?
18093   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18094   (exit $ac_status); }; }; then
18095   ac_cv_lib_m_roundf=yes
18096 else
18097   echo "$as_me: failed program was:" >&5
18098 sed 's/^/| /' conftest.$ac_ext >&5
18099
18100 ac_cv_lib_m_roundf=no
18101 fi
18102 rm -f conftest.err conftest.$ac_objext \
18103       conftest$ac_exeext conftest.$ac_ext
18104 LIBS=$ac_check_lib_save_LIBS
18105 fi
18106 echo "$as_me:$LINENO: result: $ac_cv_lib_m_roundf" >&5
18107 echo "${ECHO_T}$ac_cv_lib_m_roundf" >&6
18108 if test $ac_cv_lib_m_roundf = yes; then
18109
18110 cat >>confdefs.h <<\_ACEOF
18111 #define HAVE_ROUNDF 1
18112 _ACEOF
18113
18114 fi
18115
18116 echo "$as_me:$LINENO: checking for round in -lm" >&5
18117 echo $ECHO_N "checking for round in -lm... $ECHO_C" >&6
18118 if test "${ac_cv_lib_m_round+set}" = set; then
18119   echo $ECHO_N "(cached) $ECHO_C" >&6
18120 else
18121   ac_check_lib_save_LIBS=$LIBS
18122 LIBS="-lm  $LIBS"
18123 if test x$gcc_no_link = xyes; then
18124   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18125 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18126    { (exit 1); exit 1; }; }
18127 fi
18128 cat >conftest.$ac_ext <<_ACEOF
18129 /* confdefs.h.  */
18130 _ACEOF
18131 cat confdefs.h >>conftest.$ac_ext
18132 cat >>conftest.$ac_ext <<_ACEOF
18133 /* end confdefs.h.  */
18134
18135 /* Override any gcc2 internal prototype to avoid an error.  */
18136 #ifdef __cplusplus
18137 extern "C"
18138 #endif
18139 /* We use char because int might match the return type of a gcc2
18140    builtin and then its argument prototype would still apply.  */
18141 char round ();
18142 int
18143 main ()
18144 {
18145 round ();
18146   ;
18147   return 0;
18148 }
18149 _ACEOF
18150 rm -f conftest.$ac_objext conftest$ac_exeext
18151 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18152   (eval $ac_link) 2>conftest.er1
18153   ac_status=$?
18154   grep -v '^ *+' conftest.er1 >conftest.err
18155   rm -f conftest.er1
18156   cat conftest.err >&5
18157   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18158   (exit $ac_status); } &&
18159          { ac_try='test -z "$ac_c_werror_flag"
18160                          || test ! -s conftest.err'
18161   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18162   (eval $ac_try) 2>&5
18163   ac_status=$?
18164   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18165   (exit $ac_status); }; } &&
18166          { ac_try='test -s conftest$ac_exeext'
18167   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18168   (eval $ac_try) 2>&5
18169   ac_status=$?
18170   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18171   (exit $ac_status); }; }; then
18172   ac_cv_lib_m_round=yes
18173 else
18174   echo "$as_me: failed program was:" >&5
18175 sed 's/^/| /' conftest.$ac_ext >&5
18176
18177 ac_cv_lib_m_round=no
18178 fi
18179 rm -f conftest.err conftest.$ac_objext \
18180       conftest$ac_exeext conftest.$ac_ext
18181 LIBS=$ac_check_lib_save_LIBS
18182 fi
18183 echo "$as_me:$LINENO: result: $ac_cv_lib_m_round" >&5
18184 echo "${ECHO_T}$ac_cv_lib_m_round" >&6
18185 if test $ac_cv_lib_m_round = yes; then
18186
18187 cat >>confdefs.h <<\_ACEOF
18188 #define HAVE_ROUND 1
18189 _ACEOF
18190
18191 fi
18192
18193 echo "$as_me:$LINENO: checking for roundl in -lm" >&5
18194 echo $ECHO_N "checking for roundl in -lm... $ECHO_C" >&6
18195 if test "${ac_cv_lib_m_roundl+set}" = set; then
18196   echo $ECHO_N "(cached) $ECHO_C" >&6
18197 else
18198   ac_check_lib_save_LIBS=$LIBS
18199 LIBS="-lm  $LIBS"
18200 if test x$gcc_no_link = xyes; then
18201   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18202 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18203    { (exit 1); exit 1; }; }
18204 fi
18205 cat >conftest.$ac_ext <<_ACEOF
18206 /* confdefs.h.  */
18207 _ACEOF
18208 cat confdefs.h >>conftest.$ac_ext
18209 cat >>conftest.$ac_ext <<_ACEOF
18210 /* end confdefs.h.  */
18211
18212 /* Override any gcc2 internal prototype to avoid an error.  */
18213 #ifdef __cplusplus
18214 extern "C"
18215 #endif
18216 /* We use char because int might match the return type of a gcc2
18217    builtin and then its argument prototype would still apply.  */
18218 char roundl ();
18219 int
18220 main ()
18221 {
18222 roundl ();
18223   ;
18224   return 0;
18225 }
18226 _ACEOF
18227 rm -f conftest.$ac_objext conftest$ac_exeext
18228 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18229   (eval $ac_link) 2>conftest.er1
18230   ac_status=$?
18231   grep -v '^ *+' conftest.er1 >conftest.err
18232   rm -f conftest.er1
18233   cat conftest.err >&5
18234   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18235   (exit $ac_status); } &&
18236          { ac_try='test -z "$ac_c_werror_flag"
18237                          || test ! -s conftest.err'
18238   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18239   (eval $ac_try) 2>&5
18240   ac_status=$?
18241   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18242   (exit $ac_status); }; } &&
18243          { ac_try='test -s conftest$ac_exeext'
18244   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18245   (eval $ac_try) 2>&5
18246   ac_status=$?
18247   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18248   (exit $ac_status); }; }; then
18249   ac_cv_lib_m_roundl=yes
18250 else
18251   echo "$as_me: failed program was:" >&5
18252 sed 's/^/| /' conftest.$ac_ext >&5
18253
18254 ac_cv_lib_m_roundl=no
18255 fi
18256 rm -f conftest.err conftest.$ac_objext \
18257       conftest$ac_exeext conftest.$ac_ext
18258 LIBS=$ac_check_lib_save_LIBS
18259 fi
18260 echo "$as_me:$LINENO: result: $ac_cv_lib_m_roundl" >&5
18261 echo "${ECHO_T}$ac_cv_lib_m_roundl" >&6
18262 if test $ac_cv_lib_m_roundl = yes; then
18263
18264 cat >>confdefs.h <<\_ACEOF
18265 #define HAVE_ROUNDL 1
18266 _ACEOF
18267
18268 fi
18269
18270 echo "$as_me:$LINENO: checking for scalbnf in -lm" >&5
18271 echo $ECHO_N "checking for scalbnf in -lm... $ECHO_C" >&6
18272 if test "${ac_cv_lib_m_scalbnf+set}" = set; then
18273   echo $ECHO_N "(cached) $ECHO_C" >&6
18274 else
18275   ac_check_lib_save_LIBS=$LIBS
18276 LIBS="-lm  $LIBS"
18277 if test x$gcc_no_link = xyes; then
18278   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18279 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18280    { (exit 1); exit 1; }; }
18281 fi
18282 cat >conftest.$ac_ext <<_ACEOF
18283 /* confdefs.h.  */
18284 _ACEOF
18285 cat confdefs.h >>conftest.$ac_ext
18286 cat >>conftest.$ac_ext <<_ACEOF
18287 /* end confdefs.h.  */
18288
18289 /* Override any gcc2 internal prototype to avoid an error.  */
18290 #ifdef __cplusplus
18291 extern "C"
18292 #endif
18293 /* We use char because int might match the return type of a gcc2
18294    builtin and then its argument prototype would still apply.  */
18295 char scalbnf ();
18296 int
18297 main ()
18298 {
18299 scalbnf ();
18300   ;
18301   return 0;
18302 }
18303 _ACEOF
18304 rm -f conftest.$ac_objext conftest$ac_exeext
18305 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18306   (eval $ac_link) 2>conftest.er1
18307   ac_status=$?
18308   grep -v '^ *+' conftest.er1 >conftest.err
18309   rm -f conftest.er1
18310   cat conftest.err >&5
18311   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18312   (exit $ac_status); } &&
18313          { ac_try='test -z "$ac_c_werror_flag"
18314                          || test ! -s conftest.err'
18315   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18316   (eval $ac_try) 2>&5
18317   ac_status=$?
18318   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18319   (exit $ac_status); }; } &&
18320          { ac_try='test -s conftest$ac_exeext'
18321   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18322   (eval $ac_try) 2>&5
18323   ac_status=$?
18324   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18325   (exit $ac_status); }; }; then
18326   ac_cv_lib_m_scalbnf=yes
18327 else
18328   echo "$as_me: failed program was:" >&5
18329 sed 's/^/| /' conftest.$ac_ext >&5
18330
18331 ac_cv_lib_m_scalbnf=no
18332 fi
18333 rm -f conftest.err conftest.$ac_objext \
18334       conftest$ac_exeext conftest.$ac_ext
18335 LIBS=$ac_check_lib_save_LIBS
18336 fi
18337 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbnf" >&5
18338 echo "${ECHO_T}$ac_cv_lib_m_scalbnf" >&6
18339 if test $ac_cv_lib_m_scalbnf = yes; then
18340
18341 cat >>confdefs.h <<\_ACEOF
18342 #define HAVE_SCALBNF 1
18343 _ACEOF
18344
18345 fi
18346
18347 echo "$as_me:$LINENO: checking for scalbn in -lm" >&5
18348 echo $ECHO_N "checking for scalbn in -lm... $ECHO_C" >&6
18349 if test "${ac_cv_lib_m_scalbn+set}" = set; then
18350   echo $ECHO_N "(cached) $ECHO_C" >&6
18351 else
18352   ac_check_lib_save_LIBS=$LIBS
18353 LIBS="-lm  $LIBS"
18354 if test x$gcc_no_link = xyes; then
18355   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18356 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18357    { (exit 1); exit 1; }; }
18358 fi
18359 cat >conftest.$ac_ext <<_ACEOF
18360 /* confdefs.h.  */
18361 _ACEOF
18362 cat confdefs.h >>conftest.$ac_ext
18363 cat >>conftest.$ac_ext <<_ACEOF
18364 /* end confdefs.h.  */
18365
18366 /* Override any gcc2 internal prototype to avoid an error.  */
18367 #ifdef __cplusplus
18368 extern "C"
18369 #endif
18370 /* We use char because int might match the return type of a gcc2
18371    builtin and then its argument prototype would still apply.  */
18372 char scalbn ();
18373 int
18374 main ()
18375 {
18376 scalbn ();
18377   ;
18378   return 0;
18379 }
18380 _ACEOF
18381 rm -f conftest.$ac_objext conftest$ac_exeext
18382 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18383   (eval $ac_link) 2>conftest.er1
18384   ac_status=$?
18385   grep -v '^ *+' conftest.er1 >conftest.err
18386   rm -f conftest.er1
18387   cat conftest.err >&5
18388   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18389   (exit $ac_status); } &&
18390          { ac_try='test -z "$ac_c_werror_flag"
18391                          || test ! -s conftest.err'
18392   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18393   (eval $ac_try) 2>&5
18394   ac_status=$?
18395   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18396   (exit $ac_status); }; } &&
18397          { ac_try='test -s conftest$ac_exeext'
18398   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18399   (eval $ac_try) 2>&5
18400   ac_status=$?
18401   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18402   (exit $ac_status); }; }; then
18403   ac_cv_lib_m_scalbn=yes
18404 else
18405   echo "$as_me: failed program was:" >&5
18406 sed 's/^/| /' conftest.$ac_ext >&5
18407
18408 ac_cv_lib_m_scalbn=no
18409 fi
18410 rm -f conftest.err conftest.$ac_objext \
18411       conftest$ac_exeext conftest.$ac_ext
18412 LIBS=$ac_check_lib_save_LIBS
18413 fi
18414 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbn" >&5
18415 echo "${ECHO_T}$ac_cv_lib_m_scalbn" >&6
18416 if test $ac_cv_lib_m_scalbn = yes; then
18417
18418 cat >>confdefs.h <<\_ACEOF
18419 #define HAVE_SCALBN 1
18420 _ACEOF
18421
18422 fi
18423
18424 echo "$as_me:$LINENO: checking for scalbnl in -lm" >&5
18425 echo $ECHO_N "checking for scalbnl in -lm... $ECHO_C" >&6
18426 if test "${ac_cv_lib_m_scalbnl+set}" = set; then
18427   echo $ECHO_N "(cached) $ECHO_C" >&6
18428 else
18429   ac_check_lib_save_LIBS=$LIBS
18430 LIBS="-lm  $LIBS"
18431 if test x$gcc_no_link = xyes; then
18432   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18433 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18434    { (exit 1); exit 1; }; }
18435 fi
18436 cat >conftest.$ac_ext <<_ACEOF
18437 /* confdefs.h.  */
18438 _ACEOF
18439 cat confdefs.h >>conftest.$ac_ext
18440 cat >>conftest.$ac_ext <<_ACEOF
18441 /* end confdefs.h.  */
18442
18443 /* Override any gcc2 internal prototype to avoid an error.  */
18444 #ifdef __cplusplus
18445 extern "C"
18446 #endif
18447 /* We use char because int might match the return type of a gcc2
18448    builtin and then its argument prototype would still apply.  */
18449 char scalbnl ();
18450 int
18451 main ()
18452 {
18453 scalbnl ();
18454   ;
18455   return 0;
18456 }
18457 _ACEOF
18458 rm -f conftest.$ac_objext conftest$ac_exeext
18459 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18460   (eval $ac_link) 2>conftest.er1
18461   ac_status=$?
18462   grep -v '^ *+' conftest.er1 >conftest.err
18463   rm -f conftest.er1
18464   cat conftest.err >&5
18465   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18466   (exit $ac_status); } &&
18467          { ac_try='test -z "$ac_c_werror_flag"
18468                          || test ! -s conftest.err'
18469   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18470   (eval $ac_try) 2>&5
18471   ac_status=$?
18472   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18473   (exit $ac_status); }; } &&
18474          { ac_try='test -s conftest$ac_exeext'
18475   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18476   (eval $ac_try) 2>&5
18477   ac_status=$?
18478   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18479   (exit $ac_status); }; }; then
18480   ac_cv_lib_m_scalbnl=yes
18481 else
18482   echo "$as_me: failed program was:" >&5
18483 sed 's/^/| /' conftest.$ac_ext >&5
18484
18485 ac_cv_lib_m_scalbnl=no
18486 fi
18487 rm -f conftest.err conftest.$ac_objext \
18488       conftest$ac_exeext conftest.$ac_ext
18489 LIBS=$ac_check_lib_save_LIBS
18490 fi
18491 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbnl" >&5
18492 echo "${ECHO_T}$ac_cv_lib_m_scalbnl" >&6
18493 if test $ac_cv_lib_m_scalbnl = yes; then
18494
18495 cat >>confdefs.h <<\_ACEOF
18496 #define HAVE_SCALBNL 1
18497 _ACEOF
18498
18499 fi
18500
18501 echo "$as_me:$LINENO: checking for sinf in -lm" >&5
18502 echo $ECHO_N "checking for sinf in -lm... $ECHO_C" >&6
18503 if test "${ac_cv_lib_m_sinf+set}" = set; then
18504   echo $ECHO_N "(cached) $ECHO_C" >&6
18505 else
18506   ac_check_lib_save_LIBS=$LIBS
18507 LIBS="-lm  $LIBS"
18508 if test x$gcc_no_link = xyes; then
18509   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18510 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18511    { (exit 1); exit 1; }; }
18512 fi
18513 cat >conftest.$ac_ext <<_ACEOF
18514 /* confdefs.h.  */
18515 _ACEOF
18516 cat confdefs.h >>conftest.$ac_ext
18517 cat >>conftest.$ac_ext <<_ACEOF
18518 /* end confdefs.h.  */
18519
18520 /* Override any gcc2 internal prototype to avoid an error.  */
18521 #ifdef __cplusplus
18522 extern "C"
18523 #endif
18524 /* We use char because int might match the return type of a gcc2
18525    builtin and then its argument prototype would still apply.  */
18526 char sinf ();
18527 int
18528 main ()
18529 {
18530 sinf ();
18531   ;
18532   return 0;
18533 }
18534 _ACEOF
18535 rm -f conftest.$ac_objext conftest$ac_exeext
18536 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18537   (eval $ac_link) 2>conftest.er1
18538   ac_status=$?
18539   grep -v '^ *+' conftest.er1 >conftest.err
18540   rm -f conftest.er1
18541   cat conftest.err >&5
18542   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18543   (exit $ac_status); } &&
18544          { ac_try='test -z "$ac_c_werror_flag"
18545                          || test ! -s conftest.err'
18546   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18547   (eval $ac_try) 2>&5
18548   ac_status=$?
18549   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18550   (exit $ac_status); }; } &&
18551          { ac_try='test -s conftest$ac_exeext'
18552   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18553   (eval $ac_try) 2>&5
18554   ac_status=$?
18555   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18556   (exit $ac_status); }; }; then
18557   ac_cv_lib_m_sinf=yes
18558 else
18559   echo "$as_me: failed program was:" >&5
18560 sed 's/^/| /' conftest.$ac_ext >&5
18561
18562 ac_cv_lib_m_sinf=no
18563 fi
18564 rm -f conftest.err conftest.$ac_objext \
18565       conftest$ac_exeext conftest.$ac_ext
18566 LIBS=$ac_check_lib_save_LIBS
18567 fi
18568 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinf" >&5
18569 echo "${ECHO_T}$ac_cv_lib_m_sinf" >&6
18570 if test $ac_cv_lib_m_sinf = yes; then
18571
18572 cat >>confdefs.h <<\_ACEOF
18573 #define HAVE_SINF 1
18574 _ACEOF
18575
18576 fi
18577
18578 echo "$as_me:$LINENO: checking for sin in -lm" >&5
18579 echo $ECHO_N "checking for sin in -lm... $ECHO_C" >&6
18580 if test "${ac_cv_lib_m_sin+set}" = set; then
18581   echo $ECHO_N "(cached) $ECHO_C" >&6
18582 else
18583   ac_check_lib_save_LIBS=$LIBS
18584 LIBS="-lm  $LIBS"
18585 if test x$gcc_no_link = xyes; then
18586   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18587 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18588    { (exit 1); exit 1; }; }
18589 fi
18590 cat >conftest.$ac_ext <<_ACEOF
18591 /* confdefs.h.  */
18592 _ACEOF
18593 cat confdefs.h >>conftest.$ac_ext
18594 cat >>conftest.$ac_ext <<_ACEOF
18595 /* end confdefs.h.  */
18596
18597 /* Override any gcc2 internal prototype to avoid an error.  */
18598 #ifdef __cplusplus
18599 extern "C"
18600 #endif
18601 /* We use char because int might match the return type of a gcc2
18602    builtin and then its argument prototype would still apply.  */
18603 char sin ();
18604 int
18605 main ()
18606 {
18607 sin ();
18608   ;
18609   return 0;
18610 }
18611 _ACEOF
18612 rm -f conftest.$ac_objext conftest$ac_exeext
18613 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18614   (eval $ac_link) 2>conftest.er1
18615   ac_status=$?
18616   grep -v '^ *+' conftest.er1 >conftest.err
18617   rm -f conftest.er1
18618   cat conftest.err >&5
18619   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18620   (exit $ac_status); } &&
18621          { ac_try='test -z "$ac_c_werror_flag"
18622                          || test ! -s conftest.err'
18623   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18624   (eval $ac_try) 2>&5
18625   ac_status=$?
18626   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18627   (exit $ac_status); }; } &&
18628          { ac_try='test -s conftest$ac_exeext'
18629   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18630   (eval $ac_try) 2>&5
18631   ac_status=$?
18632   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18633   (exit $ac_status); }; }; then
18634   ac_cv_lib_m_sin=yes
18635 else
18636   echo "$as_me: failed program was:" >&5
18637 sed 's/^/| /' conftest.$ac_ext >&5
18638
18639 ac_cv_lib_m_sin=no
18640 fi
18641 rm -f conftest.err conftest.$ac_objext \
18642       conftest$ac_exeext conftest.$ac_ext
18643 LIBS=$ac_check_lib_save_LIBS
18644 fi
18645 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sin" >&5
18646 echo "${ECHO_T}$ac_cv_lib_m_sin" >&6
18647 if test $ac_cv_lib_m_sin = yes; then
18648
18649 cat >>confdefs.h <<\_ACEOF
18650 #define HAVE_SIN 1
18651 _ACEOF
18652
18653 fi
18654
18655 echo "$as_me:$LINENO: checking for sinl in -lm" >&5
18656 echo $ECHO_N "checking for sinl in -lm... $ECHO_C" >&6
18657 if test "${ac_cv_lib_m_sinl+set}" = set; then
18658   echo $ECHO_N "(cached) $ECHO_C" >&6
18659 else
18660   ac_check_lib_save_LIBS=$LIBS
18661 LIBS="-lm  $LIBS"
18662 if test x$gcc_no_link = xyes; then
18663   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18664 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18665    { (exit 1); exit 1; }; }
18666 fi
18667 cat >conftest.$ac_ext <<_ACEOF
18668 /* confdefs.h.  */
18669 _ACEOF
18670 cat confdefs.h >>conftest.$ac_ext
18671 cat >>conftest.$ac_ext <<_ACEOF
18672 /* end confdefs.h.  */
18673
18674 /* Override any gcc2 internal prototype to avoid an error.  */
18675 #ifdef __cplusplus
18676 extern "C"
18677 #endif
18678 /* We use char because int might match the return type of a gcc2
18679    builtin and then its argument prototype would still apply.  */
18680 char sinl ();
18681 int
18682 main ()
18683 {
18684 sinl ();
18685   ;
18686   return 0;
18687 }
18688 _ACEOF
18689 rm -f conftest.$ac_objext conftest$ac_exeext
18690 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18691   (eval $ac_link) 2>conftest.er1
18692   ac_status=$?
18693   grep -v '^ *+' conftest.er1 >conftest.err
18694   rm -f conftest.er1
18695   cat conftest.err >&5
18696   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18697   (exit $ac_status); } &&
18698          { ac_try='test -z "$ac_c_werror_flag"
18699                          || test ! -s conftest.err'
18700   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18701   (eval $ac_try) 2>&5
18702   ac_status=$?
18703   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18704   (exit $ac_status); }; } &&
18705          { ac_try='test -s conftest$ac_exeext'
18706   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18707   (eval $ac_try) 2>&5
18708   ac_status=$?
18709   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18710   (exit $ac_status); }; }; then
18711   ac_cv_lib_m_sinl=yes
18712 else
18713   echo "$as_me: failed program was:" >&5
18714 sed 's/^/| /' conftest.$ac_ext >&5
18715
18716 ac_cv_lib_m_sinl=no
18717 fi
18718 rm -f conftest.err conftest.$ac_objext \
18719       conftest$ac_exeext conftest.$ac_ext
18720 LIBS=$ac_check_lib_save_LIBS
18721 fi
18722 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinl" >&5
18723 echo "${ECHO_T}$ac_cv_lib_m_sinl" >&6
18724 if test $ac_cv_lib_m_sinl = yes; then
18725
18726 cat >>confdefs.h <<\_ACEOF
18727 #define HAVE_SINL 1
18728 _ACEOF
18729
18730 fi
18731
18732 echo "$as_me:$LINENO: checking for csinf in -lm" >&5
18733 echo $ECHO_N "checking for csinf in -lm... $ECHO_C" >&6
18734 if test "${ac_cv_lib_m_csinf+set}" = set; then
18735   echo $ECHO_N "(cached) $ECHO_C" >&6
18736 else
18737   ac_check_lib_save_LIBS=$LIBS
18738 LIBS="-lm  $LIBS"
18739 if test x$gcc_no_link = xyes; then
18740   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18741 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18742    { (exit 1); exit 1; }; }
18743 fi
18744 cat >conftest.$ac_ext <<_ACEOF
18745 /* confdefs.h.  */
18746 _ACEOF
18747 cat confdefs.h >>conftest.$ac_ext
18748 cat >>conftest.$ac_ext <<_ACEOF
18749 /* end confdefs.h.  */
18750
18751 /* Override any gcc2 internal prototype to avoid an error.  */
18752 #ifdef __cplusplus
18753 extern "C"
18754 #endif
18755 /* We use char because int might match the return type of a gcc2
18756    builtin and then its argument prototype would still apply.  */
18757 char csinf ();
18758 int
18759 main ()
18760 {
18761 csinf ();
18762   ;
18763   return 0;
18764 }
18765 _ACEOF
18766 rm -f conftest.$ac_objext conftest$ac_exeext
18767 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18768   (eval $ac_link) 2>conftest.er1
18769   ac_status=$?
18770   grep -v '^ *+' conftest.er1 >conftest.err
18771   rm -f conftest.er1
18772   cat conftest.err >&5
18773   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18774   (exit $ac_status); } &&
18775          { ac_try='test -z "$ac_c_werror_flag"
18776                          || test ! -s conftest.err'
18777   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18778   (eval $ac_try) 2>&5
18779   ac_status=$?
18780   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18781   (exit $ac_status); }; } &&
18782          { ac_try='test -s conftest$ac_exeext'
18783   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18784   (eval $ac_try) 2>&5
18785   ac_status=$?
18786   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18787   (exit $ac_status); }; }; then
18788   ac_cv_lib_m_csinf=yes
18789 else
18790   echo "$as_me: failed program was:" >&5
18791 sed 's/^/| /' conftest.$ac_ext >&5
18792
18793 ac_cv_lib_m_csinf=no
18794 fi
18795 rm -f conftest.err conftest.$ac_objext \
18796       conftest$ac_exeext conftest.$ac_ext
18797 LIBS=$ac_check_lib_save_LIBS
18798 fi
18799 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinf" >&5
18800 echo "${ECHO_T}$ac_cv_lib_m_csinf" >&6
18801 if test $ac_cv_lib_m_csinf = yes; then
18802
18803 cat >>confdefs.h <<\_ACEOF
18804 #define HAVE_CSINF 1
18805 _ACEOF
18806
18807 fi
18808
18809 echo "$as_me:$LINENO: checking for csin in -lm" >&5
18810 echo $ECHO_N "checking for csin in -lm... $ECHO_C" >&6
18811 if test "${ac_cv_lib_m_csin+set}" = set; then
18812   echo $ECHO_N "(cached) $ECHO_C" >&6
18813 else
18814   ac_check_lib_save_LIBS=$LIBS
18815 LIBS="-lm  $LIBS"
18816 if test x$gcc_no_link = xyes; then
18817   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18818 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18819    { (exit 1); exit 1; }; }
18820 fi
18821 cat >conftest.$ac_ext <<_ACEOF
18822 /* confdefs.h.  */
18823 _ACEOF
18824 cat confdefs.h >>conftest.$ac_ext
18825 cat >>conftest.$ac_ext <<_ACEOF
18826 /* end confdefs.h.  */
18827
18828 /* Override any gcc2 internal prototype to avoid an error.  */
18829 #ifdef __cplusplus
18830 extern "C"
18831 #endif
18832 /* We use char because int might match the return type of a gcc2
18833    builtin and then its argument prototype would still apply.  */
18834 char csin ();
18835 int
18836 main ()
18837 {
18838 csin ();
18839   ;
18840   return 0;
18841 }
18842 _ACEOF
18843 rm -f conftest.$ac_objext conftest$ac_exeext
18844 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18845   (eval $ac_link) 2>conftest.er1
18846   ac_status=$?
18847   grep -v '^ *+' conftest.er1 >conftest.err
18848   rm -f conftest.er1
18849   cat conftest.err >&5
18850   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18851   (exit $ac_status); } &&
18852          { ac_try='test -z "$ac_c_werror_flag"
18853                          || test ! -s conftest.err'
18854   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18855   (eval $ac_try) 2>&5
18856   ac_status=$?
18857   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18858   (exit $ac_status); }; } &&
18859          { ac_try='test -s conftest$ac_exeext'
18860   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18861   (eval $ac_try) 2>&5
18862   ac_status=$?
18863   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18864   (exit $ac_status); }; }; then
18865   ac_cv_lib_m_csin=yes
18866 else
18867   echo "$as_me: failed program was:" >&5
18868 sed 's/^/| /' conftest.$ac_ext >&5
18869
18870 ac_cv_lib_m_csin=no
18871 fi
18872 rm -f conftest.err conftest.$ac_objext \
18873       conftest$ac_exeext conftest.$ac_ext
18874 LIBS=$ac_check_lib_save_LIBS
18875 fi
18876 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csin" >&5
18877 echo "${ECHO_T}$ac_cv_lib_m_csin" >&6
18878 if test $ac_cv_lib_m_csin = yes; then
18879
18880 cat >>confdefs.h <<\_ACEOF
18881 #define HAVE_CSIN 1
18882 _ACEOF
18883
18884 fi
18885
18886 echo "$as_me:$LINENO: checking for csinl in -lm" >&5
18887 echo $ECHO_N "checking for csinl in -lm... $ECHO_C" >&6
18888 if test "${ac_cv_lib_m_csinl+set}" = set; then
18889   echo $ECHO_N "(cached) $ECHO_C" >&6
18890 else
18891   ac_check_lib_save_LIBS=$LIBS
18892 LIBS="-lm  $LIBS"
18893 if test x$gcc_no_link = xyes; then
18894   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18895 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18896    { (exit 1); exit 1; }; }
18897 fi
18898 cat >conftest.$ac_ext <<_ACEOF
18899 /* confdefs.h.  */
18900 _ACEOF
18901 cat confdefs.h >>conftest.$ac_ext
18902 cat >>conftest.$ac_ext <<_ACEOF
18903 /* end confdefs.h.  */
18904
18905 /* Override any gcc2 internal prototype to avoid an error.  */
18906 #ifdef __cplusplus
18907 extern "C"
18908 #endif
18909 /* We use char because int might match the return type of a gcc2
18910    builtin and then its argument prototype would still apply.  */
18911 char csinl ();
18912 int
18913 main ()
18914 {
18915 csinl ();
18916   ;
18917   return 0;
18918 }
18919 _ACEOF
18920 rm -f conftest.$ac_objext conftest$ac_exeext
18921 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18922   (eval $ac_link) 2>conftest.er1
18923   ac_status=$?
18924   grep -v '^ *+' conftest.er1 >conftest.err
18925   rm -f conftest.er1
18926   cat conftest.err >&5
18927   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18928   (exit $ac_status); } &&
18929          { ac_try='test -z "$ac_c_werror_flag"
18930                          || test ! -s conftest.err'
18931   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18932   (eval $ac_try) 2>&5
18933   ac_status=$?
18934   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18935   (exit $ac_status); }; } &&
18936          { ac_try='test -s conftest$ac_exeext'
18937   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18938   (eval $ac_try) 2>&5
18939   ac_status=$?
18940   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18941   (exit $ac_status); }; }; then
18942   ac_cv_lib_m_csinl=yes
18943 else
18944   echo "$as_me: failed program was:" >&5
18945 sed 's/^/| /' conftest.$ac_ext >&5
18946
18947 ac_cv_lib_m_csinl=no
18948 fi
18949 rm -f conftest.err conftest.$ac_objext \
18950       conftest$ac_exeext conftest.$ac_ext
18951 LIBS=$ac_check_lib_save_LIBS
18952 fi
18953 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinl" >&5
18954 echo "${ECHO_T}$ac_cv_lib_m_csinl" >&6
18955 if test $ac_cv_lib_m_csinl = yes; then
18956
18957 cat >>confdefs.h <<\_ACEOF
18958 #define HAVE_CSINL 1
18959 _ACEOF
18960
18961 fi
18962
18963 echo "$as_me:$LINENO: checking for sinhf in -lm" >&5
18964 echo $ECHO_N "checking for sinhf in -lm... $ECHO_C" >&6
18965 if test "${ac_cv_lib_m_sinhf+set}" = set; then
18966   echo $ECHO_N "(cached) $ECHO_C" >&6
18967 else
18968   ac_check_lib_save_LIBS=$LIBS
18969 LIBS="-lm  $LIBS"
18970 if test x$gcc_no_link = xyes; then
18971   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18972 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18973    { (exit 1); exit 1; }; }
18974 fi
18975 cat >conftest.$ac_ext <<_ACEOF
18976 /* confdefs.h.  */
18977 _ACEOF
18978 cat confdefs.h >>conftest.$ac_ext
18979 cat >>conftest.$ac_ext <<_ACEOF
18980 /* end confdefs.h.  */
18981
18982 /* Override any gcc2 internal prototype to avoid an error.  */
18983 #ifdef __cplusplus
18984 extern "C"
18985 #endif
18986 /* We use char because int might match the return type of a gcc2
18987    builtin and then its argument prototype would still apply.  */
18988 char sinhf ();
18989 int
18990 main ()
18991 {
18992 sinhf ();
18993   ;
18994   return 0;
18995 }
18996 _ACEOF
18997 rm -f conftest.$ac_objext conftest$ac_exeext
18998 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18999   (eval $ac_link) 2>conftest.er1
19000   ac_status=$?
19001   grep -v '^ *+' conftest.er1 >conftest.err
19002   rm -f conftest.er1
19003   cat conftest.err >&5
19004   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19005   (exit $ac_status); } &&
19006          { ac_try='test -z "$ac_c_werror_flag"
19007                          || test ! -s conftest.err'
19008   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19009   (eval $ac_try) 2>&5
19010   ac_status=$?
19011   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19012   (exit $ac_status); }; } &&
19013          { ac_try='test -s conftest$ac_exeext'
19014   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19015   (eval $ac_try) 2>&5
19016   ac_status=$?
19017   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19018   (exit $ac_status); }; }; then
19019   ac_cv_lib_m_sinhf=yes
19020 else
19021   echo "$as_me: failed program was:" >&5
19022 sed 's/^/| /' conftest.$ac_ext >&5
19023
19024 ac_cv_lib_m_sinhf=no
19025 fi
19026 rm -f conftest.err conftest.$ac_objext \
19027       conftest$ac_exeext conftest.$ac_ext
19028 LIBS=$ac_check_lib_save_LIBS
19029 fi
19030 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinhf" >&5
19031 echo "${ECHO_T}$ac_cv_lib_m_sinhf" >&6
19032 if test $ac_cv_lib_m_sinhf = yes; then
19033
19034 cat >>confdefs.h <<\_ACEOF
19035 #define HAVE_SINHF 1
19036 _ACEOF
19037
19038 fi
19039
19040 echo "$as_me:$LINENO: checking for sinh in -lm" >&5
19041 echo $ECHO_N "checking for sinh in -lm... $ECHO_C" >&6
19042 if test "${ac_cv_lib_m_sinh+set}" = set; then
19043   echo $ECHO_N "(cached) $ECHO_C" >&6
19044 else
19045   ac_check_lib_save_LIBS=$LIBS
19046 LIBS="-lm  $LIBS"
19047 if test x$gcc_no_link = xyes; then
19048   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19049 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19050    { (exit 1); exit 1; }; }
19051 fi
19052 cat >conftest.$ac_ext <<_ACEOF
19053 /* confdefs.h.  */
19054 _ACEOF
19055 cat confdefs.h >>conftest.$ac_ext
19056 cat >>conftest.$ac_ext <<_ACEOF
19057 /* end confdefs.h.  */
19058
19059 /* Override any gcc2 internal prototype to avoid an error.  */
19060 #ifdef __cplusplus
19061 extern "C"
19062 #endif
19063 /* We use char because int might match the return type of a gcc2
19064    builtin and then its argument prototype would still apply.  */
19065 char sinh ();
19066 int
19067 main ()
19068 {
19069 sinh ();
19070   ;
19071   return 0;
19072 }
19073 _ACEOF
19074 rm -f conftest.$ac_objext conftest$ac_exeext
19075 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19076   (eval $ac_link) 2>conftest.er1
19077   ac_status=$?
19078   grep -v '^ *+' conftest.er1 >conftest.err
19079   rm -f conftest.er1
19080   cat conftest.err >&5
19081   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19082   (exit $ac_status); } &&
19083          { ac_try='test -z "$ac_c_werror_flag"
19084                          || test ! -s conftest.err'
19085   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19086   (eval $ac_try) 2>&5
19087   ac_status=$?
19088   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19089   (exit $ac_status); }; } &&
19090          { ac_try='test -s conftest$ac_exeext'
19091   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19092   (eval $ac_try) 2>&5
19093   ac_status=$?
19094   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19095   (exit $ac_status); }; }; then
19096   ac_cv_lib_m_sinh=yes
19097 else
19098   echo "$as_me: failed program was:" >&5
19099 sed 's/^/| /' conftest.$ac_ext >&5
19100
19101 ac_cv_lib_m_sinh=no
19102 fi
19103 rm -f conftest.err conftest.$ac_objext \
19104       conftest$ac_exeext conftest.$ac_ext
19105 LIBS=$ac_check_lib_save_LIBS
19106 fi
19107 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinh" >&5
19108 echo "${ECHO_T}$ac_cv_lib_m_sinh" >&6
19109 if test $ac_cv_lib_m_sinh = yes; then
19110
19111 cat >>confdefs.h <<\_ACEOF
19112 #define HAVE_SINH 1
19113 _ACEOF
19114
19115 fi
19116
19117 echo "$as_me:$LINENO: checking for sinhl in -lm" >&5
19118 echo $ECHO_N "checking for sinhl in -lm... $ECHO_C" >&6
19119 if test "${ac_cv_lib_m_sinhl+set}" = set; then
19120   echo $ECHO_N "(cached) $ECHO_C" >&6
19121 else
19122   ac_check_lib_save_LIBS=$LIBS
19123 LIBS="-lm  $LIBS"
19124 if test x$gcc_no_link = xyes; then
19125   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19126 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19127    { (exit 1); exit 1; }; }
19128 fi
19129 cat >conftest.$ac_ext <<_ACEOF
19130 /* confdefs.h.  */
19131 _ACEOF
19132 cat confdefs.h >>conftest.$ac_ext
19133 cat >>conftest.$ac_ext <<_ACEOF
19134 /* end confdefs.h.  */
19135
19136 /* Override any gcc2 internal prototype to avoid an error.  */
19137 #ifdef __cplusplus
19138 extern "C"
19139 #endif
19140 /* We use char because int might match the return type of a gcc2
19141    builtin and then its argument prototype would still apply.  */
19142 char sinhl ();
19143 int
19144 main ()
19145 {
19146 sinhl ();
19147   ;
19148   return 0;
19149 }
19150 _ACEOF
19151 rm -f conftest.$ac_objext conftest$ac_exeext
19152 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19153   (eval $ac_link) 2>conftest.er1
19154   ac_status=$?
19155   grep -v '^ *+' conftest.er1 >conftest.err
19156   rm -f conftest.er1
19157   cat conftest.err >&5
19158   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19159   (exit $ac_status); } &&
19160          { ac_try='test -z "$ac_c_werror_flag"
19161                          || test ! -s conftest.err'
19162   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19163   (eval $ac_try) 2>&5
19164   ac_status=$?
19165   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19166   (exit $ac_status); }; } &&
19167          { ac_try='test -s conftest$ac_exeext'
19168   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19169   (eval $ac_try) 2>&5
19170   ac_status=$?
19171   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19172   (exit $ac_status); }; }; then
19173   ac_cv_lib_m_sinhl=yes
19174 else
19175   echo "$as_me: failed program was:" >&5
19176 sed 's/^/| /' conftest.$ac_ext >&5
19177
19178 ac_cv_lib_m_sinhl=no
19179 fi
19180 rm -f conftest.err conftest.$ac_objext \
19181       conftest$ac_exeext conftest.$ac_ext
19182 LIBS=$ac_check_lib_save_LIBS
19183 fi
19184 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinhl" >&5
19185 echo "${ECHO_T}$ac_cv_lib_m_sinhl" >&6
19186 if test $ac_cv_lib_m_sinhl = yes; then
19187
19188 cat >>confdefs.h <<\_ACEOF
19189 #define HAVE_SINHL 1
19190 _ACEOF
19191
19192 fi
19193
19194 echo "$as_me:$LINENO: checking for csinhf in -lm" >&5
19195 echo $ECHO_N "checking for csinhf in -lm... $ECHO_C" >&6
19196 if test "${ac_cv_lib_m_csinhf+set}" = set; then
19197   echo $ECHO_N "(cached) $ECHO_C" >&6
19198 else
19199   ac_check_lib_save_LIBS=$LIBS
19200 LIBS="-lm  $LIBS"
19201 if test x$gcc_no_link = xyes; then
19202   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19203 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19204    { (exit 1); exit 1; }; }
19205 fi
19206 cat >conftest.$ac_ext <<_ACEOF
19207 /* confdefs.h.  */
19208 _ACEOF
19209 cat confdefs.h >>conftest.$ac_ext
19210 cat >>conftest.$ac_ext <<_ACEOF
19211 /* end confdefs.h.  */
19212
19213 /* Override any gcc2 internal prototype to avoid an error.  */
19214 #ifdef __cplusplus
19215 extern "C"
19216 #endif
19217 /* We use char because int might match the return type of a gcc2
19218    builtin and then its argument prototype would still apply.  */
19219 char csinhf ();
19220 int
19221 main ()
19222 {
19223 csinhf ();
19224   ;
19225   return 0;
19226 }
19227 _ACEOF
19228 rm -f conftest.$ac_objext conftest$ac_exeext
19229 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19230   (eval $ac_link) 2>conftest.er1
19231   ac_status=$?
19232   grep -v '^ *+' conftest.er1 >conftest.err
19233   rm -f conftest.er1
19234   cat conftest.err >&5
19235   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19236   (exit $ac_status); } &&
19237          { ac_try='test -z "$ac_c_werror_flag"
19238                          || test ! -s conftest.err'
19239   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19240   (eval $ac_try) 2>&5
19241   ac_status=$?
19242   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19243   (exit $ac_status); }; } &&
19244          { ac_try='test -s conftest$ac_exeext'
19245   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19246   (eval $ac_try) 2>&5
19247   ac_status=$?
19248   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19249   (exit $ac_status); }; }; then
19250   ac_cv_lib_m_csinhf=yes
19251 else
19252   echo "$as_me: failed program was:" >&5
19253 sed 's/^/| /' conftest.$ac_ext >&5
19254
19255 ac_cv_lib_m_csinhf=no
19256 fi
19257 rm -f conftest.err conftest.$ac_objext \
19258       conftest$ac_exeext conftest.$ac_ext
19259 LIBS=$ac_check_lib_save_LIBS
19260 fi
19261 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinhf" >&5
19262 echo "${ECHO_T}$ac_cv_lib_m_csinhf" >&6
19263 if test $ac_cv_lib_m_csinhf = yes; then
19264
19265 cat >>confdefs.h <<\_ACEOF
19266 #define HAVE_CSINHF 1
19267 _ACEOF
19268
19269 fi
19270
19271 echo "$as_me:$LINENO: checking for csinh in -lm" >&5
19272 echo $ECHO_N "checking for csinh in -lm... $ECHO_C" >&6
19273 if test "${ac_cv_lib_m_csinh+set}" = set; then
19274   echo $ECHO_N "(cached) $ECHO_C" >&6
19275 else
19276   ac_check_lib_save_LIBS=$LIBS
19277 LIBS="-lm  $LIBS"
19278 if test x$gcc_no_link = xyes; then
19279   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19280 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19281    { (exit 1); exit 1; }; }
19282 fi
19283 cat >conftest.$ac_ext <<_ACEOF
19284 /* confdefs.h.  */
19285 _ACEOF
19286 cat confdefs.h >>conftest.$ac_ext
19287 cat >>conftest.$ac_ext <<_ACEOF
19288 /* end confdefs.h.  */
19289
19290 /* Override any gcc2 internal prototype to avoid an error.  */
19291 #ifdef __cplusplus
19292 extern "C"
19293 #endif
19294 /* We use char because int might match the return type of a gcc2
19295    builtin and then its argument prototype would still apply.  */
19296 char csinh ();
19297 int
19298 main ()
19299 {
19300 csinh ();
19301   ;
19302   return 0;
19303 }
19304 _ACEOF
19305 rm -f conftest.$ac_objext conftest$ac_exeext
19306 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19307   (eval $ac_link) 2>conftest.er1
19308   ac_status=$?
19309   grep -v '^ *+' conftest.er1 >conftest.err
19310   rm -f conftest.er1
19311   cat conftest.err >&5
19312   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19313   (exit $ac_status); } &&
19314          { ac_try='test -z "$ac_c_werror_flag"
19315                          || test ! -s conftest.err'
19316   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19317   (eval $ac_try) 2>&5
19318   ac_status=$?
19319   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19320   (exit $ac_status); }; } &&
19321          { ac_try='test -s conftest$ac_exeext'
19322   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19323   (eval $ac_try) 2>&5
19324   ac_status=$?
19325   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19326   (exit $ac_status); }; }; then
19327   ac_cv_lib_m_csinh=yes
19328 else
19329   echo "$as_me: failed program was:" >&5
19330 sed 's/^/| /' conftest.$ac_ext >&5
19331
19332 ac_cv_lib_m_csinh=no
19333 fi
19334 rm -f conftest.err conftest.$ac_objext \
19335       conftest$ac_exeext conftest.$ac_ext
19336 LIBS=$ac_check_lib_save_LIBS
19337 fi
19338 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinh" >&5
19339 echo "${ECHO_T}$ac_cv_lib_m_csinh" >&6
19340 if test $ac_cv_lib_m_csinh = yes; then
19341
19342 cat >>confdefs.h <<\_ACEOF
19343 #define HAVE_CSINH 1
19344 _ACEOF
19345
19346 fi
19347
19348 echo "$as_me:$LINENO: checking for csinhl in -lm" >&5
19349 echo $ECHO_N "checking for csinhl in -lm... $ECHO_C" >&6
19350 if test "${ac_cv_lib_m_csinhl+set}" = set; then
19351   echo $ECHO_N "(cached) $ECHO_C" >&6
19352 else
19353   ac_check_lib_save_LIBS=$LIBS
19354 LIBS="-lm  $LIBS"
19355 if test x$gcc_no_link = xyes; then
19356   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19357 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19358    { (exit 1); exit 1; }; }
19359 fi
19360 cat >conftest.$ac_ext <<_ACEOF
19361 /* confdefs.h.  */
19362 _ACEOF
19363 cat confdefs.h >>conftest.$ac_ext
19364 cat >>conftest.$ac_ext <<_ACEOF
19365 /* end confdefs.h.  */
19366
19367 /* Override any gcc2 internal prototype to avoid an error.  */
19368 #ifdef __cplusplus
19369 extern "C"
19370 #endif
19371 /* We use char because int might match the return type of a gcc2
19372    builtin and then its argument prototype would still apply.  */
19373 char csinhl ();
19374 int
19375 main ()
19376 {
19377 csinhl ();
19378   ;
19379   return 0;
19380 }
19381 _ACEOF
19382 rm -f conftest.$ac_objext conftest$ac_exeext
19383 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19384   (eval $ac_link) 2>conftest.er1
19385   ac_status=$?
19386   grep -v '^ *+' conftest.er1 >conftest.err
19387   rm -f conftest.er1
19388   cat conftest.err >&5
19389   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19390   (exit $ac_status); } &&
19391          { ac_try='test -z "$ac_c_werror_flag"
19392                          || test ! -s conftest.err'
19393   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19394   (eval $ac_try) 2>&5
19395   ac_status=$?
19396   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19397   (exit $ac_status); }; } &&
19398          { ac_try='test -s conftest$ac_exeext'
19399   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19400   (eval $ac_try) 2>&5
19401   ac_status=$?
19402   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19403   (exit $ac_status); }; }; then
19404   ac_cv_lib_m_csinhl=yes
19405 else
19406   echo "$as_me: failed program was:" >&5
19407 sed 's/^/| /' conftest.$ac_ext >&5
19408
19409 ac_cv_lib_m_csinhl=no
19410 fi
19411 rm -f conftest.err conftest.$ac_objext \
19412       conftest$ac_exeext conftest.$ac_ext
19413 LIBS=$ac_check_lib_save_LIBS
19414 fi
19415 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinhl" >&5
19416 echo "${ECHO_T}$ac_cv_lib_m_csinhl" >&6
19417 if test $ac_cv_lib_m_csinhl = yes; then
19418
19419 cat >>confdefs.h <<\_ACEOF
19420 #define HAVE_CSINHL 1
19421 _ACEOF
19422
19423 fi
19424
19425 echo "$as_me:$LINENO: checking for sqrtf in -lm" >&5
19426 echo $ECHO_N "checking for sqrtf in -lm... $ECHO_C" >&6
19427 if test "${ac_cv_lib_m_sqrtf+set}" = set; then
19428   echo $ECHO_N "(cached) $ECHO_C" >&6
19429 else
19430   ac_check_lib_save_LIBS=$LIBS
19431 LIBS="-lm  $LIBS"
19432 if test x$gcc_no_link = xyes; then
19433   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19434 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19435    { (exit 1); exit 1; }; }
19436 fi
19437 cat >conftest.$ac_ext <<_ACEOF
19438 /* confdefs.h.  */
19439 _ACEOF
19440 cat confdefs.h >>conftest.$ac_ext
19441 cat >>conftest.$ac_ext <<_ACEOF
19442 /* end confdefs.h.  */
19443
19444 /* Override any gcc2 internal prototype to avoid an error.  */
19445 #ifdef __cplusplus
19446 extern "C"
19447 #endif
19448 /* We use char because int might match the return type of a gcc2
19449    builtin and then its argument prototype would still apply.  */
19450 char sqrtf ();
19451 int
19452 main ()
19453 {
19454 sqrtf ();
19455   ;
19456   return 0;
19457 }
19458 _ACEOF
19459 rm -f conftest.$ac_objext conftest$ac_exeext
19460 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19461   (eval $ac_link) 2>conftest.er1
19462   ac_status=$?
19463   grep -v '^ *+' conftest.er1 >conftest.err
19464   rm -f conftest.er1
19465   cat conftest.err >&5
19466   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19467   (exit $ac_status); } &&
19468          { ac_try='test -z "$ac_c_werror_flag"
19469                          || test ! -s conftest.err'
19470   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19471   (eval $ac_try) 2>&5
19472   ac_status=$?
19473   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19474   (exit $ac_status); }; } &&
19475          { ac_try='test -s conftest$ac_exeext'
19476   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19477   (eval $ac_try) 2>&5
19478   ac_status=$?
19479   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19480   (exit $ac_status); }; }; then
19481   ac_cv_lib_m_sqrtf=yes
19482 else
19483   echo "$as_me: failed program was:" >&5
19484 sed 's/^/| /' conftest.$ac_ext >&5
19485
19486 ac_cv_lib_m_sqrtf=no
19487 fi
19488 rm -f conftest.err conftest.$ac_objext \
19489       conftest$ac_exeext conftest.$ac_ext
19490 LIBS=$ac_check_lib_save_LIBS
19491 fi
19492 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrtf" >&5
19493 echo "${ECHO_T}$ac_cv_lib_m_sqrtf" >&6
19494 if test $ac_cv_lib_m_sqrtf = yes; then
19495
19496 cat >>confdefs.h <<\_ACEOF
19497 #define HAVE_SQRTF 1
19498 _ACEOF
19499
19500 fi
19501
19502 echo "$as_me:$LINENO: checking for sqrt in -lm" >&5
19503 echo $ECHO_N "checking for sqrt in -lm... $ECHO_C" >&6
19504 if test "${ac_cv_lib_m_sqrt+set}" = set; then
19505   echo $ECHO_N "(cached) $ECHO_C" >&6
19506 else
19507   ac_check_lib_save_LIBS=$LIBS
19508 LIBS="-lm  $LIBS"
19509 if test x$gcc_no_link = xyes; then
19510   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19511 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19512    { (exit 1); exit 1; }; }
19513 fi
19514 cat >conftest.$ac_ext <<_ACEOF
19515 /* confdefs.h.  */
19516 _ACEOF
19517 cat confdefs.h >>conftest.$ac_ext
19518 cat >>conftest.$ac_ext <<_ACEOF
19519 /* end confdefs.h.  */
19520
19521 /* Override any gcc2 internal prototype to avoid an error.  */
19522 #ifdef __cplusplus
19523 extern "C"
19524 #endif
19525 /* We use char because int might match the return type of a gcc2
19526    builtin and then its argument prototype would still apply.  */
19527 char sqrt ();
19528 int
19529 main ()
19530 {
19531 sqrt ();
19532   ;
19533   return 0;
19534 }
19535 _ACEOF
19536 rm -f conftest.$ac_objext conftest$ac_exeext
19537 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19538   (eval $ac_link) 2>conftest.er1
19539   ac_status=$?
19540   grep -v '^ *+' conftest.er1 >conftest.err
19541   rm -f conftest.er1
19542   cat conftest.err >&5
19543   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19544   (exit $ac_status); } &&
19545          { ac_try='test -z "$ac_c_werror_flag"
19546                          || test ! -s conftest.err'
19547   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19548   (eval $ac_try) 2>&5
19549   ac_status=$?
19550   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19551   (exit $ac_status); }; } &&
19552          { ac_try='test -s conftest$ac_exeext'
19553   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19554   (eval $ac_try) 2>&5
19555   ac_status=$?
19556   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19557   (exit $ac_status); }; }; then
19558   ac_cv_lib_m_sqrt=yes
19559 else
19560   echo "$as_me: failed program was:" >&5
19561 sed 's/^/| /' conftest.$ac_ext >&5
19562
19563 ac_cv_lib_m_sqrt=no
19564 fi
19565 rm -f conftest.err conftest.$ac_objext \
19566       conftest$ac_exeext conftest.$ac_ext
19567 LIBS=$ac_check_lib_save_LIBS
19568 fi
19569 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrt" >&5
19570 echo "${ECHO_T}$ac_cv_lib_m_sqrt" >&6
19571 if test $ac_cv_lib_m_sqrt = yes; then
19572
19573 cat >>confdefs.h <<\_ACEOF
19574 #define HAVE_SQRT 1
19575 _ACEOF
19576
19577 fi
19578
19579 echo "$as_me:$LINENO: checking for sqrtl in -lm" >&5
19580 echo $ECHO_N "checking for sqrtl in -lm... $ECHO_C" >&6
19581 if test "${ac_cv_lib_m_sqrtl+set}" = set; then
19582   echo $ECHO_N "(cached) $ECHO_C" >&6
19583 else
19584   ac_check_lib_save_LIBS=$LIBS
19585 LIBS="-lm  $LIBS"
19586 if test x$gcc_no_link = xyes; then
19587   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19588 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19589    { (exit 1); exit 1; }; }
19590 fi
19591 cat >conftest.$ac_ext <<_ACEOF
19592 /* confdefs.h.  */
19593 _ACEOF
19594 cat confdefs.h >>conftest.$ac_ext
19595 cat >>conftest.$ac_ext <<_ACEOF
19596 /* end confdefs.h.  */
19597
19598 /* Override any gcc2 internal prototype to avoid an error.  */
19599 #ifdef __cplusplus
19600 extern "C"
19601 #endif
19602 /* We use char because int might match the return type of a gcc2
19603    builtin and then its argument prototype would still apply.  */
19604 char sqrtl ();
19605 int
19606 main ()
19607 {
19608 sqrtl ();
19609   ;
19610   return 0;
19611 }
19612 _ACEOF
19613 rm -f conftest.$ac_objext conftest$ac_exeext
19614 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19615   (eval $ac_link) 2>conftest.er1
19616   ac_status=$?
19617   grep -v '^ *+' conftest.er1 >conftest.err
19618   rm -f conftest.er1
19619   cat conftest.err >&5
19620   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19621   (exit $ac_status); } &&
19622          { ac_try='test -z "$ac_c_werror_flag"
19623                          || test ! -s conftest.err'
19624   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19625   (eval $ac_try) 2>&5
19626   ac_status=$?
19627   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19628   (exit $ac_status); }; } &&
19629          { ac_try='test -s conftest$ac_exeext'
19630   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19631   (eval $ac_try) 2>&5
19632   ac_status=$?
19633   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19634   (exit $ac_status); }; }; then
19635   ac_cv_lib_m_sqrtl=yes
19636 else
19637   echo "$as_me: failed program was:" >&5
19638 sed 's/^/| /' conftest.$ac_ext >&5
19639
19640 ac_cv_lib_m_sqrtl=no
19641 fi
19642 rm -f conftest.err conftest.$ac_objext \
19643       conftest$ac_exeext conftest.$ac_ext
19644 LIBS=$ac_check_lib_save_LIBS
19645 fi
19646 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrtl" >&5
19647 echo "${ECHO_T}$ac_cv_lib_m_sqrtl" >&6
19648 if test $ac_cv_lib_m_sqrtl = yes; then
19649
19650 cat >>confdefs.h <<\_ACEOF
19651 #define HAVE_SQRTL 1
19652 _ACEOF
19653
19654 fi
19655
19656 echo "$as_me:$LINENO: checking for csqrtf in -lm" >&5
19657 echo $ECHO_N "checking for csqrtf in -lm... $ECHO_C" >&6
19658 if test "${ac_cv_lib_m_csqrtf+set}" = set; then
19659   echo $ECHO_N "(cached) $ECHO_C" >&6
19660 else
19661   ac_check_lib_save_LIBS=$LIBS
19662 LIBS="-lm  $LIBS"
19663 if test x$gcc_no_link = xyes; then
19664   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19665 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19666    { (exit 1); exit 1; }; }
19667 fi
19668 cat >conftest.$ac_ext <<_ACEOF
19669 /* confdefs.h.  */
19670 _ACEOF
19671 cat confdefs.h >>conftest.$ac_ext
19672 cat >>conftest.$ac_ext <<_ACEOF
19673 /* end confdefs.h.  */
19674
19675 /* Override any gcc2 internal prototype to avoid an error.  */
19676 #ifdef __cplusplus
19677 extern "C"
19678 #endif
19679 /* We use char because int might match the return type of a gcc2
19680    builtin and then its argument prototype would still apply.  */
19681 char csqrtf ();
19682 int
19683 main ()
19684 {
19685 csqrtf ();
19686   ;
19687   return 0;
19688 }
19689 _ACEOF
19690 rm -f conftest.$ac_objext conftest$ac_exeext
19691 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19692   (eval $ac_link) 2>conftest.er1
19693   ac_status=$?
19694   grep -v '^ *+' conftest.er1 >conftest.err
19695   rm -f conftest.er1
19696   cat conftest.err >&5
19697   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19698   (exit $ac_status); } &&
19699          { ac_try='test -z "$ac_c_werror_flag"
19700                          || test ! -s conftest.err'
19701   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19702   (eval $ac_try) 2>&5
19703   ac_status=$?
19704   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19705   (exit $ac_status); }; } &&
19706          { ac_try='test -s conftest$ac_exeext'
19707   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19708   (eval $ac_try) 2>&5
19709   ac_status=$?
19710   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19711   (exit $ac_status); }; }; then
19712   ac_cv_lib_m_csqrtf=yes
19713 else
19714   echo "$as_me: failed program was:" >&5
19715 sed 's/^/| /' conftest.$ac_ext >&5
19716
19717 ac_cv_lib_m_csqrtf=no
19718 fi
19719 rm -f conftest.err conftest.$ac_objext \
19720       conftest$ac_exeext conftest.$ac_ext
19721 LIBS=$ac_check_lib_save_LIBS
19722 fi
19723 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrtf" >&5
19724 echo "${ECHO_T}$ac_cv_lib_m_csqrtf" >&6
19725 if test $ac_cv_lib_m_csqrtf = yes; then
19726
19727 cat >>confdefs.h <<\_ACEOF
19728 #define HAVE_CSQRTF 1
19729 _ACEOF
19730
19731 fi
19732
19733 echo "$as_me:$LINENO: checking for csqrt in -lm" >&5
19734 echo $ECHO_N "checking for csqrt in -lm... $ECHO_C" >&6
19735 if test "${ac_cv_lib_m_csqrt+set}" = set; then
19736   echo $ECHO_N "(cached) $ECHO_C" >&6
19737 else
19738   ac_check_lib_save_LIBS=$LIBS
19739 LIBS="-lm  $LIBS"
19740 if test x$gcc_no_link = xyes; then
19741   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19742 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19743    { (exit 1); exit 1; }; }
19744 fi
19745 cat >conftest.$ac_ext <<_ACEOF
19746 /* confdefs.h.  */
19747 _ACEOF
19748 cat confdefs.h >>conftest.$ac_ext
19749 cat >>conftest.$ac_ext <<_ACEOF
19750 /* end confdefs.h.  */
19751
19752 /* Override any gcc2 internal prototype to avoid an error.  */
19753 #ifdef __cplusplus
19754 extern "C"
19755 #endif
19756 /* We use char because int might match the return type of a gcc2
19757    builtin and then its argument prototype would still apply.  */
19758 char csqrt ();
19759 int
19760 main ()
19761 {
19762 csqrt ();
19763   ;
19764   return 0;
19765 }
19766 _ACEOF
19767 rm -f conftest.$ac_objext conftest$ac_exeext
19768 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19769   (eval $ac_link) 2>conftest.er1
19770   ac_status=$?
19771   grep -v '^ *+' conftest.er1 >conftest.err
19772   rm -f conftest.er1
19773   cat conftest.err >&5
19774   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19775   (exit $ac_status); } &&
19776          { ac_try='test -z "$ac_c_werror_flag"
19777                          || test ! -s conftest.err'
19778   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19779   (eval $ac_try) 2>&5
19780   ac_status=$?
19781   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19782   (exit $ac_status); }; } &&
19783          { ac_try='test -s conftest$ac_exeext'
19784   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19785   (eval $ac_try) 2>&5
19786   ac_status=$?
19787   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19788   (exit $ac_status); }; }; then
19789   ac_cv_lib_m_csqrt=yes
19790 else
19791   echo "$as_me: failed program was:" >&5
19792 sed 's/^/| /' conftest.$ac_ext >&5
19793
19794 ac_cv_lib_m_csqrt=no
19795 fi
19796 rm -f conftest.err conftest.$ac_objext \
19797       conftest$ac_exeext conftest.$ac_ext
19798 LIBS=$ac_check_lib_save_LIBS
19799 fi
19800 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrt" >&5
19801 echo "${ECHO_T}$ac_cv_lib_m_csqrt" >&6
19802 if test $ac_cv_lib_m_csqrt = yes; then
19803
19804 cat >>confdefs.h <<\_ACEOF
19805 #define HAVE_CSQRT 1
19806 _ACEOF
19807
19808 fi
19809
19810 echo "$as_me:$LINENO: checking for csqrtl in -lm" >&5
19811 echo $ECHO_N "checking for csqrtl in -lm... $ECHO_C" >&6
19812 if test "${ac_cv_lib_m_csqrtl+set}" = set; then
19813   echo $ECHO_N "(cached) $ECHO_C" >&6
19814 else
19815   ac_check_lib_save_LIBS=$LIBS
19816 LIBS="-lm  $LIBS"
19817 if test x$gcc_no_link = xyes; then
19818   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19819 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19820    { (exit 1); exit 1; }; }
19821 fi
19822 cat >conftest.$ac_ext <<_ACEOF
19823 /* confdefs.h.  */
19824 _ACEOF
19825 cat confdefs.h >>conftest.$ac_ext
19826 cat >>conftest.$ac_ext <<_ACEOF
19827 /* end confdefs.h.  */
19828
19829 /* Override any gcc2 internal prototype to avoid an error.  */
19830 #ifdef __cplusplus
19831 extern "C"
19832 #endif
19833 /* We use char because int might match the return type of a gcc2
19834    builtin and then its argument prototype would still apply.  */
19835 char csqrtl ();
19836 int
19837 main ()
19838 {
19839 csqrtl ();
19840   ;
19841   return 0;
19842 }
19843 _ACEOF
19844 rm -f conftest.$ac_objext conftest$ac_exeext
19845 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19846   (eval $ac_link) 2>conftest.er1
19847   ac_status=$?
19848   grep -v '^ *+' conftest.er1 >conftest.err
19849   rm -f conftest.er1
19850   cat conftest.err >&5
19851   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19852   (exit $ac_status); } &&
19853          { ac_try='test -z "$ac_c_werror_flag"
19854                          || test ! -s conftest.err'
19855   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19856   (eval $ac_try) 2>&5
19857   ac_status=$?
19858   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19859   (exit $ac_status); }; } &&
19860          { ac_try='test -s conftest$ac_exeext'
19861   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19862   (eval $ac_try) 2>&5
19863   ac_status=$?
19864   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19865   (exit $ac_status); }; }; then
19866   ac_cv_lib_m_csqrtl=yes
19867 else
19868   echo "$as_me: failed program was:" >&5
19869 sed 's/^/| /' conftest.$ac_ext >&5
19870
19871 ac_cv_lib_m_csqrtl=no
19872 fi
19873 rm -f conftest.err conftest.$ac_objext \
19874       conftest$ac_exeext conftest.$ac_ext
19875 LIBS=$ac_check_lib_save_LIBS
19876 fi
19877 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrtl" >&5
19878 echo "${ECHO_T}$ac_cv_lib_m_csqrtl" >&6
19879 if test $ac_cv_lib_m_csqrtl = yes; then
19880
19881 cat >>confdefs.h <<\_ACEOF
19882 #define HAVE_CSQRTL 1
19883 _ACEOF
19884
19885 fi
19886
19887 echo "$as_me:$LINENO: checking for tanf in -lm" >&5
19888 echo $ECHO_N "checking for tanf in -lm... $ECHO_C" >&6
19889 if test "${ac_cv_lib_m_tanf+set}" = set; then
19890   echo $ECHO_N "(cached) $ECHO_C" >&6
19891 else
19892   ac_check_lib_save_LIBS=$LIBS
19893 LIBS="-lm  $LIBS"
19894 if test x$gcc_no_link = xyes; then
19895   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19896 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19897    { (exit 1); exit 1; }; }
19898 fi
19899 cat >conftest.$ac_ext <<_ACEOF
19900 /* confdefs.h.  */
19901 _ACEOF
19902 cat confdefs.h >>conftest.$ac_ext
19903 cat >>conftest.$ac_ext <<_ACEOF
19904 /* end confdefs.h.  */
19905
19906 /* Override any gcc2 internal prototype to avoid an error.  */
19907 #ifdef __cplusplus
19908 extern "C"
19909 #endif
19910 /* We use char because int might match the return type of a gcc2
19911    builtin and then its argument prototype would still apply.  */
19912 char tanf ();
19913 int
19914 main ()
19915 {
19916 tanf ();
19917   ;
19918   return 0;
19919 }
19920 _ACEOF
19921 rm -f conftest.$ac_objext conftest$ac_exeext
19922 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19923   (eval $ac_link) 2>conftest.er1
19924   ac_status=$?
19925   grep -v '^ *+' conftest.er1 >conftest.err
19926   rm -f conftest.er1
19927   cat conftest.err >&5
19928   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19929   (exit $ac_status); } &&
19930          { ac_try='test -z "$ac_c_werror_flag"
19931                          || test ! -s conftest.err'
19932   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19933   (eval $ac_try) 2>&5
19934   ac_status=$?
19935   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19936   (exit $ac_status); }; } &&
19937          { ac_try='test -s conftest$ac_exeext'
19938   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19939   (eval $ac_try) 2>&5
19940   ac_status=$?
19941   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19942   (exit $ac_status); }; }; then
19943   ac_cv_lib_m_tanf=yes
19944 else
19945   echo "$as_me: failed program was:" >&5
19946 sed 's/^/| /' conftest.$ac_ext >&5
19947
19948 ac_cv_lib_m_tanf=no
19949 fi
19950 rm -f conftest.err conftest.$ac_objext \
19951       conftest$ac_exeext conftest.$ac_ext
19952 LIBS=$ac_check_lib_save_LIBS
19953 fi
19954 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanf" >&5
19955 echo "${ECHO_T}$ac_cv_lib_m_tanf" >&6
19956 if test $ac_cv_lib_m_tanf = yes; then
19957
19958 cat >>confdefs.h <<\_ACEOF
19959 #define HAVE_TANF 1
19960 _ACEOF
19961
19962 fi
19963
19964 echo "$as_me:$LINENO: checking for tan in -lm" >&5
19965 echo $ECHO_N "checking for tan in -lm... $ECHO_C" >&6
19966 if test "${ac_cv_lib_m_tan+set}" = set; then
19967   echo $ECHO_N "(cached) $ECHO_C" >&6
19968 else
19969   ac_check_lib_save_LIBS=$LIBS
19970 LIBS="-lm  $LIBS"
19971 if test x$gcc_no_link = xyes; then
19972   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19973 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19974    { (exit 1); exit 1; }; }
19975 fi
19976 cat >conftest.$ac_ext <<_ACEOF
19977 /* confdefs.h.  */
19978 _ACEOF
19979 cat confdefs.h >>conftest.$ac_ext
19980 cat >>conftest.$ac_ext <<_ACEOF
19981 /* end confdefs.h.  */
19982
19983 /* Override any gcc2 internal prototype to avoid an error.  */
19984 #ifdef __cplusplus
19985 extern "C"
19986 #endif
19987 /* We use char because int might match the return type of a gcc2
19988    builtin and then its argument prototype would still apply.  */
19989 char tan ();
19990 int
19991 main ()
19992 {
19993 tan ();
19994   ;
19995   return 0;
19996 }
19997 _ACEOF
19998 rm -f conftest.$ac_objext conftest$ac_exeext
19999 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20000   (eval $ac_link) 2>conftest.er1
20001   ac_status=$?
20002   grep -v '^ *+' conftest.er1 >conftest.err
20003   rm -f conftest.er1
20004   cat conftest.err >&5
20005   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20006   (exit $ac_status); } &&
20007          { ac_try='test -z "$ac_c_werror_flag"
20008                          || test ! -s conftest.err'
20009   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20010   (eval $ac_try) 2>&5
20011   ac_status=$?
20012   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20013   (exit $ac_status); }; } &&
20014          { ac_try='test -s conftest$ac_exeext'
20015   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20016   (eval $ac_try) 2>&5
20017   ac_status=$?
20018   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20019   (exit $ac_status); }; }; then
20020   ac_cv_lib_m_tan=yes
20021 else
20022   echo "$as_me: failed program was:" >&5
20023 sed 's/^/| /' conftest.$ac_ext >&5
20024
20025 ac_cv_lib_m_tan=no
20026 fi
20027 rm -f conftest.err conftest.$ac_objext \
20028       conftest$ac_exeext conftest.$ac_ext
20029 LIBS=$ac_check_lib_save_LIBS
20030 fi
20031 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tan" >&5
20032 echo "${ECHO_T}$ac_cv_lib_m_tan" >&6
20033 if test $ac_cv_lib_m_tan = yes; then
20034
20035 cat >>confdefs.h <<\_ACEOF
20036 #define HAVE_TAN 1
20037 _ACEOF
20038
20039 fi
20040
20041 echo "$as_me:$LINENO: checking for tanl in -lm" >&5
20042 echo $ECHO_N "checking for tanl in -lm... $ECHO_C" >&6
20043 if test "${ac_cv_lib_m_tanl+set}" = set; then
20044   echo $ECHO_N "(cached) $ECHO_C" >&6
20045 else
20046   ac_check_lib_save_LIBS=$LIBS
20047 LIBS="-lm  $LIBS"
20048 if test x$gcc_no_link = xyes; then
20049   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20050 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20051    { (exit 1); exit 1; }; }
20052 fi
20053 cat >conftest.$ac_ext <<_ACEOF
20054 /* confdefs.h.  */
20055 _ACEOF
20056 cat confdefs.h >>conftest.$ac_ext
20057 cat >>conftest.$ac_ext <<_ACEOF
20058 /* end confdefs.h.  */
20059
20060 /* Override any gcc2 internal prototype to avoid an error.  */
20061 #ifdef __cplusplus
20062 extern "C"
20063 #endif
20064 /* We use char because int might match the return type of a gcc2
20065    builtin and then its argument prototype would still apply.  */
20066 char tanl ();
20067 int
20068 main ()
20069 {
20070 tanl ();
20071   ;
20072   return 0;
20073 }
20074 _ACEOF
20075 rm -f conftest.$ac_objext conftest$ac_exeext
20076 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20077   (eval $ac_link) 2>conftest.er1
20078   ac_status=$?
20079   grep -v '^ *+' conftest.er1 >conftest.err
20080   rm -f conftest.er1
20081   cat conftest.err >&5
20082   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20083   (exit $ac_status); } &&
20084          { ac_try='test -z "$ac_c_werror_flag"
20085                          || test ! -s conftest.err'
20086   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20087   (eval $ac_try) 2>&5
20088   ac_status=$?
20089   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20090   (exit $ac_status); }; } &&
20091          { ac_try='test -s conftest$ac_exeext'
20092   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20093   (eval $ac_try) 2>&5
20094   ac_status=$?
20095   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20096   (exit $ac_status); }; }; then
20097   ac_cv_lib_m_tanl=yes
20098 else
20099   echo "$as_me: failed program was:" >&5
20100 sed 's/^/| /' conftest.$ac_ext >&5
20101
20102 ac_cv_lib_m_tanl=no
20103 fi
20104 rm -f conftest.err conftest.$ac_objext \
20105       conftest$ac_exeext conftest.$ac_ext
20106 LIBS=$ac_check_lib_save_LIBS
20107 fi
20108 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanl" >&5
20109 echo "${ECHO_T}$ac_cv_lib_m_tanl" >&6
20110 if test $ac_cv_lib_m_tanl = yes; then
20111
20112 cat >>confdefs.h <<\_ACEOF
20113 #define HAVE_TANL 1
20114 _ACEOF
20115
20116 fi
20117
20118 echo "$as_me:$LINENO: checking for ctanf in -lm" >&5
20119 echo $ECHO_N "checking for ctanf in -lm... $ECHO_C" >&6
20120 if test "${ac_cv_lib_m_ctanf+set}" = set; then
20121   echo $ECHO_N "(cached) $ECHO_C" >&6
20122 else
20123   ac_check_lib_save_LIBS=$LIBS
20124 LIBS="-lm  $LIBS"
20125 if test x$gcc_no_link = xyes; then
20126   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20127 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20128    { (exit 1); exit 1; }; }
20129 fi
20130 cat >conftest.$ac_ext <<_ACEOF
20131 /* confdefs.h.  */
20132 _ACEOF
20133 cat confdefs.h >>conftest.$ac_ext
20134 cat >>conftest.$ac_ext <<_ACEOF
20135 /* end confdefs.h.  */
20136
20137 /* Override any gcc2 internal prototype to avoid an error.  */
20138 #ifdef __cplusplus
20139 extern "C"
20140 #endif
20141 /* We use char because int might match the return type of a gcc2
20142    builtin and then its argument prototype would still apply.  */
20143 char ctanf ();
20144 int
20145 main ()
20146 {
20147 ctanf ();
20148   ;
20149   return 0;
20150 }
20151 _ACEOF
20152 rm -f conftest.$ac_objext conftest$ac_exeext
20153 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20154   (eval $ac_link) 2>conftest.er1
20155   ac_status=$?
20156   grep -v '^ *+' conftest.er1 >conftest.err
20157   rm -f conftest.er1
20158   cat conftest.err >&5
20159   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20160   (exit $ac_status); } &&
20161          { ac_try='test -z "$ac_c_werror_flag"
20162                          || test ! -s conftest.err'
20163   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20164   (eval $ac_try) 2>&5
20165   ac_status=$?
20166   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20167   (exit $ac_status); }; } &&
20168          { ac_try='test -s conftest$ac_exeext'
20169   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20170   (eval $ac_try) 2>&5
20171   ac_status=$?
20172   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20173   (exit $ac_status); }; }; then
20174   ac_cv_lib_m_ctanf=yes
20175 else
20176   echo "$as_me: failed program was:" >&5
20177 sed 's/^/| /' conftest.$ac_ext >&5
20178
20179 ac_cv_lib_m_ctanf=no
20180 fi
20181 rm -f conftest.err conftest.$ac_objext \
20182       conftest$ac_exeext conftest.$ac_ext
20183 LIBS=$ac_check_lib_save_LIBS
20184 fi
20185 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanf" >&5
20186 echo "${ECHO_T}$ac_cv_lib_m_ctanf" >&6
20187 if test $ac_cv_lib_m_ctanf = yes; then
20188
20189 cat >>confdefs.h <<\_ACEOF
20190 #define HAVE_CTANF 1
20191 _ACEOF
20192
20193 fi
20194
20195 echo "$as_me:$LINENO: checking for ctan in -lm" >&5
20196 echo $ECHO_N "checking for ctan in -lm... $ECHO_C" >&6
20197 if test "${ac_cv_lib_m_ctan+set}" = set; then
20198   echo $ECHO_N "(cached) $ECHO_C" >&6
20199 else
20200   ac_check_lib_save_LIBS=$LIBS
20201 LIBS="-lm  $LIBS"
20202 if test x$gcc_no_link = xyes; then
20203   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20204 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20205    { (exit 1); exit 1; }; }
20206 fi
20207 cat >conftest.$ac_ext <<_ACEOF
20208 /* confdefs.h.  */
20209 _ACEOF
20210 cat confdefs.h >>conftest.$ac_ext
20211 cat >>conftest.$ac_ext <<_ACEOF
20212 /* end confdefs.h.  */
20213
20214 /* Override any gcc2 internal prototype to avoid an error.  */
20215 #ifdef __cplusplus
20216 extern "C"
20217 #endif
20218 /* We use char because int might match the return type of a gcc2
20219    builtin and then its argument prototype would still apply.  */
20220 char ctan ();
20221 int
20222 main ()
20223 {
20224 ctan ();
20225   ;
20226   return 0;
20227 }
20228 _ACEOF
20229 rm -f conftest.$ac_objext conftest$ac_exeext
20230 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20231   (eval $ac_link) 2>conftest.er1
20232   ac_status=$?
20233   grep -v '^ *+' conftest.er1 >conftest.err
20234   rm -f conftest.er1
20235   cat conftest.err >&5
20236   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20237   (exit $ac_status); } &&
20238          { ac_try='test -z "$ac_c_werror_flag"
20239                          || test ! -s conftest.err'
20240   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20241   (eval $ac_try) 2>&5
20242   ac_status=$?
20243   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20244   (exit $ac_status); }; } &&
20245          { ac_try='test -s conftest$ac_exeext'
20246   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20247   (eval $ac_try) 2>&5
20248   ac_status=$?
20249   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20250   (exit $ac_status); }; }; then
20251   ac_cv_lib_m_ctan=yes
20252 else
20253   echo "$as_me: failed program was:" >&5
20254 sed 's/^/| /' conftest.$ac_ext >&5
20255
20256 ac_cv_lib_m_ctan=no
20257 fi
20258 rm -f conftest.err conftest.$ac_objext \
20259       conftest$ac_exeext conftest.$ac_ext
20260 LIBS=$ac_check_lib_save_LIBS
20261 fi
20262 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctan" >&5
20263 echo "${ECHO_T}$ac_cv_lib_m_ctan" >&6
20264 if test $ac_cv_lib_m_ctan = yes; then
20265
20266 cat >>confdefs.h <<\_ACEOF
20267 #define HAVE_CTAN 1
20268 _ACEOF
20269
20270 fi
20271
20272 echo "$as_me:$LINENO: checking for ctanl in -lm" >&5
20273 echo $ECHO_N "checking for ctanl in -lm... $ECHO_C" >&6
20274 if test "${ac_cv_lib_m_ctanl+set}" = set; then
20275   echo $ECHO_N "(cached) $ECHO_C" >&6
20276 else
20277   ac_check_lib_save_LIBS=$LIBS
20278 LIBS="-lm  $LIBS"
20279 if test x$gcc_no_link = xyes; then
20280   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20281 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20282    { (exit 1); exit 1; }; }
20283 fi
20284 cat >conftest.$ac_ext <<_ACEOF
20285 /* confdefs.h.  */
20286 _ACEOF
20287 cat confdefs.h >>conftest.$ac_ext
20288 cat >>conftest.$ac_ext <<_ACEOF
20289 /* end confdefs.h.  */
20290
20291 /* Override any gcc2 internal prototype to avoid an error.  */
20292 #ifdef __cplusplus
20293 extern "C"
20294 #endif
20295 /* We use char because int might match the return type of a gcc2
20296    builtin and then its argument prototype would still apply.  */
20297 char ctanl ();
20298 int
20299 main ()
20300 {
20301 ctanl ();
20302   ;
20303   return 0;
20304 }
20305 _ACEOF
20306 rm -f conftest.$ac_objext conftest$ac_exeext
20307 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20308   (eval $ac_link) 2>conftest.er1
20309   ac_status=$?
20310   grep -v '^ *+' conftest.er1 >conftest.err
20311   rm -f conftest.er1
20312   cat conftest.err >&5
20313   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20314   (exit $ac_status); } &&
20315          { ac_try='test -z "$ac_c_werror_flag"
20316                          || test ! -s conftest.err'
20317   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20318   (eval $ac_try) 2>&5
20319   ac_status=$?
20320   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20321   (exit $ac_status); }; } &&
20322          { ac_try='test -s conftest$ac_exeext'
20323   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20324   (eval $ac_try) 2>&5
20325   ac_status=$?
20326   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20327   (exit $ac_status); }; }; then
20328   ac_cv_lib_m_ctanl=yes
20329 else
20330   echo "$as_me: failed program was:" >&5
20331 sed 's/^/| /' conftest.$ac_ext >&5
20332
20333 ac_cv_lib_m_ctanl=no
20334 fi
20335 rm -f conftest.err conftest.$ac_objext \
20336       conftest$ac_exeext conftest.$ac_ext
20337 LIBS=$ac_check_lib_save_LIBS
20338 fi
20339 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanl" >&5
20340 echo "${ECHO_T}$ac_cv_lib_m_ctanl" >&6
20341 if test $ac_cv_lib_m_ctanl = yes; then
20342
20343 cat >>confdefs.h <<\_ACEOF
20344 #define HAVE_CTANL 1
20345 _ACEOF
20346
20347 fi
20348
20349 echo "$as_me:$LINENO: checking for tanhf in -lm" >&5
20350 echo $ECHO_N "checking for tanhf in -lm... $ECHO_C" >&6
20351 if test "${ac_cv_lib_m_tanhf+set}" = set; then
20352   echo $ECHO_N "(cached) $ECHO_C" >&6
20353 else
20354   ac_check_lib_save_LIBS=$LIBS
20355 LIBS="-lm  $LIBS"
20356 if test x$gcc_no_link = xyes; then
20357   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20358 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20359    { (exit 1); exit 1; }; }
20360 fi
20361 cat >conftest.$ac_ext <<_ACEOF
20362 /* confdefs.h.  */
20363 _ACEOF
20364 cat confdefs.h >>conftest.$ac_ext
20365 cat >>conftest.$ac_ext <<_ACEOF
20366 /* end confdefs.h.  */
20367
20368 /* Override any gcc2 internal prototype to avoid an error.  */
20369 #ifdef __cplusplus
20370 extern "C"
20371 #endif
20372 /* We use char because int might match the return type of a gcc2
20373    builtin and then its argument prototype would still apply.  */
20374 char tanhf ();
20375 int
20376 main ()
20377 {
20378 tanhf ();
20379   ;
20380   return 0;
20381 }
20382 _ACEOF
20383 rm -f conftest.$ac_objext conftest$ac_exeext
20384 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20385   (eval $ac_link) 2>conftest.er1
20386   ac_status=$?
20387   grep -v '^ *+' conftest.er1 >conftest.err
20388   rm -f conftest.er1
20389   cat conftest.err >&5
20390   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20391   (exit $ac_status); } &&
20392          { ac_try='test -z "$ac_c_werror_flag"
20393                          || test ! -s conftest.err'
20394   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20395   (eval $ac_try) 2>&5
20396   ac_status=$?
20397   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20398   (exit $ac_status); }; } &&
20399          { ac_try='test -s conftest$ac_exeext'
20400   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20401   (eval $ac_try) 2>&5
20402   ac_status=$?
20403   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20404   (exit $ac_status); }; }; then
20405   ac_cv_lib_m_tanhf=yes
20406 else
20407   echo "$as_me: failed program was:" >&5
20408 sed 's/^/| /' conftest.$ac_ext >&5
20409
20410 ac_cv_lib_m_tanhf=no
20411 fi
20412 rm -f conftest.err conftest.$ac_objext \
20413       conftest$ac_exeext conftest.$ac_ext
20414 LIBS=$ac_check_lib_save_LIBS
20415 fi
20416 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanhf" >&5
20417 echo "${ECHO_T}$ac_cv_lib_m_tanhf" >&6
20418 if test $ac_cv_lib_m_tanhf = yes; then
20419
20420 cat >>confdefs.h <<\_ACEOF
20421 #define HAVE_TANHF 1
20422 _ACEOF
20423
20424 fi
20425
20426 echo "$as_me:$LINENO: checking for tanh in -lm" >&5
20427 echo $ECHO_N "checking for tanh in -lm... $ECHO_C" >&6
20428 if test "${ac_cv_lib_m_tanh+set}" = set; then
20429   echo $ECHO_N "(cached) $ECHO_C" >&6
20430 else
20431   ac_check_lib_save_LIBS=$LIBS
20432 LIBS="-lm  $LIBS"
20433 if test x$gcc_no_link = xyes; then
20434   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20435 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20436    { (exit 1); exit 1; }; }
20437 fi
20438 cat >conftest.$ac_ext <<_ACEOF
20439 /* confdefs.h.  */
20440 _ACEOF
20441 cat confdefs.h >>conftest.$ac_ext
20442 cat >>conftest.$ac_ext <<_ACEOF
20443 /* end confdefs.h.  */
20444
20445 /* Override any gcc2 internal prototype to avoid an error.  */
20446 #ifdef __cplusplus
20447 extern "C"
20448 #endif
20449 /* We use char because int might match the return type of a gcc2
20450    builtin and then its argument prototype would still apply.  */
20451 char tanh ();
20452 int
20453 main ()
20454 {
20455 tanh ();
20456   ;
20457   return 0;
20458 }
20459 _ACEOF
20460 rm -f conftest.$ac_objext conftest$ac_exeext
20461 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20462   (eval $ac_link) 2>conftest.er1
20463   ac_status=$?
20464   grep -v '^ *+' conftest.er1 >conftest.err
20465   rm -f conftest.er1
20466   cat conftest.err >&5
20467   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20468   (exit $ac_status); } &&
20469          { ac_try='test -z "$ac_c_werror_flag"
20470                          || test ! -s conftest.err'
20471   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20472   (eval $ac_try) 2>&5
20473   ac_status=$?
20474   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20475   (exit $ac_status); }; } &&
20476          { ac_try='test -s conftest$ac_exeext'
20477   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20478   (eval $ac_try) 2>&5
20479   ac_status=$?
20480   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20481   (exit $ac_status); }; }; then
20482   ac_cv_lib_m_tanh=yes
20483 else
20484   echo "$as_me: failed program was:" >&5
20485 sed 's/^/| /' conftest.$ac_ext >&5
20486
20487 ac_cv_lib_m_tanh=no
20488 fi
20489 rm -f conftest.err conftest.$ac_objext \
20490       conftest$ac_exeext conftest.$ac_ext
20491 LIBS=$ac_check_lib_save_LIBS
20492 fi
20493 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanh" >&5
20494 echo "${ECHO_T}$ac_cv_lib_m_tanh" >&6
20495 if test $ac_cv_lib_m_tanh = yes; then
20496
20497 cat >>confdefs.h <<\_ACEOF
20498 #define HAVE_TANH 1
20499 _ACEOF
20500
20501 fi
20502
20503 echo "$as_me:$LINENO: checking for tanhl in -lm" >&5
20504 echo $ECHO_N "checking for tanhl in -lm... $ECHO_C" >&6
20505 if test "${ac_cv_lib_m_tanhl+set}" = set; then
20506   echo $ECHO_N "(cached) $ECHO_C" >&6
20507 else
20508   ac_check_lib_save_LIBS=$LIBS
20509 LIBS="-lm  $LIBS"
20510 if test x$gcc_no_link = xyes; then
20511   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20512 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20513    { (exit 1); exit 1; }; }
20514 fi
20515 cat >conftest.$ac_ext <<_ACEOF
20516 /* confdefs.h.  */
20517 _ACEOF
20518 cat confdefs.h >>conftest.$ac_ext
20519 cat >>conftest.$ac_ext <<_ACEOF
20520 /* end confdefs.h.  */
20521
20522 /* Override any gcc2 internal prototype to avoid an error.  */
20523 #ifdef __cplusplus
20524 extern "C"
20525 #endif
20526 /* We use char because int might match the return type of a gcc2
20527    builtin and then its argument prototype would still apply.  */
20528 char tanhl ();
20529 int
20530 main ()
20531 {
20532 tanhl ();
20533   ;
20534   return 0;
20535 }
20536 _ACEOF
20537 rm -f conftest.$ac_objext conftest$ac_exeext
20538 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20539   (eval $ac_link) 2>conftest.er1
20540   ac_status=$?
20541   grep -v '^ *+' conftest.er1 >conftest.err
20542   rm -f conftest.er1
20543   cat conftest.err >&5
20544   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20545   (exit $ac_status); } &&
20546          { ac_try='test -z "$ac_c_werror_flag"
20547                          || test ! -s conftest.err'
20548   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20549   (eval $ac_try) 2>&5
20550   ac_status=$?
20551   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20552   (exit $ac_status); }; } &&
20553          { ac_try='test -s conftest$ac_exeext'
20554   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20555   (eval $ac_try) 2>&5
20556   ac_status=$?
20557   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20558   (exit $ac_status); }; }; then
20559   ac_cv_lib_m_tanhl=yes
20560 else
20561   echo "$as_me: failed program was:" >&5
20562 sed 's/^/| /' conftest.$ac_ext >&5
20563
20564 ac_cv_lib_m_tanhl=no
20565 fi
20566 rm -f conftest.err conftest.$ac_objext \
20567       conftest$ac_exeext conftest.$ac_ext
20568 LIBS=$ac_check_lib_save_LIBS
20569 fi
20570 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanhl" >&5
20571 echo "${ECHO_T}$ac_cv_lib_m_tanhl" >&6
20572 if test $ac_cv_lib_m_tanhl = yes; then
20573
20574 cat >>confdefs.h <<\_ACEOF
20575 #define HAVE_TANHL 1
20576 _ACEOF
20577
20578 fi
20579
20580 echo "$as_me:$LINENO: checking for ctanhf in -lm" >&5
20581 echo $ECHO_N "checking for ctanhf in -lm... $ECHO_C" >&6
20582 if test "${ac_cv_lib_m_ctanhf+set}" = set; then
20583   echo $ECHO_N "(cached) $ECHO_C" >&6
20584 else
20585   ac_check_lib_save_LIBS=$LIBS
20586 LIBS="-lm  $LIBS"
20587 if test x$gcc_no_link = xyes; then
20588   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20589 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20590    { (exit 1); exit 1; }; }
20591 fi
20592 cat >conftest.$ac_ext <<_ACEOF
20593 /* confdefs.h.  */
20594 _ACEOF
20595 cat confdefs.h >>conftest.$ac_ext
20596 cat >>conftest.$ac_ext <<_ACEOF
20597 /* end confdefs.h.  */
20598
20599 /* Override any gcc2 internal prototype to avoid an error.  */
20600 #ifdef __cplusplus
20601 extern "C"
20602 #endif
20603 /* We use char because int might match the return type of a gcc2
20604    builtin and then its argument prototype would still apply.  */
20605 char ctanhf ();
20606 int
20607 main ()
20608 {
20609 ctanhf ();
20610   ;
20611   return 0;
20612 }
20613 _ACEOF
20614 rm -f conftest.$ac_objext conftest$ac_exeext
20615 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20616   (eval $ac_link) 2>conftest.er1
20617   ac_status=$?
20618   grep -v '^ *+' conftest.er1 >conftest.err
20619   rm -f conftest.er1
20620   cat conftest.err >&5
20621   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20622   (exit $ac_status); } &&
20623          { ac_try='test -z "$ac_c_werror_flag"
20624                          || test ! -s conftest.err'
20625   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20626   (eval $ac_try) 2>&5
20627   ac_status=$?
20628   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20629   (exit $ac_status); }; } &&
20630          { ac_try='test -s conftest$ac_exeext'
20631   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20632   (eval $ac_try) 2>&5
20633   ac_status=$?
20634   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20635   (exit $ac_status); }; }; then
20636   ac_cv_lib_m_ctanhf=yes
20637 else
20638   echo "$as_me: failed program was:" >&5
20639 sed 's/^/| /' conftest.$ac_ext >&5
20640
20641 ac_cv_lib_m_ctanhf=no
20642 fi
20643 rm -f conftest.err conftest.$ac_objext \
20644       conftest$ac_exeext conftest.$ac_ext
20645 LIBS=$ac_check_lib_save_LIBS
20646 fi
20647 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanhf" >&5
20648 echo "${ECHO_T}$ac_cv_lib_m_ctanhf" >&6
20649 if test $ac_cv_lib_m_ctanhf = yes; then
20650
20651 cat >>confdefs.h <<\_ACEOF
20652 #define HAVE_CTANHF 1
20653 _ACEOF
20654
20655 fi
20656
20657 echo "$as_me:$LINENO: checking for ctanh in -lm" >&5
20658 echo $ECHO_N "checking for ctanh in -lm... $ECHO_C" >&6
20659 if test "${ac_cv_lib_m_ctanh+set}" = set; then
20660   echo $ECHO_N "(cached) $ECHO_C" >&6
20661 else
20662   ac_check_lib_save_LIBS=$LIBS
20663 LIBS="-lm  $LIBS"
20664 if test x$gcc_no_link = xyes; then
20665   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20666 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20667    { (exit 1); exit 1; }; }
20668 fi
20669 cat >conftest.$ac_ext <<_ACEOF
20670 /* confdefs.h.  */
20671 _ACEOF
20672 cat confdefs.h >>conftest.$ac_ext
20673 cat >>conftest.$ac_ext <<_ACEOF
20674 /* end confdefs.h.  */
20675
20676 /* Override any gcc2 internal prototype to avoid an error.  */
20677 #ifdef __cplusplus
20678 extern "C"
20679 #endif
20680 /* We use char because int might match the return type of a gcc2
20681    builtin and then its argument prototype would still apply.  */
20682 char ctanh ();
20683 int
20684 main ()
20685 {
20686 ctanh ();
20687   ;
20688   return 0;
20689 }
20690 _ACEOF
20691 rm -f conftest.$ac_objext conftest$ac_exeext
20692 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20693   (eval $ac_link) 2>conftest.er1
20694   ac_status=$?
20695   grep -v '^ *+' conftest.er1 >conftest.err
20696   rm -f conftest.er1
20697   cat conftest.err >&5
20698   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20699   (exit $ac_status); } &&
20700          { ac_try='test -z "$ac_c_werror_flag"
20701                          || test ! -s conftest.err'
20702   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20703   (eval $ac_try) 2>&5
20704   ac_status=$?
20705   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20706   (exit $ac_status); }; } &&
20707          { ac_try='test -s conftest$ac_exeext'
20708   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20709   (eval $ac_try) 2>&5
20710   ac_status=$?
20711   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20712   (exit $ac_status); }; }; then
20713   ac_cv_lib_m_ctanh=yes
20714 else
20715   echo "$as_me: failed program was:" >&5
20716 sed 's/^/| /' conftest.$ac_ext >&5
20717
20718 ac_cv_lib_m_ctanh=no
20719 fi
20720 rm -f conftest.err conftest.$ac_objext \
20721       conftest$ac_exeext conftest.$ac_ext
20722 LIBS=$ac_check_lib_save_LIBS
20723 fi
20724 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanh" >&5
20725 echo "${ECHO_T}$ac_cv_lib_m_ctanh" >&6
20726 if test $ac_cv_lib_m_ctanh = yes; then
20727
20728 cat >>confdefs.h <<\_ACEOF
20729 #define HAVE_CTANH 1
20730 _ACEOF
20731
20732 fi
20733
20734 echo "$as_me:$LINENO: checking for ctanhl in -lm" >&5
20735 echo $ECHO_N "checking for ctanhl in -lm... $ECHO_C" >&6
20736 if test "${ac_cv_lib_m_ctanhl+set}" = set; then
20737   echo $ECHO_N "(cached) $ECHO_C" >&6
20738 else
20739   ac_check_lib_save_LIBS=$LIBS
20740 LIBS="-lm  $LIBS"
20741 if test x$gcc_no_link = xyes; then
20742   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20743 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20744    { (exit 1); exit 1; }; }
20745 fi
20746 cat >conftest.$ac_ext <<_ACEOF
20747 /* confdefs.h.  */
20748 _ACEOF
20749 cat confdefs.h >>conftest.$ac_ext
20750 cat >>conftest.$ac_ext <<_ACEOF
20751 /* end confdefs.h.  */
20752
20753 /* Override any gcc2 internal prototype to avoid an error.  */
20754 #ifdef __cplusplus
20755 extern "C"
20756 #endif
20757 /* We use char because int might match the return type of a gcc2
20758    builtin and then its argument prototype would still apply.  */
20759 char ctanhl ();
20760 int
20761 main ()
20762 {
20763 ctanhl ();
20764   ;
20765   return 0;
20766 }
20767 _ACEOF
20768 rm -f conftest.$ac_objext conftest$ac_exeext
20769 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20770   (eval $ac_link) 2>conftest.er1
20771   ac_status=$?
20772   grep -v '^ *+' conftest.er1 >conftest.err
20773   rm -f conftest.er1
20774   cat conftest.err >&5
20775   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20776   (exit $ac_status); } &&
20777          { ac_try='test -z "$ac_c_werror_flag"
20778                          || test ! -s conftest.err'
20779   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20780   (eval $ac_try) 2>&5
20781   ac_status=$?
20782   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20783   (exit $ac_status); }; } &&
20784          { ac_try='test -s conftest$ac_exeext'
20785   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20786   (eval $ac_try) 2>&5
20787   ac_status=$?
20788   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20789   (exit $ac_status); }; }; then
20790   ac_cv_lib_m_ctanhl=yes
20791 else
20792   echo "$as_me: failed program was:" >&5
20793 sed 's/^/| /' conftest.$ac_ext >&5
20794
20795 ac_cv_lib_m_ctanhl=no
20796 fi
20797 rm -f conftest.err conftest.$ac_objext \
20798       conftest$ac_exeext conftest.$ac_ext
20799 LIBS=$ac_check_lib_save_LIBS
20800 fi
20801 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanhl" >&5
20802 echo "${ECHO_T}$ac_cv_lib_m_ctanhl" >&6
20803 if test $ac_cv_lib_m_ctanhl = yes; then
20804
20805 cat >>confdefs.h <<\_ACEOF
20806 #define HAVE_CTANHL 1
20807 _ACEOF
20808
20809 fi
20810
20811 echo "$as_me:$LINENO: checking for truncf in -lm" >&5
20812 echo $ECHO_N "checking for truncf in -lm... $ECHO_C" >&6
20813 if test "${ac_cv_lib_m_truncf+set}" = set; then
20814   echo $ECHO_N "(cached) $ECHO_C" >&6
20815 else
20816   ac_check_lib_save_LIBS=$LIBS
20817 LIBS="-lm  $LIBS"
20818 if test x$gcc_no_link = xyes; then
20819   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20820 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20821    { (exit 1); exit 1; }; }
20822 fi
20823 cat >conftest.$ac_ext <<_ACEOF
20824 /* confdefs.h.  */
20825 _ACEOF
20826 cat confdefs.h >>conftest.$ac_ext
20827 cat >>conftest.$ac_ext <<_ACEOF
20828 /* end confdefs.h.  */
20829
20830 /* Override any gcc2 internal prototype to avoid an error.  */
20831 #ifdef __cplusplus
20832 extern "C"
20833 #endif
20834 /* We use char because int might match the return type of a gcc2
20835    builtin and then its argument prototype would still apply.  */
20836 char truncf ();
20837 int
20838 main ()
20839 {
20840 truncf ();
20841   ;
20842   return 0;
20843 }
20844 _ACEOF
20845 rm -f conftest.$ac_objext conftest$ac_exeext
20846 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20847   (eval $ac_link) 2>conftest.er1
20848   ac_status=$?
20849   grep -v '^ *+' conftest.er1 >conftest.err
20850   rm -f conftest.er1
20851   cat conftest.err >&5
20852   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20853   (exit $ac_status); } &&
20854          { ac_try='test -z "$ac_c_werror_flag"
20855                          || test ! -s conftest.err'
20856   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20857   (eval $ac_try) 2>&5
20858   ac_status=$?
20859   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20860   (exit $ac_status); }; } &&
20861          { ac_try='test -s conftest$ac_exeext'
20862   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20863   (eval $ac_try) 2>&5
20864   ac_status=$?
20865   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20866   (exit $ac_status); }; }; then
20867   ac_cv_lib_m_truncf=yes
20868 else
20869   echo "$as_me: failed program was:" >&5
20870 sed 's/^/| /' conftest.$ac_ext >&5
20871
20872 ac_cv_lib_m_truncf=no
20873 fi
20874 rm -f conftest.err conftest.$ac_objext \
20875       conftest$ac_exeext conftest.$ac_ext
20876 LIBS=$ac_check_lib_save_LIBS
20877 fi
20878 echo "$as_me:$LINENO: result: $ac_cv_lib_m_truncf" >&5
20879 echo "${ECHO_T}$ac_cv_lib_m_truncf" >&6
20880 if test $ac_cv_lib_m_truncf = yes; then
20881
20882 cat >>confdefs.h <<\_ACEOF
20883 #define HAVE_TRUNCF 1
20884 _ACEOF
20885
20886 fi
20887
20888 echo "$as_me:$LINENO: checking for trunc in -lm" >&5
20889 echo $ECHO_N "checking for trunc in -lm... $ECHO_C" >&6
20890 if test "${ac_cv_lib_m_trunc+set}" = set; then
20891   echo $ECHO_N "(cached) $ECHO_C" >&6
20892 else
20893   ac_check_lib_save_LIBS=$LIBS
20894 LIBS="-lm  $LIBS"
20895 if test x$gcc_no_link = xyes; then
20896   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20897 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20898    { (exit 1); exit 1; }; }
20899 fi
20900 cat >conftest.$ac_ext <<_ACEOF
20901 /* confdefs.h.  */
20902 _ACEOF
20903 cat confdefs.h >>conftest.$ac_ext
20904 cat >>conftest.$ac_ext <<_ACEOF
20905 /* end confdefs.h.  */
20906
20907 /* Override any gcc2 internal prototype to avoid an error.  */
20908 #ifdef __cplusplus
20909 extern "C"
20910 #endif
20911 /* We use char because int might match the return type of a gcc2
20912    builtin and then its argument prototype would still apply.  */
20913 char trunc ();
20914 int
20915 main ()
20916 {
20917 trunc ();
20918   ;
20919   return 0;
20920 }
20921 _ACEOF
20922 rm -f conftest.$ac_objext conftest$ac_exeext
20923 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20924   (eval $ac_link) 2>conftest.er1
20925   ac_status=$?
20926   grep -v '^ *+' conftest.er1 >conftest.err
20927   rm -f conftest.er1
20928   cat conftest.err >&5
20929   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20930   (exit $ac_status); } &&
20931          { ac_try='test -z "$ac_c_werror_flag"
20932                          || test ! -s conftest.err'
20933   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20934   (eval $ac_try) 2>&5
20935   ac_status=$?
20936   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20937   (exit $ac_status); }; } &&
20938          { ac_try='test -s conftest$ac_exeext'
20939   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20940   (eval $ac_try) 2>&5
20941   ac_status=$?
20942   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20943   (exit $ac_status); }; }; then
20944   ac_cv_lib_m_trunc=yes
20945 else
20946   echo "$as_me: failed program was:" >&5
20947 sed 's/^/| /' conftest.$ac_ext >&5
20948
20949 ac_cv_lib_m_trunc=no
20950 fi
20951 rm -f conftest.err conftest.$ac_objext \
20952       conftest$ac_exeext conftest.$ac_ext
20953 LIBS=$ac_check_lib_save_LIBS
20954 fi
20955 echo "$as_me:$LINENO: result: $ac_cv_lib_m_trunc" >&5
20956 echo "${ECHO_T}$ac_cv_lib_m_trunc" >&6
20957 if test $ac_cv_lib_m_trunc = yes; then
20958
20959 cat >>confdefs.h <<\_ACEOF
20960 #define HAVE_TRUNC 1
20961 _ACEOF
20962
20963 fi
20964
20965 echo "$as_me:$LINENO: checking for truncl in -lm" >&5
20966 echo $ECHO_N "checking for truncl in -lm... $ECHO_C" >&6
20967 if test "${ac_cv_lib_m_truncl+set}" = set; then
20968   echo $ECHO_N "(cached) $ECHO_C" >&6
20969 else
20970   ac_check_lib_save_LIBS=$LIBS
20971 LIBS="-lm  $LIBS"
20972 if test x$gcc_no_link = xyes; then
20973   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20974 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20975    { (exit 1); exit 1; }; }
20976 fi
20977 cat >conftest.$ac_ext <<_ACEOF
20978 /* confdefs.h.  */
20979 _ACEOF
20980 cat confdefs.h >>conftest.$ac_ext
20981 cat >>conftest.$ac_ext <<_ACEOF
20982 /* end confdefs.h.  */
20983
20984 /* Override any gcc2 internal prototype to avoid an error.  */
20985 #ifdef __cplusplus
20986 extern "C"
20987 #endif
20988 /* We use char because int might match the return type of a gcc2
20989    builtin and then its argument prototype would still apply.  */
20990 char truncl ();
20991 int
20992 main ()
20993 {
20994 truncl ();
20995   ;
20996   return 0;
20997 }
20998 _ACEOF
20999 rm -f conftest.$ac_objext conftest$ac_exeext
21000 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21001   (eval $ac_link) 2>conftest.er1
21002   ac_status=$?
21003   grep -v '^ *+' conftest.er1 >conftest.err
21004   rm -f conftest.er1
21005   cat conftest.err >&5
21006   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21007   (exit $ac_status); } &&
21008          { ac_try='test -z "$ac_c_werror_flag"
21009                          || test ! -s conftest.err'
21010   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21011   (eval $ac_try) 2>&5
21012   ac_status=$?
21013   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21014   (exit $ac_status); }; } &&
21015          { ac_try='test -s conftest$ac_exeext'
21016   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21017   (eval $ac_try) 2>&5
21018   ac_status=$?
21019   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21020   (exit $ac_status); }; }; then
21021   ac_cv_lib_m_truncl=yes
21022 else
21023   echo "$as_me: failed program was:" >&5
21024 sed 's/^/| /' conftest.$ac_ext >&5
21025
21026 ac_cv_lib_m_truncl=no
21027 fi
21028 rm -f conftest.err conftest.$ac_objext \
21029       conftest$ac_exeext conftest.$ac_ext
21030 LIBS=$ac_check_lib_save_LIBS
21031 fi
21032 echo "$as_me:$LINENO: result: $ac_cv_lib_m_truncl" >&5
21033 echo "${ECHO_T}$ac_cv_lib_m_truncl" >&6
21034 if test $ac_cv_lib_m_truncl = yes; then
21035
21036 cat >>confdefs.h <<\_ACEOF
21037 #define HAVE_TRUNCL 1
21038 _ACEOF
21039
21040 fi
21041
21042 echo "$as_me:$LINENO: checking for erff in -lm" >&5
21043 echo $ECHO_N "checking for erff in -lm... $ECHO_C" >&6
21044 if test "${ac_cv_lib_m_erff+set}" = set; then
21045   echo $ECHO_N "(cached) $ECHO_C" >&6
21046 else
21047   ac_check_lib_save_LIBS=$LIBS
21048 LIBS="-lm  $LIBS"
21049 if test x$gcc_no_link = xyes; then
21050   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21051 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21052    { (exit 1); exit 1; }; }
21053 fi
21054 cat >conftest.$ac_ext <<_ACEOF
21055 /* confdefs.h.  */
21056 _ACEOF
21057 cat confdefs.h >>conftest.$ac_ext
21058 cat >>conftest.$ac_ext <<_ACEOF
21059 /* end confdefs.h.  */
21060
21061 /* Override any gcc2 internal prototype to avoid an error.  */
21062 #ifdef __cplusplus
21063 extern "C"
21064 #endif
21065 /* We use char because int might match the return type of a gcc2
21066    builtin and then its argument prototype would still apply.  */
21067 char erff ();
21068 int
21069 main ()
21070 {
21071 erff ();
21072   ;
21073   return 0;
21074 }
21075 _ACEOF
21076 rm -f conftest.$ac_objext conftest$ac_exeext
21077 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21078   (eval $ac_link) 2>conftest.er1
21079   ac_status=$?
21080   grep -v '^ *+' conftest.er1 >conftest.err
21081   rm -f conftest.er1
21082   cat conftest.err >&5
21083   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21084   (exit $ac_status); } &&
21085          { ac_try='test -z "$ac_c_werror_flag"
21086                          || test ! -s conftest.err'
21087   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21088   (eval $ac_try) 2>&5
21089   ac_status=$?
21090   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21091   (exit $ac_status); }; } &&
21092          { ac_try='test -s conftest$ac_exeext'
21093   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21094   (eval $ac_try) 2>&5
21095   ac_status=$?
21096   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21097   (exit $ac_status); }; }; then
21098   ac_cv_lib_m_erff=yes
21099 else
21100   echo "$as_me: failed program was:" >&5
21101 sed 's/^/| /' conftest.$ac_ext >&5
21102
21103 ac_cv_lib_m_erff=no
21104 fi
21105 rm -f conftest.err conftest.$ac_objext \
21106       conftest$ac_exeext conftest.$ac_ext
21107 LIBS=$ac_check_lib_save_LIBS
21108 fi
21109 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erff" >&5
21110 echo "${ECHO_T}$ac_cv_lib_m_erff" >&6
21111 if test $ac_cv_lib_m_erff = yes; then
21112
21113 cat >>confdefs.h <<\_ACEOF
21114 #define HAVE_ERFF 1
21115 _ACEOF
21116
21117 fi
21118
21119 echo "$as_me:$LINENO: checking for erf in -lm" >&5
21120 echo $ECHO_N "checking for erf in -lm... $ECHO_C" >&6
21121 if test "${ac_cv_lib_m_erf+set}" = set; then
21122   echo $ECHO_N "(cached) $ECHO_C" >&6
21123 else
21124   ac_check_lib_save_LIBS=$LIBS
21125 LIBS="-lm  $LIBS"
21126 if test x$gcc_no_link = xyes; then
21127   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21128 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21129    { (exit 1); exit 1; }; }
21130 fi
21131 cat >conftest.$ac_ext <<_ACEOF
21132 /* confdefs.h.  */
21133 _ACEOF
21134 cat confdefs.h >>conftest.$ac_ext
21135 cat >>conftest.$ac_ext <<_ACEOF
21136 /* end confdefs.h.  */
21137
21138 /* Override any gcc2 internal prototype to avoid an error.  */
21139 #ifdef __cplusplus
21140 extern "C"
21141 #endif
21142 /* We use char because int might match the return type of a gcc2
21143    builtin and then its argument prototype would still apply.  */
21144 char erf ();
21145 int
21146 main ()
21147 {
21148 erf ();
21149   ;
21150   return 0;
21151 }
21152 _ACEOF
21153 rm -f conftest.$ac_objext conftest$ac_exeext
21154 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21155   (eval $ac_link) 2>conftest.er1
21156   ac_status=$?
21157   grep -v '^ *+' conftest.er1 >conftest.err
21158   rm -f conftest.er1
21159   cat conftest.err >&5
21160   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21161   (exit $ac_status); } &&
21162          { ac_try='test -z "$ac_c_werror_flag"
21163                          || test ! -s conftest.err'
21164   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21165   (eval $ac_try) 2>&5
21166   ac_status=$?
21167   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21168   (exit $ac_status); }; } &&
21169          { ac_try='test -s conftest$ac_exeext'
21170   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21171   (eval $ac_try) 2>&5
21172   ac_status=$?
21173   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21174   (exit $ac_status); }; }; then
21175   ac_cv_lib_m_erf=yes
21176 else
21177   echo "$as_me: failed program was:" >&5
21178 sed 's/^/| /' conftest.$ac_ext >&5
21179
21180 ac_cv_lib_m_erf=no
21181 fi
21182 rm -f conftest.err conftest.$ac_objext \
21183       conftest$ac_exeext conftest.$ac_ext
21184 LIBS=$ac_check_lib_save_LIBS
21185 fi
21186 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erf" >&5
21187 echo "${ECHO_T}$ac_cv_lib_m_erf" >&6
21188 if test $ac_cv_lib_m_erf = yes; then
21189
21190 cat >>confdefs.h <<\_ACEOF
21191 #define HAVE_ERF 1
21192 _ACEOF
21193
21194 fi
21195
21196 echo "$as_me:$LINENO: checking for erfl in -lm" >&5
21197 echo $ECHO_N "checking for erfl in -lm... $ECHO_C" >&6
21198 if test "${ac_cv_lib_m_erfl+set}" = set; then
21199   echo $ECHO_N "(cached) $ECHO_C" >&6
21200 else
21201   ac_check_lib_save_LIBS=$LIBS
21202 LIBS="-lm  $LIBS"
21203 if test x$gcc_no_link = xyes; then
21204   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21205 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21206    { (exit 1); exit 1; }; }
21207 fi
21208 cat >conftest.$ac_ext <<_ACEOF
21209 /* confdefs.h.  */
21210 _ACEOF
21211 cat confdefs.h >>conftest.$ac_ext
21212 cat >>conftest.$ac_ext <<_ACEOF
21213 /* end confdefs.h.  */
21214
21215 /* Override any gcc2 internal prototype to avoid an error.  */
21216 #ifdef __cplusplus
21217 extern "C"
21218 #endif
21219 /* We use char because int might match the return type of a gcc2
21220    builtin and then its argument prototype would still apply.  */
21221 char erfl ();
21222 int
21223 main ()
21224 {
21225 erfl ();
21226   ;
21227   return 0;
21228 }
21229 _ACEOF
21230 rm -f conftest.$ac_objext conftest$ac_exeext
21231 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21232   (eval $ac_link) 2>conftest.er1
21233   ac_status=$?
21234   grep -v '^ *+' conftest.er1 >conftest.err
21235   rm -f conftest.er1
21236   cat conftest.err >&5
21237   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21238   (exit $ac_status); } &&
21239          { ac_try='test -z "$ac_c_werror_flag"
21240                          || test ! -s conftest.err'
21241   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21242   (eval $ac_try) 2>&5
21243   ac_status=$?
21244   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21245   (exit $ac_status); }; } &&
21246          { ac_try='test -s conftest$ac_exeext'
21247   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21248   (eval $ac_try) 2>&5
21249   ac_status=$?
21250   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21251   (exit $ac_status); }; }; then
21252   ac_cv_lib_m_erfl=yes
21253 else
21254   echo "$as_me: failed program was:" >&5
21255 sed 's/^/| /' conftest.$ac_ext >&5
21256
21257 ac_cv_lib_m_erfl=no
21258 fi
21259 rm -f conftest.err conftest.$ac_objext \
21260       conftest$ac_exeext conftest.$ac_ext
21261 LIBS=$ac_check_lib_save_LIBS
21262 fi
21263 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfl" >&5
21264 echo "${ECHO_T}$ac_cv_lib_m_erfl" >&6
21265 if test $ac_cv_lib_m_erfl = yes; then
21266
21267 cat >>confdefs.h <<\_ACEOF
21268 #define HAVE_ERFL 1
21269 _ACEOF
21270
21271 fi
21272
21273 echo "$as_me:$LINENO: checking for erfcf in -lm" >&5
21274 echo $ECHO_N "checking for erfcf in -lm... $ECHO_C" >&6
21275 if test "${ac_cv_lib_m_erfcf+set}" = set; then
21276   echo $ECHO_N "(cached) $ECHO_C" >&6
21277 else
21278   ac_check_lib_save_LIBS=$LIBS
21279 LIBS="-lm  $LIBS"
21280 if test x$gcc_no_link = xyes; then
21281   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21282 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21283    { (exit 1); exit 1; }; }
21284 fi
21285 cat >conftest.$ac_ext <<_ACEOF
21286 /* confdefs.h.  */
21287 _ACEOF
21288 cat confdefs.h >>conftest.$ac_ext
21289 cat >>conftest.$ac_ext <<_ACEOF
21290 /* end confdefs.h.  */
21291
21292 /* Override any gcc2 internal prototype to avoid an error.  */
21293 #ifdef __cplusplus
21294 extern "C"
21295 #endif
21296 /* We use char because int might match the return type of a gcc2
21297    builtin and then its argument prototype would still apply.  */
21298 char erfcf ();
21299 int
21300 main ()
21301 {
21302 erfcf ();
21303   ;
21304   return 0;
21305 }
21306 _ACEOF
21307 rm -f conftest.$ac_objext conftest$ac_exeext
21308 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21309   (eval $ac_link) 2>conftest.er1
21310   ac_status=$?
21311   grep -v '^ *+' conftest.er1 >conftest.err
21312   rm -f conftest.er1
21313   cat conftest.err >&5
21314   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21315   (exit $ac_status); } &&
21316          { ac_try='test -z "$ac_c_werror_flag"
21317                          || test ! -s conftest.err'
21318   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21319   (eval $ac_try) 2>&5
21320   ac_status=$?
21321   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21322   (exit $ac_status); }; } &&
21323          { ac_try='test -s conftest$ac_exeext'
21324   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21325   (eval $ac_try) 2>&5
21326   ac_status=$?
21327   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21328   (exit $ac_status); }; }; then
21329   ac_cv_lib_m_erfcf=yes
21330 else
21331   echo "$as_me: failed program was:" >&5
21332 sed 's/^/| /' conftest.$ac_ext >&5
21333
21334 ac_cv_lib_m_erfcf=no
21335 fi
21336 rm -f conftest.err conftest.$ac_objext \
21337       conftest$ac_exeext conftest.$ac_ext
21338 LIBS=$ac_check_lib_save_LIBS
21339 fi
21340 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfcf" >&5
21341 echo "${ECHO_T}$ac_cv_lib_m_erfcf" >&6
21342 if test $ac_cv_lib_m_erfcf = yes; then
21343
21344 cat >>confdefs.h <<\_ACEOF
21345 #define HAVE_ERFCF 1
21346 _ACEOF
21347
21348 fi
21349
21350 echo "$as_me:$LINENO: checking for erfc in -lm" >&5
21351 echo $ECHO_N "checking for erfc in -lm... $ECHO_C" >&6
21352 if test "${ac_cv_lib_m_erfc+set}" = set; then
21353   echo $ECHO_N "(cached) $ECHO_C" >&6
21354 else
21355   ac_check_lib_save_LIBS=$LIBS
21356 LIBS="-lm  $LIBS"
21357 if test x$gcc_no_link = xyes; then
21358   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21359 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21360    { (exit 1); exit 1; }; }
21361 fi
21362 cat >conftest.$ac_ext <<_ACEOF
21363 /* confdefs.h.  */
21364 _ACEOF
21365 cat confdefs.h >>conftest.$ac_ext
21366 cat >>conftest.$ac_ext <<_ACEOF
21367 /* end confdefs.h.  */
21368
21369 /* Override any gcc2 internal prototype to avoid an error.  */
21370 #ifdef __cplusplus
21371 extern "C"
21372 #endif
21373 /* We use char because int might match the return type of a gcc2
21374    builtin and then its argument prototype would still apply.  */
21375 char erfc ();
21376 int
21377 main ()
21378 {
21379 erfc ();
21380   ;
21381   return 0;
21382 }
21383 _ACEOF
21384 rm -f conftest.$ac_objext conftest$ac_exeext
21385 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21386   (eval $ac_link) 2>conftest.er1
21387   ac_status=$?
21388   grep -v '^ *+' conftest.er1 >conftest.err
21389   rm -f conftest.er1
21390   cat conftest.err >&5
21391   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21392   (exit $ac_status); } &&
21393          { ac_try='test -z "$ac_c_werror_flag"
21394                          || test ! -s conftest.err'
21395   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21396   (eval $ac_try) 2>&5
21397   ac_status=$?
21398   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21399   (exit $ac_status); }; } &&
21400          { ac_try='test -s conftest$ac_exeext'
21401   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21402   (eval $ac_try) 2>&5
21403   ac_status=$?
21404   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21405   (exit $ac_status); }; }; then
21406   ac_cv_lib_m_erfc=yes
21407 else
21408   echo "$as_me: failed program was:" >&5
21409 sed 's/^/| /' conftest.$ac_ext >&5
21410
21411 ac_cv_lib_m_erfc=no
21412 fi
21413 rm -f conftest.err conftest.$ac_objext \
21414       conftest$ac_exeext conftest.$ac_ext
21415 LIBS=$ac_check_lib_save_LIBS
21416 fi
21417 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfc" >&5
21418 echo "${ECHO_T}$ac_cv_lib_m_erfc" >&6
21419 if test $ac_cv_lib_m_erfc = yes; then
21420
21421 cat >>confdefs.h <<\_ACEOF
21422 #define HAVE_ERFC 1
21423 _ACEOF
21424
21425 fi
21426
21427 echo "$as_me:$LINENO: checking for erfcl in -lm" >&5
21428 echo $ECHO_N "checking for erfcl in -lm... $ECHO_C" >&6
21429 if test "${ac_cv_lib_m_erfcl+set}" = set; then
21430   echo $ECHO_N "(cached) $ECHO_C" >&6
21431 else
21432   ac_check_lib_save_LIBS=$LIBS
21433 LIBS="-lm  $LIBS"
21434 if test x$gcc_no_link = xyes; then
21435   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21436 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21437    { (exit 1); exit 1; }; }
21438 fi
21439 cat >conftest.$ac_ext <<_ACEOF
21440 /* confdefs.h.  */
21441 _ACEOF
21442 cat confdefs.h >>conftest.$ac_ext
21443 cat >>conftest.$ac_ext <<_ACEOF
21444 /* end confdefs.h.  */
21445
21446 /* Override any gcc2 internal prototype to avoid an error.  */
21447 #ifdef __cplusplus
21448 extern "C"
21449 #endif
21450 /* We use char because int might match the return type of a gcc2
21451    builtin and then its argument prototype would still apply.  */
21452 char erfcl ();
21453 int
21454 main ()
21455 {
21456 erfcl ();
21457   ;
21458   return 0;
21459 }
21460 _ACEOF
21461 rm -f conftest.$ac_objext conftest$ac_exeext
21462 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21463   (eval $ac_link) 2>conftest.er1
21464   ac_status=$?
21465   grep -v '^ *+' conftest.er1 >conftest.err
21466   rm -f conftest.er1
21467   cat conftest.err >&5
21468   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21469   (exit $ac_status); } &&
21470          { ac_try='test -z "$ac_c_werror_flag"
21471                          || test ! -s conftest.err'
21472   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21473   (eval $ac_try) 2>&5
21474   ac_status=$?
21475   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21476   (exit $ac_status); }; } &&
21477          { ac_try='test -s conftest$ac_exeext'
21478   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21479   (eval $ac_try) 2>&5
21480   ac_status=$?
21481   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21482   (exit $ac_status); }; }; then
21483   ac_cv_lib_m_erfcl=yes
21484 else
21485   echo "$as_me: failed program was:" >&5
21486 sed 's/^/| /' conftest.$ac_ext >&5
21487
21488 ac_cv_lib_m_erfcl=no
21489 fi
21490 rm -f conftest.err conftest.$ac_objext \
21491       conftest$ac_exeext conftest.$ac_ext
21492 LIBS=$ac_check_lib_save_LIBS
21493 fi
21494 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfcl" >&5
21495 echo "${ECHO_T}$ac_cv_lib_m_erfcl" >&6
21496 if test $ac_cv_lib_m_erfcl = yes; then
21497
21498 cat >>confdefs.h <<\_ACEOF
21499 #define HAVE_ERFCL 1
21500 _ACEOF
21501
21502 fi
21503
21504 echo "$as_me:$LINENO: checking for j0f in -lm" >&5
21505 echo $ECHO_N "checking for j0f in -lm... $ECHO_C" >&6
21506 if test "${ac_cv_lib_m_j0f+set}" = set; then
21507   echo $ECHO_N "(cached) $ECHO_C" >&6
21508 else
21509   ac_check_lib_save_LIBS=$LIBS
21510 LIBS="-lm  $LIBS"
21511 if test x$gcc_no_link = xyes; then
21512   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21513 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21514    { (exit 1); exit 1; }; }
21515 fi
21516 cat >conftest.$ac_ext <<_ACEOF
21517 /* confdefs.h.  */
21518 _ACEOF
21519 cat confdefs.h >>conftest.$ac_ext
21520 cat >>conftest.$ac_ext <<_ACEOF
21521 /* end confdefs.h.  */
21522
21523 /* Override any gcc2 internal prototype to avoid an error.  */
21524 #ifdef __cplusplus
21525 extern "C"
21526 #endif
21527 /* We use char because int might match the return type of a gcc2
21528    builtin and then its argument prototype would still apply.  */
21529 char j0f ();
21530 int
21531 main ()
21532 {
21533 j0f ();
21534   ;
21535   return 0;
21536 }
21537 _ACEOF
21538 rm -f conftest.$ac_objext conftest$ac_exeext
21539 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21540   (eval $ac_link) 2>conftest.er1
21541   ac_status=$?
21542   grep -v '^ *+' conftest.er1 >conftest.err
21543   rm -f conftest.er1
21544   cat conftest.err >&5
21545   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21546   (exit $ac_status); } &&
21547          { ac_try='test -z "$ac_c_werror_flag"
21548                          || test ! -s conftest.err'
21549   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21550   (eval $ac_try) 2>&5
21551   ac_status=$?
21552   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21553   (exit $ac_status); }; } &&
21554          { ac_try='test -s conftest$ac_exeext'
21555   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21556   (eval $ac_try) 2>&5
21557   ac_status=$?
21558   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21559   (exit $ac_status); }; }; then
21560   ac_cv_lib_m_j0f=yes
21561 else
21562   echo "$as_me: failed program was:" >&5
21563 sed 's/^/| /' conftest.$ac_ext >&5
21564
21565 ac_cv_lib_m_j0f=no
21566 fi
21567 rm -f conftest.err conftest.$ac_objext \
21568       conftest$ac_exeext conftest.$ac_ext
21569 LIBS=$ac_check_lib_save_LIBS
21570 fi
21571 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0f" >&5
21572 echo "${ECHO_T}$ac_cv_lib_m_j0f" >&6
21573 if test $ac_cv_lib_m_j0f = yes; then
21574
21575 cat >>confdefs.h <<\_ACEOF
21576 #define HAVE_J0F 1
21577 _ACEOF
21578
21579 fi
21580
21581 echo "$as_me:$LINENO: checking for j0 in -lm" >&5
21582 echo $ECHO_N "checking for j0 in -lm... $ECHO_C" >&6
21583 if test "${ac_cv_lib_m_j0+set}" = set; then
21584   echo $ECHO_N "(cached) $ECHO_C" >&6
21585 else
21586   ac_check_lib_save_LIBS=$LIBS
21587 LIBS="-lm  $LIBS"
21588 if test x$gcc_no_link = xyes; then
21589   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21590 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21591    { (exit 1); exit 1; }; }
21592 fi
21593 cat >conftest.$ac_ext <<_ACEOF
21594 /* confdefs.h.  */
21595 _ACEOF
21596 cat confdefs.h >>conftest.$ac_ext
21597 cat >>conftest.$ac_ext <<_ACEOF
21598 /* end confdefs.h.  */
21599
21600 /* Override any gcc2 internal prototype to avoid an error.  */
21601 #ifdef __cplusplus
21602 extern "C"
21603 #endif
21604 /* We use char because int might match the return type of a gcc2
21605    builtin and then its argument prototype would still apply.  */
21606 char j0 ();
21607 int
21608 main ()
21609 {
21610 j0 ();
21611   ;
21612   return 0;
21613 }
21614 _ACEOF
21615 rm -f conftest.$ac_objext conftest$ac_exeext
21616 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21617   (eval $ac_link) 2>conftest.er1
21618   ac_status=$?
21619   grep -v '^ *+' conftest.er1 >conftest.err
21620   rm -f conftest.er1
21621   cat conftest.err >&5
21622   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21623   (exit $ac_status); } &&
21624          { ac_try='test -z "$ac_c_werror_flag"
21625                          || test ! -s conftest.err'
21626   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21627   (eval $ac_try) 2>&5
21628   ac_status=$?
21629   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21630   (exit $ac_status); }; } &&
21631          { ac_try='test -s conftest$ac_exeext'
21632   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21633   (eval $ac_try) 2>&5
21634   ac_status=$?
21635   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21636   (exit $ac_status); }; }; then
21637   ac_cv_lib_m_j0=yes
21638 else
21639   echo "$as_me: failed program was:" >&5
21640 sed 's/^/| /' conftest.$ac_ext >&5
21641
21642 ac_cv_lib_m_j0=no
21643 fi
21644 rm -f conftest.err conftest.$ac_objext \
21645       conftest$ac_exeext conftest.$ac_ext
21646 LIBS=$ac_check_lib_save_LIBS
21647 fi
21648 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0" >&5
21649 echo "${ECHO_T}$ac_cv_lib_m_j0" >&6
21650 if test $ac_cv_lib_m_j0 = yes; then
21651
21652 cat >>confdefs.h <<\_ACEOF
21653 #define HAVE_J0 1
21654 _ACEOF
21655
21656 fi
21657
21658 echo "$as_me:$LINENO: checking for j0l in -lm" >&5
21659 echo $ECHO_N "checking for j0l in -lm... $ECHO_C" >&6
21660 if test "${ac_cv_lib_m_j0l+set}" = set; then
21661   echo $ECHO_N "(cached) $ECHO_C" >&6
21662 else
21663   ac_check_lib_save_LIBS=$LIBS
21664 LIBS="-lm  $LIBS"
21665 if test x$gcc_no_link = xyes; then
21666   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21667 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21668    { (exit 1); exit 1; }; }
21669 fi
21670 cat >conftest.$ac_ext <<_ACEOF
21671 /* confdefs.h.  */
21672 _ACEOF
21673 cat confdefs.h >>conftest.$ac_ext
21674 cat >>conftest.$ac_ext <<_ACEOF
21675 /* end confdefs.h.  */
21676
21677 /* Override any gcc2 internal prototype to avoid an error.  */
21678 #ifdef __cplusplus
21679 extern "C"
21680 #endif
21681 /* We use char because int might match the return type of a gcc2
21682    builtin and then its argument prototype would still apply.  */
21683 char j0l ();
21684 int
21685 main ()
21686 {
21687 j0l ();
21688   ;
21689   return 0;
21690 }
21691 _ACEOF
21692 rm -f conftest.$ac_objext conftest$ac_exeext
21693 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21694   (eval $ac_link) 2>conftest.er1
21695   ac_status=$?
21696   grep -v '^ *+' conftest.er1 >conftest.err
21697   rm -f conftest.er1
21698   cat conftest.err >&5
21699   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21700   (exit $ac_status); } &&
21701          { ac_try='test -z "$ac_c_werror_flag"
21702                          || test ! -s conftest.err'
21703   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21704   (eval $ac_try) 2>&5
21705   ac_status=$?
21706   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21707   (exit $ac_status); }; } &&
21708          { ac_try='test -s conftest$ac_exeext'
21709   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21710   (eval $ac_try) 2>&5
21711   ac_status=$?
21712   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21713   (exit $ac_status); }; }; then
21714   ac_cv_lib_m_j0l=yes
21715 else
21716   echo "$as_me: failed program was:" >&5
21717 sed 's/^/| /' conftest.$ac_ext >&5
21718
21719 ac_cv_lib_m_j0l=no
21720 fi
21721 rm -f conftest.err conftest.$ac_objext \
21722       conftest$ac_exeext conftest.$ac_ext
21723 LIBS=$ac_check_lib_save_LIBS
21724 fi
21725 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0l" >&5
21726 echo "${ECHO_T}$ac_cv_lib_m_j0l" >&6
21727 if test $ac_cv_lib_m_j0l = yes; then
21728
21729 cat >>confdefs.h <<\_ACEOF
21730 #define HAVE_J0L 1
21731 _ACEOF
21732
21733 fi
21734
21735 echo "$as_me:$LINENO: checking for j1f in -lm" >&5
21736 echo $ECHO_N "checking for j1f in -lm... $ECHO_C" >&6
21737 if test "${ac_cv_lib_m_j1f+set}" = set; then
21738   echo $ECHO_N "(cached) $ECHO_C" >&6
21739 else
21740   ac_check_lib_save_LIBS=$LIBS
21741 LIBS="-lm  $LIBS"
21742 if test x$gcc_no_link = xyes; then
21743   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21744 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21745    { (exit 1); exit 1; }; }
21746 fi
21747 cat >conftest.$ac_ext <<_ACEOF
21748 /* confdefs.h.  */
21749 _ACEOF
21750 cat confdefs.h >>conftest.$ac_ext
21751 cat >>conftest.$ac_ext <<_ACEOF
21752 /* end confdefs.h.  */
21753
21754 /* Override any gcc2 internal prototype to avoid an error.  */
21755 #ifdef __cplusplus
21756 extern "C"
21757 #endif
21758 /* We use char because int might match the return type of a gcc2
21759    builtin and then its argument prototype would still apply.  */
21760 char j1f ();
21761 int
21762 main ()
21763 {
21764 j1f ();
21765   ;
21766   return 0;
21767 }
21768 _ACEOF
21769 rm -f conftest.$ac_objext conftest$ac_exeext
21770 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21771   (eval $ac_link) 2>conftest.er1
21772   ac_status=$?
21773   grep -v '^ *+' conftest.er1 >conftest.err
21774   rm -f conftest.er1
21775   cat conftest.err >&5
21776   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21777   (exit $ac_status); } &&
21778          { ac_try='test -z "$ac_c_werror_flag"
21779                          || test ! -s conftest.err'
21780   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21781   (eval $ac_try) 2>&5
21782   ac_status=$?
21783   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21784   (exit $ac_status); }; } &&
21785          { ac_try='test -s conftest$ac_exeext'
21786   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21787   (eval $ac_try) 2>&5
21788   ac_status=$?
21789   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21790   (exit $ac_status); }; }; then
21791   ac_cv_lib_m_j1f=yes
21792 else
21793   echo "$as_me: failed program was:" >&5
21794 sed 's/^/| /' conftest.$ac_ext >&5
21795
21796 ac_cv_lib_m_j1f=no
21797 fi
21798 rm -f conftest.err conftest.$ac_objext \
21799       conftest$ac_exeext conftest.$ac_ext
21800 LIBS=$ac_check_lib_save_LIBS
21801 fi
21802 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1f" >&5
21803 echo "${ECHO_T}$ac_cv_lib_m_j1f" >&6
21804 if test $ac_cv_lib_m_j1f = yes; then
21805
21806 cat >>confdefs.h <<\_ACEOF
21807 #define HAVE_J1F 1
21808 _ACEOF
21809
21810 fi
21811
21812 echo "$as_me:$LINENO: checking for j1 in -lm" >&5
21813 echo $ECHO_N "checking for j1 in -lm... $ECHO_C" >&6
21814 if test "${ac_cv_lib_m_j1+set}" = set; then
21815   echo $ECHO_N "(cached) $ECHO_C" >&6
21816 else
21817   ac_check_lib_save_LIBS=$LIBS
21818 LIBS="-lm  $LIBS"
21819 if test x$gcc_no_link = xyes; then
21820   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21821 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21822    { (exit 1); exit 1; }; }
21823 fi
21824 cat >conftest.$ac_ext <<_ACEOF
21825 /* confdefs.h.  */
21826 _ACEOF
21827 cat confdefs.h >>conftest.$ac_ext
21828 cat >>conftest.$ac_ext <<_ACEOF
21829 /* end confdefs.h.  */
21830
21831 /* Override any gcc2 internal prototype to avoid an error.  */
21832 #ifdef __cplusplus
21833 extern "C"
21834 #endif
21835 /* We use char because int might match the return type of a gcc2
21836    builtin and then its argument prototype would still apply.  */
21837 char j1 ();
21838 int
21839 main ()
21840 {
21841 j1 ();
21842   ;
21843   return 0;
21844 }
21845 _ACEOF
21846 rm -f conftest.$ac_objext conftest$ac_exeext
21847 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21848   (eval $ac_link) 2>conftest.er1
21849   ac_status=$?
21850   grep -v '^ *+' conftest.er1 >conftest.err
21851   rm -f conftest.er1
21852   cat conftest.err >&5
21853   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21854   (exit $ac_status); } &&
21855          { ac_try='test -z "$ac_c_werror_flag"
21856                          || test ! -s conftest.err'
21857   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21858   (eval $ac_try) 2>&5
21859   ac_status=$?
21860   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21861   (exit $ac_status); }; } &&
21862          { ac_try='test -s conftest$ac_exeext'
21863   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21864   (eval $ac_try) 2>&5
21865   ac_status=$?
21866   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21867   (exit $ac_status); }; }; then
21868   ac_cv_lib_m_j1=yes
21869 else
21870   echo "$as_me: failed program was:" >&5
21871 sed 's/^/| /' conftest.$ac_ext >&5
21872
21873 ac_cv_lib_m_j1=no
21874 fi
21875 rm -f conftest.err conftest.$ac_objext \
21876       conftest$ac_exeext conftest.$ac_ext
21877 LIBS=$ac_check_lib_save_LIBS
21878 fi
21879 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1" >&5
21880 echo "${ECHO_T}$ac_cv_lib_m_j1" >&6
21881 if test $ac_cv_lib_m_j1 = yes; then
21882
21883 cat >>confdefs.h <<\_ACEOF
21884 #define HAVE_J1 1
21885 _ACEOF
21886
21887 fi
21888
21889 echo "$as_me:$LINENO: checking for j1l in -lm" >&5
21890 echo $ECHO_N "checking for j1l in -lm... $ECHO_C" >&6
21891 if test "${ac_cv_lib_m_j1l+set}" = set; then
21892   echo $ECHO_N "(cached) $ECHO_C" >&6
21893 else
21894   ac_check_lib_save_LIBS=$LIBS
21895 LIBS="-lm  $LIBS"
21896 if test x$gcc_no_link = xyes; then
21897   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21898 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21899    { (exit 1); exit 1; }; }
21900 fi
21901 cat >conftest.$ac_ext <<_ACEOF
21902 /* confdefs.h.  */
21903 _ACEOF
21904 cat confdefs.h >>conftest.$ac_ext
21905 cat >>conftest.$ac_ext <<_ACEOF
21906 /* end confdefs.h.  */
21907
21908 /* Override any gcc2 internal prototype to avoid an error.  */
21909 #ifdef __cplusplus
21910 extern "C"
21911 #endif
21912 /* We use char because int might match the return type of a gcc2
21913    builtin and then its argument prototype would still apply.  */
21914 char j1l ();
21915 int
21916 main ()
21917 {
21918 j1l ();
21919   ;
21920   return 0;
21921 }
21922 _ACEOF
21923 rm -f conftest.$ac_objext conftest$ac_exeext
21924 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21925   (eval $ac_link) 2>conftest.er1
21926   ac_status=$?
21927   grep -v '^ *+' conftest.er1 >conftest.err
21928   rm -f conftest.er1
21929   cat conftest.err >&5
21930   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21931   (exit $ac_status); } &&
21932          { ac_try='test -z "$ac_c_werror_flag"
21933                          || test ! -s conftest.err'
21934   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21935   (eval $ac_try) 2>&5
21936   ac_status=$?
21937   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21938   (exit $ac_status); }; } &&
21939          { ac_try='test -s conftest$ac_exeext'
21940   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21941   (eval $ac_try) 2>&5
21942   ac_status=$?
21943   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21944   (exit $ac_status); }; }; then
21945   ac_cv_lib_m_j1l=yes
21946 else
21947   echo "$as_me: failed program was:" >&5
21948 sed 's/^/| /' conftest.$ac_ext >&5
21949
21950 ac_cv_lib_m_j1l=no
21951 fi
21952 rm -f conftest.err conftest.$ac_objext \
21953       conftest$ac_exeext conftest.$ac_ext
21954 LIBS=$ac_check_lib_save_LIBS
21955 fi
21956 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1l" >&5
21957 echo "${ECHO_T}$ac_cv_lib_m_j1l" >&6
21958 if test $ac_cv_lib_m_j1l = yes; then
21959
21960 cat >>confdefs.h <<\_ACEOF
21961 #define HAVE_J1L 1
21962 _ACEOF
21963
21964 fi
21965
21966 echo "$as_me:$LINENO: checking for jnf in -lm" >&5
21967 echo $ECHO_N "checking for jnf in -lm... $ECHO_C" >&6
21968 if test "${ac_cv_lib_m_jnf+set}" = set; then
21969   echo $ECHO_N "(cached) $ECHO_C" >&6
21970 else
21971   ac_check_lib_save_LIBS=$LIBS
21972 LIBS="-lm  $LIBS"
21973 if test x$gcc_no_link = xyes; then
21974   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21975 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21976    { (exit 1); exit 1; }; }
21977 fi
21978 cat >conftest.$ac_ext <<_ACEOF
21979 /* confdefs.h.  */
21980 _ACEOF
21981 cat confdefs.h >>conftest.$ac_ext
21982 cat >>conftest.$ac_ext <<_ACEOF
21983 /* end confdefs.h.  */
21984
21985 /* Override any gcc2 internal prototype to avoid an error.  */
21986 #ifdef __cplusplus
21987 extern "C"
21988 #endif
21989 /* We use char because int might match the return type of a gcc2
21990    builtin and then its argument prototype would still apply.  */
21991 char jnf ();
21992 int
21993 main ()
21994 {
21995 jnf ();
21996   ;
21997   return 0;
21998 }
21999 _ACEOF
22000 rm -f conftest.$ac_objext conftest$ac_exeext
22001 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22002   (eval $ac_link) 2>conftest.er1
22003   ac_status=$?
22004   grep -v '^ *+' conftest.er1 >conftest.err
22005   rm -f conftest.er1
22006   cat conftest.err >&5
22007   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22008   (exit $ac_status); } &&
22009          { ac_try='test -z "$ac_c_werror_flag"
22010                          || test ! -s conftest.err'
22011   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22012   (eval $ac_try) 2>&5
22013   ac_status=$?
22014   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22015   (exit $ac_status); }; } &&
22016          { ac_try='test -s conftest$ac_exeext'
22017   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22018   (eval $ac_try) 2>&5
22019   ac_status=$?
22020   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22021   (exit $ac_status); }; }; then
22022   ac_cv_lib_m_jnf=yes
22023 else
22024   echo "$as_me: failed program was:" >&5
22025 sed 's/^/| /' conftest.$ac_ext >&5
22026
22027 ac_cv_lib_m_jnf=no
22028 fi
22029 rm -f conftest.err conftest.$ac_objext \
22030       conftest$ac_exeext conftest.$ac_ext
22031 LIBS=$ac_check_lib_save_LIBS
22032 fi
22033 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jnf" >&5
22034 echo "${ECHO_T}$ac_cv_lib_m_jnf" >&6
22035 if test $ac_cv_lib_m_jnf = yes; then
22036
22037 cat >>confdefs.h <<\_ACEOF
22038 #define HAVE_JNF 1
22039 _ACEOF
22040
22041 fi
22042
22043 echo "$as_me:$LINENO: checking for jn in -lm" >&5
22044 echo $ECHO_N "checking for jn in -lm... $ECHO_C" >&6
22045 if test "${ac_cv_lib_m_jn+set}" = set; then
22046   echo $ECHO_N "(cached) $ECHO_C" >&6
22047 else
22048   ac_check_lib_save_LIBS=$LIBS
22049 LIBS="-lm  $LIBS"
22050 if test x$gcc_no_link = xyes; then
22051   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22052 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22053    { (exit 1); exit 1; }; }
22054 fi
22055 cat >conftest.$ac_ext <<_ACEOF
22056 /* confdefs.h.  */
22057 _ACEOF
22058 cat confdefs.h >>conftest.$ac_ext
22059 cat >>conftest.$ac_ext <<_ACEOF
22060 /* end confdefs.h.  */
22061
22062 /* Override any gcc2 internal prototype to avoid an error.  */
22063 #ifdef __cplusplus
22064 extern "C"
22065 #endif
22066 /* We use char because int might match the return type of a gcc2
22067    builtin and then its argument prototype would still apply.  */
22068 char jn ();
22069 int
22070 main ()
22071 {
22072 jn ();
22073   ;
22074   return 0;
22075 }
22076 _ACEOF
22077 rm -f conftest.$ac_objext conftest$ac_exeext
22078 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22079   (eval $ac_link) 2>conftest.er1
22080   ac_status=$?
22081   grep -v '^ *+' conftest.er1 >conftest.err
22082   rm -f conftest.er1
22083   cat conftest.err >&5
22084   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22085   (exit $ac_status); } &&
22086          { ac_try='test -z "$ac_c_werror_flag"
22087                          || test ! -s conftest.err'
22088   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22089   (eval $ac_try) 2>&5
22090   ac_status=$?
22091   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22092   (exit $ac_status); }; } &&
22093          { ac_try='test -s conftest$ac_exeext'
22094   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22095   (eval $ac_try) 2>&5
22096   ac_status=$?
22097   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22098   (exit $ac_status); }; }; then
22099   ac_cv_lib_m_jn=yes
22100 else
22101   echo "$as_me: failed program was:" >&5
22102 sed 's/^/| /' conftest.$ac_ext >&5
22103
22104 ac_cv_lib_m_jn=no
22105 fi
22106 rm -f conftest.err conftest.$ac_objext \
22107       conftest$ac_exeext conftest.$ac_ext
22108 LIBS=$ac_check_lib_save_LIBS
22109 fi
22110 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jn" >&5
22111 echo "${ECHO_T}$ac_cv_lib_m_jn" >&6
22112 if test $ac_cv_lib_m_jn = yes; then
22113
22114 cat >>confdefs.h <<\_ACEOF
22115 #define HAVE_JN 1
22116 _ACEOF
22117
22118 fi
22119
22120 echo "$as_me:$LINENO: checking for jnl in -lm" >&5
22121 echo $ECHO_N "checking for jnl in -lm... $ECHO_C" >&6
22122 if test "${ac_cv_lib_m_jnl+set}" = set; then
22123   echo $ECHO_N "(cached) $ECHO_C" >&6
22124 else
22125   ac_check_lib_save_LIBS=$LIBS
22126 LIBS="-lm  $LIBS"
22127 if test x$gcc_no_link = xyes; then
22128   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22129 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22130    { (exit 1); exit 1; }; }
22131 fi
22132 cat >conftest.$ac_ext <<_ACEOF
22133 /* confdefs.h.  */
22134 _ACEOF
22135 cat confdefs.h >>conftest.$ac_ext
22136 cat >>conftest.$ac_ext <<_ACEOF
22137 /* end confdefs.h.  */
22138
22139 /* Override any gcc2 internal prototype to avoid an error.  */
22140 #ifdef __cplusplus
22141 extern "C"
22142 #endif
22143 /* We use char because int might match the return type of a gcc2
22144    builtin and then its argument prototype would still apply.  */
22145 char jnl ();
22146 int
22147 main ()
22148 {
22149 jnl ();
22150   ;
22151   return 0;
22152 }
22153 _ACEOF
22154 rm -f conftest.$ac_objext conftest$ac_exeext
22155 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22156   (eval $ac_link) 2>conftest.er1
22157   ac_status=$?
22158   grep -v '^ *+' conftest.er1 >conftest.err
22159   rm -f conftest.er1
22160   cat conftest.err >&5
22161   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22162   (exit $ac_status); } &&
22163          { ac_try='test -z "$ac_c_werror_flag"
22164                          || test ! -s conftest.err'
22165   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22166   (eval $ac_try) 2>&5
22167   ac_status=$?
22168   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22169   (exit $ac_status); }; } &&
22170          { ac_try='test -s conftest$ac_exeext'
22171   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22172   (eval $ac_try) 2>&5
22173   ac_status=$?
22174   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22175   (exit $ac_status); }; }; then
22176   ac_cv_lib_m_jnl=yes
22177 else
22178   echo "$as_me: failed program was:" >&5
22179 sed 's/^/| /' conftest.$ac_ext >&5
22180
22181 ac_cv_lib_m_jnl=no
22182 fi
22183 rm -f conftest.err conftest.$ac_objext \
22184       conftest$ac_exeext conftest.$ac_ext
22185 LIBS=$ac_check_lib_save_LIBS
22186 fi
22187 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jnl" >&5
22188 echo "${ECHO_T}$ac_cv_lib_m_jnl" >&6
22189 if test $ac_cv_lib_m_jnl = yes; then
22190
22191 cat >>confdefs.h <<\_ACEOF
22192 #define HAVE_JNL 1
22193 _ACEOF
22194
22195 fi
22196
22197 echo "$as_me:$LINENO: checking for y0f in -lm" >&5
22198 echo $ECHO_N "checking for y0f in -lm... $ECHO_C" >&6
22199 if test "${ac_cv_lib_m_y0f+set}" = set; then
22200   echo $ECHO_N "(cached) $ECHO_C" >&6
22201 else
22202   ac_check_lib_save_LIBS=$LIBS
22203 LIBS="-lm  $LIBS"
22204 if test x$gcc_no_link = xyes; then
22205   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22206 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22207    { (exit 1); exit 1; }; }
22208 fi
22209 cat >conftest.$ac_ext <<_ACEOF
22210 /* confdefs.h.  */
22211 _ACEOF
22212 cat confdefs.h >>conftest.$ac_ext
22213 cat >>conftest.$ac_ext <<_ACEOF
22214 /* end confdefs.h.  */
22215
22216 /* Override any gcc2 internal prototype to avoid an error.  */
22217 #ifdef __cplusplus
22218 extern "C"
22219 #endif
22220 /* We use char because int might match the return type of a gcc2
22221    builtin and then its argument prototype would still apply.  */
22222 char y0f ();
22223 int
22224 main ()
22225 {
22226 y0f ();
22227   ;
22228   return 0;
22229 }
22230 _ACEOF
22231 rm -f conftest.$ac_objext conftest$ac_exeext
22232 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22233   (eval $ac_link) 2>conftest.er1
22234   ac_status=$?
22235   grep -v '^ *+' conftest.er1 >conftest.err
22236   rm -f conftest.er1
22237   cat conftest.err >&5
22238   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22239   (exit $ac_status); } &&
22240          { ac_try='test -z "$ac_c_werror_flag"
22241                          || test ! -s conftest.err'
22242   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22243   (eval $ac_try) 2>&5
22244   ac_status=$?
22245   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22246   (exit $ac_status); }; } &&
22247          { ac_try='test -s conftest$ac_exeext'
22248   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22249   (eval $ac_try) 2>&5
22250   ac_status=$?
22251   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22252   (exit $ac_status); }; }; then
22253   ac_cv_lib_m_y0f=yes
22254 else
22255   echo "$as_me: failed program was:" >&5
22256 sed 's/^/| /' conftest.$ac_ext >&5
22257
22258 ac_cv_lib_m_y0f=no
22259 fi
22260 rm -f conftest.err conftest.$ac_objext \
22261       conftest$ac_exeext conftest.$ac_ext
22262 LIBS=$ac_check_lib_save_LIBS
22263 fi
22264 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0f" >&5
22265 echo "${ECHO_T}$ac_cv_lib_m_y0f" >&6
22266 if test $ac_cv_lib_m_y0f = yes; then
22267
22268 cat >>confdefs.h <<\_ACEOF
22269 #define HAVE_Y0F 1
22270 _ACEOF
22271
22272 fi
22273
22274 echo "$as_me:$LINENO: checking for y0 in -lm" >&5
22275 echo $ECHO_N "checking for y0 in -lm... $ECHO_C" >&6
22276 if test "${ac_cv_lib_m_y0+set}" = set; then
22277   echo $ECHO_N "(cached) $ECHO_C" >&6
22278 else
22279   ac_check_lib_save_LIBS=$LIBS
22280 LIBS="-lm  $LIBS"
22281 if test x$gcc_no_link = xyes; then
22282   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22283 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22284    { (exit 1); exit 1; }; }
22285 fi
22286 cat >conftest.$ac_ext <<_ACEOF
22287 /* confdefs.h.  */
22288 _ACEOF
22289 cat confdefs.h >>conftest.$ac_ext
22290 cat >>conftest.$ac_ext <<_ACEOF
22291 /* end confdefs.h.  */
22292
22293 /* Override any gcc2 internal prototype to avoid an error.  */
22294 #ifdef __cplusplus
22295 extern "C"
22296 #endif
22297 /* We use char because int might match the return type of a gcc2
22298    builtin and then its argument prototype would still apply.  */
22299 char y0 ();
22300 int
22301 main ()
22302 {
22303 y0 ();
22304   ;
22305   return 0;
22306 }
22307 _ACEOF
22308 rm -f conftest.$ac_objext conftest$ac_exeext
22309 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22310   (eval $ac_link) 2>conftest.er1
22311   ac_status=$?
22312   grep -v '^ *+' conftest.er1 >conftest.err
22313   rm -f conftest.er1
22314   cat conftest.err >&5
22315   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22316   (exit $ac_status); } &&
22317          { ac_try='test -z "$ac_c_werror_flag"
22318                          || test ! -s conftest.err'
22319   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22320   (eval $ac_try) 2>&5
22321   ac_status=$?
22322   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22323   (exit $ac_status); }; } &&
22324          { ac_try='test -s conftest$ac_exeext'
22325   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22326   (eval $ac_try) 2>&5
22327   ac_status=$?
22328   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22329   (exit $ac_status); }; }; then
22330   ac_cv_lib_m_y0=yes
22331 else
22332   echo "$as_me: failed program was:" >&5
22333 sed 's/^/| /' conftest.$ac_ext >&5
22334
22335 ac_cv_lib_m_y0=no
22336 fi
22337 rm -f conftest.err conftest.$ac_objext \
22338       conftest$ac_exeext conftest.$ac_ext
22339 LIBS=$ac_check_lib_save_LIBS
22340 fi
22341 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0" >&5
22342 echo "${ECHO_T}$ac_cv_lib_m_y0" >&6
22343 if test $ac_cv_lib_m_y0 = yes; then
22344
22345 cat >>confdefs.h <<\_ACEOF
22346 #define HAVE_Y0 1
22347 _ACEOF
22348
22349 fi
22350
22351 echo "$as_me:$LINENO: checking for y0l in -lm" >&5
22352 echo $ECHO_N "checking for y0l in -lm... $ECHO_C" >&6
22353 if test "${ac_cv_lib_m_y0l+set}" = set; then
22354   echo $ECHO_N "(cached) $ECHO_C" >&6
22355 else
22356   ac_check_lib_save_LIBS=$LIBS
22357 LIBS="-lm  $LIBS"
22358 if test x$gcc_no_link = xyes; then
22359   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22360 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22361    { (exit 1); exit 1; }; }
22362 fi
22363 cat >conftest.$ac_ext <<_ACEOF
22364 /* confdefs.h.  */
22365 _ACEOF
22366 cat confdefs.h >>conftest.$ac_ext
22367 cat >>conftest.$ac_ext <<_ACEOF
22368 /* end confdefs.h.  */
22369
22370 /* Override any gcc2 internal prototype to avoid an error.  */
22371 #ifdef __cplusplus
22372 extern "C"
22373 #endif
22374 /* We use char because int might match the return type of a gcc2
22375    builtin and then its argument prototype would still apply.  */
22376 char y0l ();
22377 int
22378 main ()
22379 {
22380 y0l ();
22381   ;
22382   return 0;
22383 }
22384 _ACEOF
22385 rm -f conftest.$ac_objext conftest$ac_exeext
22386 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22387   (eval $ac_link) 2>conftest.er1
22388   ac_status=$?
22389   grep -v '^ *+' conftest.er1 >conftest.err
22390   rm -f conftest.er1
22391   cat conftest.err >&5
22392   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22393   (exit $ac_status); } &&
22394          { ac_try='test -z "$ac_c_werror_flag"
22395                          || test ! -s conftest.err'
22396   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22397   (eval $ac_try) 2>&5
22398   ac_status=$?
22399   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22400   (exit $ac_status); }; } &&
22401          { ac_try='test -s conftest$ac_exeext'
22402   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22403   (eval $ac_try) 2>&5
22404   ac_status=$?
22405   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22406   (exit $ac_status); }; }; then
22407   ac_cv_lib_m_y0l=yes
22408 else
22409   echo "$as_me: failed program was:" >&5
22410 sed 's/^/| /' conftest.$ac_ext >&5
22411
22412 ac_cv_lib_m_y0l=no
22413 fi
22414 rm -f conftest.err conftest.$ac_objext \
22415       conftest$ac_exeext conftest.$ac_ext
22416 LIBS=$ac_check_lib_save_LIBS
22417 fi
22418 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0l" >&5
22419 echo "${ECHO_T}$ac_cv_lib_m_y0l" >&6
22420 if test $ac_cv_lib_m_y0l = yes; then
22421
22422 cat >>confdefs.h <<\_ACEOF
22423 #define HAVE_Y0L 1
22424 _ACEOF
22425
22426 fi
22427
22428 echo "$as_me:$LINENO: checking for y1f in -lm" >&5
22429 echo $ECHO_N "checking for y1f in -lm... $ECHO_C" >&6
22430 if test "${ac_cv_lib_m_y1f+set}" = set; then
22431   echo $ECHO_N "(cached) $ECHO_C" >&6
22432 else
22433   ac_check_lib_save_LIBS=$LIBS
22434 LIBS="-lm  $LIBS"
22435 if test x$gcc_no_link = xyes; then
22436   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22437 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22438    { (exit 1); exit 1; }; }
22439 fi
22440 cat >conftest.$ac_ext <<_ACEOF
22441 /* confdefs.h.  */
22442 _ACEOF
22443 cat confdefs.h >>conftest.$ac_ext
22444 cat >>conftest.$ac_ext <<_ACEOF
22445 /* end confdefs.h.  */
22446
22447 /* Override any gcc2 internal prototype to avoid an error.  */
22448 #ifdef __cplusplus
22449 extern "C"
22450 #endif
22451 /* We use char because int might match the return type of a gcc2
22452    builtin and then its argument prototype would still apply.  */
22453 char y1f ();
22454 int
22455 main ()
22456 {
22457 y1f ();
22458   ;
22459   return 0;
22460 }
22461 _ACEOF
22462 rm -f conftest.$ac_objext conftest$ac_exeext
22463 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22464   (eval $ac_link) 2>conftest.er1
22465   ac_status=$?
22466   grep -v '^ *+' conftest.er1 >conftest.err
22467   rm -f conftest.er1
22468   cat conftest.err >&5
22469   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22470   (exit $ac_status); } &&
22471          { ac_try='test -z "$ac_c_werror_flag"
22472                          || test ! -s conftest.err'
22473   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22474   (eval $ac_try) 2>&5
22475   ac_status=$?
22476   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22477   (exit $ac_status); }; } &&
22478          { ac_try='test -s conftest$ac_exeext'
22479   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22480   (eval $ac_try) 2>&5
22481   ac_status=$?
22482   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22483   (exit $ac_status); }; }; then
22484   ac_cv_lib_m_y1f=yes
22485 else
22486   echo "$as_me: failed program was:" >&5
22487 sed 's/^/| /' conftest.$ac_ext >&5
22488
22489 ac_cv_lib_m_y1f=no
22490 fi
22491 rm -f conftest.err conftest.$ac_objext \
22492       conftest$ac_exeext conftest.$ac_ext
22493 LIBS=$ac_check_lib_save_LIBS
22494 fi
22495 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1f" >&5
22496 echo "${ECHO_T}$ac_cv_lib_m_y1f" >&6
22497 if test $ac_cv_lib_m_y1f = yes; then
22498
22499 cat >>confdefs.h <<\_ACEOF
22500 #define HAVE_Y1F 1
22501 _ACEOF
22502
22503 fi
22504
22505 echo "$as_me:$LINENO: checking for y1 in -lm" >&5
22506 echo $ECHO_N "checking for y1 in -lm... $ECHO_C" >&6
22507 if test "${ac_cv_lib_m_y1+set}" = set; then
22508   echo $ECHO_N "(cached) $ECHO_C" >&6
22509 else
22510   ac_check_lib_save_LIBS=$LIBS
22511 LIBS="-lm  $LIBS"
22512 if test x$gcc_no_link = xyes; then
22513   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22514 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22515    { (exit 1); exit 1; }; }
22516 fi
22517 cat >conftest.$ac_ext <<_ACEOF
22518 /* confdefs.h.  */
22519 _ACEOF
22520 cat confdefs.h >>conftest.$ac_ext
22521 cat >>conftest.$ac_ext <<_ACEOF
22522 /* end confdefs.h.  */
22523
22524 /* Override any gcc2 internal prototype to avoid an error.  */
22525 #ifdef __cplusplus
22526 extern "C"
22527 #endif
22528 /* We use char because int might match the return type of a gcc2
22529    builtin and then its argument prototype would still apply.  */
22530 char y1 ();
22531 int
22532 main ()
22533 {
22534 y1 ();
22535   ;
22536   return 0;
22537 }
22538 _ACEOF
22539 rm -f conftest.$ac_objext conftest$ac_exeext
22540 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22541   (eval $ac_link) 2>conftest.er1
22542   ac_status=$?
22543   grep -v '^ *+' conftest.er1 >conftest.err
22544   rm -f conftest.er1
22545   cat conftest.err >&5
22546   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22547   (exit $ac_status); } &&
22548          { ac_try='test -z "$ac_c_werror_flag"
22549                          || test ! -s conftest.err'
22550   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22551   (eval $ac_try) 2>&5
22552   ac_status=$?
22553   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22554   (exit $ac_status); }; } &&
22555          { ac_try='test -s conftest$ac_exeext'
22556   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22557   (eval $ac_try) 2>&5
22558   ac_status=$?
22559   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22560   (exit $ac_status); }; }; then
22561   ac_cv_lib_m_y1=yes
22562 else
22563   echo "$as_me: failed program was:" >&5
22564 sed 's/^/| /' conftest.$ac_ext >&5
22565
22566 ac_cv_lib_m_y1=no
22567 fi
22568 rm -f conftest.err conftest.$ac_objext \
22569       conftest$ac_exeext conftest.$ac_ext
22570 LIBS=$ac_check_lib_save_LIBS
22571 fi
22572 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1" >&5
22573 echo "${ECHO_T}$ac_cv_lib_m_y1" >&6
22574 if test $ac_cv_lib_m_y1 = yes; then
22575
22576 cat >>confdefs.h <<\_ACEOF
22577 #define HAVE_Y1 1
22578 _ACEOF
22579
22580 fi
22581
22582 echo "$as_me:$LINENO: checking for y1l in -lm" >&5
22583 echo $ECHO_N "checking for y1l in -lm... $ECHO_C" >&6
22584 if test "${ac_cv_lib_m_y1l+set}" = set; then
22585   echo $ECHO_N "(cached) $ECHO_C" >&6
22586 else
22587   ac_check_lib_save_LIBS=$LIBS
22588 LIBS="-lm  $LIBS"
22589 if test x$gcc_no_link = xyes; then
22590   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22591 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22592    { (exit 1); exit 1; }; }
22593 fi
22594 cat >conftest.$ac_ext <<_ACEOF
22595 /* confdefs.h.  */
22596 _ACEOF
22597 cat confdefs.h >>conftest.$ac_ext
22598 cat >>conftest.$ac_ext <<_ACEOF
22599 /* end confdefs.h.  */
22600
22601 /* Override any gcc2 internal prototype to avoid an error.  */
22602 #ifdef __cplusplus
22603 extern "C"
22604 #endif
22605 /* We use char because int might match the return type of a gcc2
22606    builtin and then its argument prototype would still apply.  */
22607 char y1l ();
22608 int
22609 main ()
22610 {
22611 y1l ();
22612   ;
22613   return 0;
22614 }
22615 _ACEOF
22616 rm -f conftest.$ac_objext conftest$ac_exeext
22617 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22618   (eval $ac_link) 2>conftest.er1
22619   ac_status=$?
22620   grep -v '^ *+' conftest.er1 >conftest.err
22621   rm -f conftest.er1
22622   cat conftest.err >&5
22623   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22624   (exit $ac_status); } &&
22625          { ac_try='test -z "$ac_c_werror_flag"
22626                          || test ! -s conftest.err'
22627   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22628   (eval $ac_try) 2>&5
22629   ac_status=$?
22630   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22631   (exit $ac_status); }; } &&
22632          { ac_try='test -s conftest$ac_exeext'
22633   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22634   (eval $ac_try) 2>&5
22635   ac_status=$?
22636   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22637   (exit $ac_status); }; }; then
22638   ac_cv_lib_m_y1l=yes
22639 else
22640   echo "$as_me: failed program was:" >&5
22641 sed 's/^/| /' conftest.$ac_ext >&5
22642
22643 ac_cv_lib_m_y1l=no
22644 fi
22645 rm -f conftest.err conftest.$ac_objext \
22646       conftest$ac_exeext conftest.$ac_ext
22647 LIBS=$ac_check_lib_save_LIBS
22648 fi
22649 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1l" >&5
22650 echo "${ECHO_T}$ac_cv_lib_m_y1l" >&6
22651 if test $ac_cv_lib_m_y1l = yes; then
22652
22653 cat >>confdefs.h <<\_ACEOF
22654 #define HAVE_Y1L 1
22655 _ACEOF
22656
22657 fi
22658
22659 echo "$as_me:$LINENO: checking for ynf in -lm" >&5
22660 echo $ECHO_N "checking for ynf in -lm... $ECHO_C" >&6
22661 if test "${ac_cv_lib_m_ynf+set}" = set; then
22662   echo $ECHO_N "(cached) $ECHO_C" >&6
22663 else
22664   ac_check_lib_save_LIBS=$LIBS
22665 LIBS="-lm  $LIBS"
22666 if test x$gcc_no_link = xyes; then
22667   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22668 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22669    { (exit 1); exit 1; }; }
22670 fi
22671 cat >conftest.$ac_ext <<_ACEOF
22672 /* confdefs.h.  */
22673 _ACEOF
22674 cat confdefs.h >>conftest.$ac_ext
22675 cat >>conftest.$ac_ext <<_ACEOF
22676 /* end confdefs.h.  */
22677
22678 /* Override any gcc2 internal prototype to avoid an error.  */
22679 #ifdef __cplusplus
22680 extern "C"
22681 #endif
22682 /* We use char because int might match the return type of a gcc2
22683    builtin and then its argument prototype would still apply.  */
22684 char ynf ();
22685 int
22686 main ()
22687 {
22688 ynf ();
22689   ;
22690   return 0;
22691 }
22692 _ACEOF
22693 rm -f conftest.$ac_objext conftest$ac_exeext
22694 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22695   (eval $ac_link) 2>conftest.er1
22696   ac_status=$?
22697   grep -v '^ *+' conftest.er1 >conftest.err
22698   rm -f conftest.er1
22699   cat conftest.err >&5
22700   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22701   (exit $ac_status); } &&
22702          { ac_try='test -z "$ac_c_werror_flag"
22703                          || test ! -s conftest.err'
22704   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22705   (eval $ac_try) 2>&5
22706   ac_status=$?
22707   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22708   (exit $ac_status); }; } &&
22709          { ac_try='test -s conftest$ac_exeext'
22710   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22711   (eval $ac_try) 2>&5
22712   ac_status=$?
22713   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22714   (exit $ac_status); }; }; then
22715   ac_cv_lib_m_ynf=yes
22716 else
22717   echo "$as_me: failed program was:" >&5
22718 sed 's/^/| /' conftest.$ac_ext >&5
22719
22720 ac_cv_lib_m_ynf=no
22721 fi
22722 rm -f conftest.err conftest.$ac_objext \
22723       conftest$ac_exeext conftest.$ac_ext
22724 LIBS=$ac_check_lib_save_LIBS
22725 fi
22726 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ynf" >&5
22727 echo "${ECHO_T}$ac_cv_lib_m_ynf" >&6
22728 if test $ac_cv_lib_m_ynf = yes; then
22729
22730 cat >>confdefs.h <<\_ACEOF
22731 #define HAVE_YNF 1
22732 _ACEOF
22733
22734 fi
22735
22736 echo "$as_me:$LINENO: checking for yn in -lm" >&5
22737 echo $ECHO_N "checking for yn in -lm... $ECHO_C" >&6
22738 if test "${ac_cv_lib_m_yn+set}" = set; then
22739   echo $ECHO_N "(cached) $ECHO_C" >&6
22740 else
22741   ac_check_lib_save_LIBS=$LIBS
22742 LIBS="-lm  $LIBS"
22743 if test x$gcc_no_link = xyes; then
22744   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22745 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22746    { (exit 1); exit 1; }; }
22747 fi
22748 cat >conftest.$ac_ext <<_ACEOF
22749 /* confdefs.h.  */
22750 _ACEOF
22751 cat confdefs.h >>conftest.$ac_ext
22752 cat >>conftest.$ac_ext <<_ACEOF
22753 /* end confdefs.h.  */
22754
22755 /* Override any gcc2 internal prototype to avoid an error.  */
22756 #ifdef __cplusplus
22757 extern "C"
22758 #endif
22759 /* We use char because int might match the return type of a gcc2
22760    builtin and then its argument prototype would still apply.  */
22761 char yn ();
22762 int
22763 main ()
22764 {
22765 yn ();
22766   ;
22767   return 0;
22768 }
22769 _ACEOF
22770 rm -f conftest.$ac_objext conftest$ac_exeext
22771 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22772   (eval $ac_link) 2>conftest.er1
22773   ac_status=$?
22774   grep -v '^ *+' conftest.er1 >conftest.err
22775   rm -f conftest.er1
22776   cat conftest.err >&5
22777   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22778   (exit $ac_status); } &&
22779          { ac_try='test -z "$ac_c_werror_flag"
22780                          || test ! -s conftest.err'
22781   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22782   (eval $ac_try) 2>&5
22783   ac_status=$?
22784   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22785   (exit $ac_status); }; } &&
22786          { ac_try='test -s conftest$ac_exeext'
22787   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22788   (eval $ac_try) 2>&5
22789   ac_status=$?
22790   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22791   (exit $ac_status); }; }; then
22792   ac_cv_lib_m_yn=yes
22793 else
22794   echo "$as_me: failed program was:" >&5
22795 sed 's/^/| /' conftest.$ac_ext >&5
22796
22797 ac_cv_lib_m_yn=no
22798 fi
22799 rm -f conftest.err conftest.$ac_objext \
22800       conftest$ac_exeext conftest.$ac_ext
22801 LIBS=$ac_check_lib_save_LIBS
22802 fi
22803 echo "$as_me:$LINENO: result: $ac_cv_lib_m_yn" >&5
22804 echo "${ECHO_T}$ac_cv_lib_m_yn" >&6
22805 if test $ac_cv_lib_m_yn = yes; then
22806
22807 cat >>confdefs.h <<\_ACEOF
22808 #define HAVE_YN 1
22809 _ACEOF
22810
22811 fi
22812
22813 echo "$as_me:$LINENO: checking for ynl in -lm" >&5
22814 echo $ECHO_N "checking for ynl in -lm... $ECHO_C" >&6
22815 if test "${ac_cv_lib_m_ynl+set}" = set; then
22816   echo $ECHO_N "(cached) $ECHO_C" >&6
22817 else
22818   ac_check_lib_save_LIBS=$LIBS
22819 LIBS="-lm  $LIBS"
22820 if test x$gcc_no_link = xyes; then
22821   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22822 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22823    { (exit 1); exit 1; }; }
22824 fi
22825 cat >conftest.$ac_ext <<_ACEOF
22826 /* confdefs.h.  */
22827 _ACEOF
22828 cat confdefs.h >>conftest.$ac_ext
22829 cat >>conftest.$ac_ext <<_ACEOF
22830 /* end confdefs.h.  */
22831
22832 /* Override any gcc2 internal prototype to avoid an error.  */
22833 #ifdef __cplusplus
22834 extern "C"
22835 #endif
22836 /* We use char because int might match the return type of a gcc2
22837    builtin and then its argument prototype would still apply.  */
22838 char ynl ();
22839 int
22840 main ()
22841 {
22842 ynl ();
22843   ;
22844   return 0;
22845 }
22846 _ACEOF
22847 rm -f conftest.$ac_objext conftest$ac_exeext
22848 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22849   (eval $ac_link) 2>conftest.er1
22850   ac_status=$?
22851   grep -v '^ *+' conftest.er1 >conftest.err
22852   rm -f conftest.er1
22853   cat conftest.err >&5
22854   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22855   (exit $ac_status); } &&
22856          { ac_try='test -z "$ac_c_werror_flag"
22857                          || test ! -s conftest.err'
22858   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22859   (eval $ac_try) 2>&5
22860   ac_status=$?
22861   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22862   (exit $ac_status); }; } &&
22863          { ac_try='test -s conftest$ac_exeext'
22864   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22865   (eval $ac_try) 2>&5
22866   ac_status=$?
22867   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22868   (exit $ac_status); }; }; then
22869   ac_cv_lib_m_ynl=yes
22870 else
22871   echo "$as_me: failed program was:" >&5
22872 sed 's/^/| /' conftest.$ac_ext >&5
22873
22874 ac_cv_lib_m_ynl=no
22875 fi
22876 rm -f conftest.err conftest.$ac_objext \
22877       conftest$ac_exeext conftest.$ac_ext
22878 LIBS=$ac_check_lib_save_LIBS
22879 fi
22880 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ynl" >&5
22881 echo "${ECHO_T}$ac_cv_lib_m_ynl" >&6
22882 if test $ac_cv_lib_m_ynl = yes; then
22883
22884 cat >>confdefs.h <<\_ACEOF
22885 #define HAVE_YNL 1
22886 _ACEOF
22887
22888 fi
22889
22890
22891 # On AIX, clog is present in libm as __clog
22892 echo "$as_me:$LINENO: checking for __clog in -lm" >&5
22893 echo $ECHO_N "checking for __clog in -lm... $ECHO_C" >&6
22894 if test "${ac_cv_lib_m___clog+set}" = set; then
22895   echo $ECHO_N "(cached) $ECHO_C" >&6
22896 else
22897   ac_check_lib_save_LIBS=$LIBS
22898 LIBS="-lm  $LIBS"
22899 if test x$gcc_no_link = xyes; then
22900   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22901 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22902    { (exit 1); exit 1; }; }
22903 fi
22904 cat >conftest.$ac_ext <<_ACEOF
22905 /* confdefs.h.  */
22906 _ACEOF
22907 cat confdefs.h >>conftest.$ac_ext
22908 cat >>conftest.$ac_ext <<_ACEOF
22909 /* end confdefs.h.  */
22910
22911 /* Override any gcc2 internal prototype to avoid an error.  */
22912 #ifdef __cplusplus
22913 extern "C"
22914 #endif
22915 /* We use char because int might match the return type of a gcc2
22916    builtin and then its argument prototype would still apply.  */
22917 char __clog ();
22918 int
22919 main ()
22920 {
22921 __clog ();
22922   ;
22923   return 0;
22924 }
22925 _ACEOF
22926 rm -f conftest.$ac_objext conftest$ac_exeext
22927 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22928   (eval $ac_link) 2>conftest.er1
22929   ac_status=$?
22930   grep -v '^ *+' conftest.er1 >conftest.err
22931   rm -f conftest.er1
22932   cat conftest.err >&5
22933   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22934   (exit $ac_status); } &&
22935          { ac_try='test -z "$ac_c_werror_flag"
22936                          || test ! -s conftest.err'
22937   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22938   (eval $ac_try) 2>&5
22939   ac_status=$?
22940   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22941   (exit $ac_status); }; } &&
22942          { ac_try='test -s conftest$ac_exeext'
22943   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22944   (eval $ac_try) 2>&5
22945   ac_status=$?
22946   echo "$as_me:$LINENO: \$? = $ac_status" >&5
22947   (exit $ac_status); }; }; then
22948   ac_cv_lib_m___clog=yes
22949 else
22950   echo "$as_me: failed program was:" >&5
22951 sed 's/^/| /' conftest.$ac_ext >&5
22952
22953 ac_cv_lib_m___clog=no
22954 fi
22955 rm -f conftest.err conftest.$ac_objext \
22956       conftest$ac_exeext conftest.$ac_ext
22957 LIBS=$ac_check_lib_save_LIBS
22958 fi
22959 echo "$as_me:$LINENO: result: $ac_cv_lib_m___clog" >&5
22960 echo "${ECHO_T}$ac_cv_lib_m___clog" >&6
22961 if test $ac_cv_lib_m___clog = yes; then
22962
22963 cat >>confdefs.h <<\_ACEOF
22964 #define HAVE_CLOG 1
22965 _ACEOF
22966
22967 fi
22968
22969
22970 # Check for a isfinite macro that works on long doubles.
22971
22972   echo "$as_me:$LINENO: checking whether isfinite is broken" >&5
22973 echo $ECHO_N "checking whether isfinite is broken... $ECHO_C" >&6
22974 if test "${have_broken_isfinite+set}" = set; then
22975   echo $ECHO_N "(cached) $ECHO_C" >&6
22976 else
22977
22978   libgfor_check_for_broken_isfinite_save_LIBS=$LIBS
22979   LIBS="$LIBS -lm"
22980   if test "$cross_compiling" = yes; then
22981
22982 case "${target}" in
22983   hppa*-*-hpux*) have_broken_isfinite=yes ;;
22984   *) have_broken_isfinite=no ;;
22985 esac
22986 else
22987   cat >conftest.$ac_ext <<_ACEOF
22988 /* confdefs.h.  */
22989 _ACEOF
22990 cat confdefs.h >>conftest.$ac_ext
22991 cat >>conftest.$ac_ext <<_ACEOF
22992 /* end confdefs.h.  */
22993
22994 #ifdef HAVE_MATH_H
22995 #include <math.h>
22996 #endif
22997 #include <float.h>
22998 int main ()
22999 {
23000 #ifdef isfinite
23001 #ifdef LDBL_MAX
23002   if (!isfinite(LDBL_MAX)) return 1;
23003 #endif
23004 #ifdef DBL_MAX
23005   if (!isfinite(DBL_MAX)) return 1;
23006 #endif
23007 #endif
23008 return 0;
23009 }
23010 _ACEOF
23011 rm -f conftest$ac_exeext
23012 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23013   (eval $ac_link) 2>&5
23014   ac_status=$?
23015   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23016   (exit $ac_status); } && { ac_try='./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   have_broken_isfinite=no
23023 else
23024   echo "$as_me: program exited with status $ac_status" >&5
23025 echo "$as_me: failed program was:" >&5
23026 sed 's/^/| /' conftest.$ac_ext >&5
23027
23028 ( exit $ac_status )
23029 have_broken_isfinite=yes
23030 fi
23031 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23032 fi
23033   LIBS=$libgfor_check_for_broken_isfinite_save_LIBS
23034 fi
23035 echo "$as_me:$LINENO: result: $have_broken_isfinite" >&5
23036 echo "${ECHO_T}$have_broken_isfinite" >&6
23037 if test x"$have_broken_isfinite" = xyes; then
23038
23039 cat >>confdefs.h <<\_ACEOF
23040 #define HAVE_BROKEN_ISFINITE 1
23041 _ACEOF
23042
23043 fi
23044
23045 # Check for a isnan macro that works on long doubles.
23046
23047   echo "$as_me:$LINENO: checking whether isnan is broken" >&5
23048 echo $ECHO_N "checking whether isnan is broken... $ECHO_C" >&6
23049 if test "${have_broken_isnan+set}" = set; then
23050   echo $ECHO_N "(cached) $ECHO_C" >&6
23051 else
23052
23053   libgfor_check_for_broken_isnan_save_LIBS=$LIBS
23054   LIBS="$LIBS -lm"
23055   if test "$cross_compiling" = yes; then
23056
23057 case "${target}" in
23058   hppa*-*-hpux*) have_broken_isnan=yes ;;
23059   *) have_broken_isnan=no ;;
23060 esac
23061 else
23062   cat >conftest.$ac_ext <<_ACEOF
23063 /* confdefs.h.  */
23064 _ACEOF
23065 cat confdefs.h >>conftest.$ac_ext
23066 cat >>conftest.$ac_ext <<_ACEOF
23067 /* end confdefs.h.  */
23068
23069 #ifdef HAVE_MATH_H
23070 #include <math.h>
23071 #endif
23072 #include <float.h>
23073 int main ()
23074 {
23075 #ifdef isnan
23076 #ifdef LDBL_MAX
23077   {
23078     long double x;
23079     x = __builtin_nanl ("");
23080     if (!isnan(x)) return 1;
23081     if (isnan(LDBL_MAX)) return 1;
23082 #ifdef NAN
23083     x = (long double) NAN;
23084     if (!isnan(x)) return 1;
23085 #endif
23086   }
23087 #endif
23088 #ifdef DBL_MAX
23089   {
23090     double y;
23091     y = __builtin_nan ("");
23092     if (!isnan(y)) return 1;
23093     if (isnan(DBL_MAX)) return 1;
23094 #ifdef NAN
23095     y = (double) NAN;
23096     if (!isnan(y)) return 1;
23097 #endif
23098   }
23099 #endif
23100 #endif
23101 return 0;
23102 }
23103 _ACEOF
23104 rm -f conftest$ac_exeext
23105 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23106   (eval $ac_link) 2>&5
23107   ac_status=$?
23108   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23109   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
23110   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23111   (eval $ac_try) 2>&5
23112   ac_status=$?
23113   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23114   (exit $ac_status); }; }; then
23115   have_broken_isnan=no
23116 else
23117   echo "$as_me: program exited with status $ac_status" >&5
23118 echo "$as_me: failed program was:" >&5
23119 sed 's/^/| /' conftest.$ac_ext >&5
23120
23121 ( exit $ac_status )
23122 have_broken_isnan=yes
23123 fi
23124 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23125 fi
23126   LIBS=$libgfor_check_for_broken_isnan_save_LIBS
23127 fi
23128 echo "$as_me:$LINENO: result: $have_broken_isnan" >&5
23129 echo "${ECHO_T}$have_broken_isnan" >&6
23130 if test x"$have_broken_isnan" = xyes; then
23131
23132 cat >>confdefs.h <<\_ACEOF
23133 #define HAVE_BROKEN_ISNAN 1
23134 _ACEOF
23135
23136 fi
23137
23138 # Check for a fpclassify macro that works on long doubles.
23139
23140   echo "$as_me:$LINENO: checking whether fpclassify is broken" >&5
23141 echo $ECHO_N "checking whether fpclassify is broken... $ECHO_C" >&6
23142 if test "${have_broken_fpclassify+set}" = set; then
23143   echo $ECHO_N "(cached) $ECHO_C" >&6
23144 else
23145
23146   libgfor_check_for_broken_fpclassify_save_LIBS=$LIBS
23147   LIBS="$LIBS -lm"
23148   if test "$cross_compiling" = yes; then
23149
23150 case "${target}" in
23151   hppa*-*-hpux*) have_broken_fpclassify=yes ;;
23152   *) have_broken_fpclassify=no ;;
23153 esac
23154 else
23155   cat >conftest.$ac_ext <<_ACEOF
23156 /* confdefs.h.  */
23157 _ACEOF
23158 cat confdefs.h >>conftest.$ac_ext
23159 cat >>conftest.$ac_ext <<_ACEOF
23160 /* end confdefs.h.  */
23161
23162 #ifdef HAVE_MATH_H
23163 #include <math.h>
23164 #endif
23165 #include <float.h>
23166 int main ()
23167 {
23168 #ifdef fpclassify
23169 #ifdef LDBL_MAX
23170         if (fpclassify(LDBL_MAX) == FP_NAN
23171             || fpclassify(LDBL_MAX) == FP_INFINITE) return 1;
23172 #endif
23173 #ifdef DBL_MAX
23174         if (fpclassify(DBL_MAX) == FP_NAN
23175             || fpclassify(DBL_MAX) == FP_INFINITE) return 1;
23176 #endif
23177 #endif
23178 return 0;
23179 }
23180 _ACEOF
23181 rm -f conftest$ac_exeext
23182 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23183   (eval $ac_link) 2>&5
23184   ac_status=$?
23185   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23186   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
23187   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23188   (eval $ac_try) 2>&5
23189   ac_status=$?
23190   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23191   (exit $ac_status); }; }; then
23192   have_broken_fpclassify=no
23193 else
23194   echo "$as_me: program exited with status $ac_status" >&5
23195 echo "$as_me: failed program was:" >&5
23196 sed 's/^/| /' conftest.$ac_ext >&5
23197
23198 ( exit $ac_status )
23199 have_broken_fpclassify=yes
23200 fi
23201 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23202 fi
23203   LIBS=$libgfor_check_for_broken_fpclassify_save_LIBS
23204 fi
23205 echo "$as_me:$LINENO: result: $have_broken_fpclassify" >&5
23206 echo "${ECHO_T}$have_broken_fpclassify" >&6
23207 if test x"$have_broken_fpclassify" = xyes; then
23208
23209 cat >>confdefs.h <<\_ACEOF
23210 #define HAVE_BROKEN_FPCLASSIFY 1
23211 _ACEOF
23212
23213 fi
23214
23215 # Check whether the system has a working stat()
23216
23217   echo "$as_me:$LINENO: checking whether the target stat is reliable" >&5
23218 echo $ECHO_N "checking whether the target stat is reliable... $ECHO_C" >&6
23219 if test "${have_working_stat+set}" = set; then
23220   echo $ECHO_N "(cached) $ECHO_C" >&6
23221 else
23222
23223   if test "$cross_compiling" = yes; then
23224
23225 case "${target}" in
23226   *mingw*) have_working_stat=no ;;
23227   *) have_working_stat=yes;;
23228 esac
23229 else
23230   cat >conftest.$ac_ext <<_ACEOF
23231 /* confdefs.h.  */
23232 _ACEOF
23233 cat confdefs.h >>conftest.$ac_ext
23234 cat >>conftest.$ac_ext <<_ACEOF
23235 /* end confdefs.h.  */
23236
23237 #include <stdio.h>
23238 #include <sys/types.h>
23239 #include <sys/stat.h>
23240 #include <unistd.h>
23241
23242 int main ()
23243 {
23244   FILE *f, *g;
23245   struct stat st1, st2;
23246
23247   f = fopen ("foo", "w");
23248   g = fopen ("bar", "w");
23249   if (stat ("foo", &st1) != 0 || stat ("bar", &st2))
23250     return 1;
23251   if (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino)
23252     return 1;
23253   fclose(f);
23254   fclose(g);
23255   return 0;
23256 }
23257 _ACEOF
23258 rm -f conftest$ac_exeext
23259 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23260   (eval $ac_link) 2>&5
23261   ac_status=$?
23262   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23263   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
23264   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23265   (eval $ac_try) 2>&5
23266   ac_status=$?
23267   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23268   (exit $ac_status); }; }; then
23269   have_working_stat=yes
23270 else
23271   echo "$as_me: program exited with status $ac_status" >&5
23272 echo "$as_me: failed program was:" >&5
23273 sed 's/^/| /' conftest.$ac_ext >&5
23274
23275 ( exit $ac_status )
23276 have_working_stat=no
23277 fi
23278 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23279 fi
23280 fi
23281 echo "$as_me:$LINENO: result: $have_working_stat" >&5
23282 echo "${ECHO_T}$have_working_stat" >&6
23283 if test x"$have_working_stat" = xyes; then
23284
23285 cat >>confdefs.h <<\_ACEOF
23286 #define HAVE_WORKING_STAT 1
23287 _ACEOF
23288
23289 fi
23290
23291 # Check for GNU libc feenableexcept
23292 echo "$as_me:$LINENO: checking for feenableexcept in -lm" >&5
23293 echo $ECHO_N "checking for feenableexcept in -lm... $ECHO_C" >&6
23294 if test "${ac_cv_lib_m_feenableexcept+set}" = set; then
23295   echo $ECHO_N "(cached) $ECHO_C" >&6
23296 else
23297   ac_check_lib_save_LIBS=$LIBS
23298 LIBS="-lm  $LIBS"
23299 if test x$gcc_no_link = xyes; then
23300   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23301 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23302    { (exit 1); exit 1; }; }
23303 fi
23304 cat >conftest.$ac_ext <<_ACEOF
23305 /* confdefs.h.  */
23306 _ACEOF
23307 cat confdefs.h >>conftest.$ac_ext
23308 cat >>conftest.$ac_ext <<_ACEOF
23309 /* end confdefs.h.  */
23310
23311 /* Override any gcc2 internal prototype to avoid an error.  */
23312 #ifdef __cplusplus
23313 extern "C"
23314 #endif
23315 /* We use char because int might match the return type of a gcc2
23316    builtin and then its argument prototype would still apply.  */
23317 char feenableexcept ();
23318 int
23319 main ()
23320 {
23321 feenableexcept ();
23322   ;
23323   return 0;
23324 }
23325 _ACEOF
23326 rm -f conftest.$ac_objext conftest$ac_exeext
23327 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23328   (eval $ac_link) 2>conftest.er1
23329   ac_status=$?
23330   grep -v '^ *+' conftest.er1 >conftest.err
23331   rm -f conftest.er1
23332   cat conftest.err >&5
23333   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23334   (exit $ac_status); } &&
23335          { ac_try='test -z "$ac_c_werror_flag"
23336                          || test ! -s conftest.err'
23337   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23338   (eval $ac_try) 2>&5
23339   ac_status=$?
23340   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23341   (exit $ac_status); }; } &&
23342          { ac_try='test -s conftest$ac_exeext'
23343   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23344   (eval $ac_try) 2>&5
23345   ac_status=$?
23346   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23347   (exit $ac_status); }; }; then
23348   ac_cv_lib_m_feenableexcept=yes
23349 else
23350   echo "$as_me: failed program was:" >&5
23351 sed 's/^/| /' conftest.$ac_ext >&5
23352
23353 ac_cv_lib_m_feenableexcept=no
23354 fi
23355 rm -f conftest.err conftest.$ac_objext \
23356       conftest$ac_exeext conftest.$ac_ext
23357 LIBS=$ac_check_lib_save_LIBS
23358 fi
23359 echo "$as_me:$LINENO: result: $ac_cv_lib_m_feenableexcept" >&5
23360 echo "${ECHO_T}$ac_cv_lib_m_feenableexcept" >&6
23361 if test $ac_cv_lib_m_feenableexcept = yes; then
23362   have_feenableexcept=yes
23363 cat >>confdefs.h <<\_ACEOF
23364 #define HAVE_FEENABLEEXCEPT 1
23365 _ACEOF
23366
23367 fi
23368
23369
23370 # Check for SysV fpsetmask
23371
23372   echo "$as_me:$LINENO: checking whether fpsetmask is present" >&5
23373 echo $ECHO_N "checking whether fpsetmask is present... $ECHO_C" >&6
23374 if test "${have_fpsetmask+set}" = set; then
23375   echo $ECHO_N "(cached) $ECHO_C" >&6
23376 else
23377
23378     if test x$gcc_no_link = xyes; then
23379   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23380 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23381    { (exit 1); exit 1; }; }
23382 fi
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 #if HAVE_FLOATINGPOINT_H
23391 # include <floatingpoint.h>
23392 #endif /* HAVE_FLOATINGPOINT_H */
23393 #if HAVE_IEEEFP_H
23394 # include <ieeefp.h>
23395 #endif /* HAVE_IEEEFP_H */
23396 int
23397 main ()
23398 {
23399 fpsetmask(0);
23400   ;
23401   return 0;
23402 }
23403 _ACEOF
23404 rm -f conftest.$ac_objext conftest$ac_exeext
23405 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23406   (eval $ac_link) 2>conftest.er1
23407   ac_status=$?
23408   grep -v '^ *+' conftest.er1 >conftest.err
23409   rm -f conftest.er1
23410   cat conftest.err >&5
23411   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23412   (exit $ac_status); } &&
23413          { ac_try='test -z "$ac_c_werror_flag"
23414                          || test ! -s conftest.err'
23415   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23416   (eval $ac_try) 2>&5
23417   ac_status=$?
23418   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23419   (exit $ac_status); }; } &&
23420          { ac_try='test -s conftest$ac_exeext'
23421   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23422   (eval $ac_try) 2>&5
23423   ac_status=$?
23424   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23425   (exit $ac_status); }; }; then
23426   eval "have_fpsetmask=yes"
23427 else
23428   echo "$as_me: failed program was:" >&5
23429 sed 's/^/| /' conftest.$ac_ext >&5
23430
23431 eval "have_fpsetmask=no"
23432 fi
23433 rm -f conftest.err conftest.$ac_objext \
23434       conftest$ac_exeext conftest.$ac_ext
23435
23436 fi
23437 echo "$as_me:$LINENO: result: $have_fpsetmask" >&5
23438 echo "${ECHO_T}$have_fpsetmask" >&6
23439   if test x"$have_fpsetmask" = xyes; then
23440
23441 cat >>confdefs.h <<\_ACEOF
23442 #define HAVE_FPSETMASK 1
23443 _ACEOF
23444
23445   fi
23446
23447
23448 # Check for AIX fp_trap and fp_enable
23449 echo "$as_me:$LINENO: checking for fp_trap" >&5
23450 echo $ECHO_N "checking for fp_trap... $ECHO_C" >&6
23451 if test "${ac_cv_func_fp_trap+set}" = set; then
23452   echo $ECHO_N "(cached) $ECHO_C" >&6
23453 else
23454   if test x$gcc_no_link = xyes; then
23455   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23456 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23457    { (exit 1); exit 1; }; }
23458 fi
23459 cat >conftest.$ac_ext <<_ACEOF
23460 /* confdefs.h.  */
23461 _ACEOF
23462 cat confdefs.h >>conftest.$ac_ext
23463 cat >>conftest.$ac_ext <<_ACEOF
23464 /* end confdefs.h.  */
23465 /* Define fp_trap to an innocuous variant, in case <limits.h> declares fp_trap.
23466    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
23467 #define fp_trap innocuous_fp_trap
23468
23469 /* System header to define __stub macros and hopefully few prototypes,
23470     which can conflict with char fp_trap (); below.
23471     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
23472     <limits.h> exists even on freestanding compilers.  */
23473
23474 #ifdef __STDC__
23475 # include <limits.h>
23476 #else
23477 # include <assert.h>
23478 #endif
23479
23480 #undef fp_trap
23481
23482 /* Override any gcc2 internal prototype to avoid an error.  */
23483 #ifdef __cplusplus
23484 extern "C"
23485 {
23486 #endif
23487 /* We use char because int might match the return type of a gcc2
23488    builtin and then its argument prototype would still apply.  */
23489 char fp_trap ();
23490 /* The GNU C library defines this for functions which it implements
23491     to always fail with ENOSYS.  Some functions are actually named
23492     something starting with __ and the normal name is an alias.  */
23493 #if defined (__stub_fp_trap) || defined (__stub___fp_trap)
23494 choke me
23495 #else
23496 char (*f) () = fp_trap;
23497 #endif
23498 #ifdef __cplusplus
23499 }
23500 #endif
23501
23502 int
23503 main ()
23504 {
23505 return f != fp_trap;
23506   ;
23507   return 0;
23508 }
23509 _ACEOF
23510 rm -f conftest.$ac_objext conftest$ac_exeext
23511 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23512   (eval $ac_link) 2>conftest.er1
23513   ac_status=$?
23514   grep -v '^ *+' conftest.er1 >conftest.err
23515   rm -f conftest.er1
23516   cat conftest.err >&5
23517   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23518   (exit $ac_status); } &&
23519          { ac_try='test -z "$ac_c_werror_flag"
23520                          || test ! -s conftest.err'
23521   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23522   (eval $ac_try) 2>&5
23523   ac_status=$?
23524   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23525   (exit $ac_status); }; } &&
23526          { ac_try='test -s conftest$ac_exeext'
23527   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23528   (eval $ac_try) 2>&5
23529   ac_status=$?
23530   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23531   (exit $ac_status); }; }; then
23532   ac_cv_func_fp_trap=yes
23533 else
23534   echo "$as_me: failed program was:" >&5
23535 sed 's/^/| /' conftest.$ac_ext >&5
23536
23537 ac_cv_func_fp_trap=no
23538 fi
23539 rm -f conftest.err conftest.$ac_objext \
23540       conftest$ac_exeext conftest.$ac_ext
23541 fi
23542 echo "$as_me:$LINENO: result: $ac_cv_func_fp_trap" >&5
23543 echo "${ECHO_T}$ac_cv_func_fp_trap" >&6
23544 if test $ac_cv_func_fp_trap = yes; then
23545   have_fp_trap=yes
23546 cat >>confdefs.h <<\_ACEOF
23547 #define HAVE_FP_TRAP 1
23548 _ACEOF
23549
23550 fi
23551
23552 echo "$as_me:$LINENO: checking for fp_enable" >&5
23553 echo $ECHO_N "checking for fp_enable... $ECHO_C" >&6
23554 if test "${ac_cv_func_fp_enable+set}" = set; then
23555   echo $ECHO_N "(cached) $ECHO_C" >&6
23556 else
23557   if test x$gcc_no_link = xyes; then
23558   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23559 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23560    { (exit 1); exit 1; }; }
23561 fi
23562 cat >conftest.$ac_ext <<_ACEOF
23563 /* confdefs.h.  */
23564 _ACEOF
23565 cat confdefs.h >>conftest.$ac_ext
23566 cat >>conftest.$ac_ext <<_ACEOF
23567 /* end confdefs.h.  */
23568 /* Define fp_enable to an innocuous variant, in case <limits.h> declares fp_enable.
23569    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
23570 #define fp_enable innocuous_fp_enable
23571
23572 /* System header to define __stub macros and hopefully few prototypes,
23573     which can conflict with char fp_enable (); below.
23574     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
23575     <limits.h> exists even on freestanding compilers.  */
23576
23577 #ifdef __STDC__
23578 # include <limits.h>
23579 #else
23580 # include <assert.h>
23581 #endif
23582
23583 #undef fp_enable
23584
23585 /* Override any gcc2 internal prototype to avoid an error.  */
23586 #ifdef __cplusplus
23587 extern "C"
23588 {
23589 #endif
23590 /* We use char because int might match the return type of a gcc2
23591    builtin and then its argument prototype would still apply.  */
23592 char fp_enable ();
23593 /* The GNU C library defines this for functions which it implements
23594     to always fail with ENOSYS.  Some functions are actually named
23595     something starting with __ and the normal name is an alias.  */
23596 #if defined (__stub_fp_enable) || defined (__stub___fp_enable)
23597 choke me
23598 #else
23599 char (*f) () = fp_enable;
23600 #endif
23601 #ifdef __cplusplus
23602 }
23603 #endif
23604
23605 int
23606 main ()
23607 {
23608 return f != fp_enable;
23609   ;
23610   return 0;
23611 }
23612 _ACEOF
23613 rm -f conftest.$ac_objext conftest$ac_exeext
23614 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23615   (eval $ac_link) 2>conftest.er1
23616   ac_status=$?
23617   grep -v '^ *+' conftest.er1 >conftest.err
23618   rm -f conftest.er1
23619   cat conftest.err >&5
23620   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23621   (exit $ac_status); } &&
23622          { ac_try='test -z "$ac_c_werror_flag"
23623                          || test ! -s conftest.err'
23624   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23625   (eval $ac_try) 2>&5
23626   ac_status=$?
23627   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23628   (exit $ac_status); }; } &&
23629          { ac_try='test -s conftest$ac_exeext'
23630   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23631   (eval $ac_try) 2>&5
23632   ac_status=$?
23633   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23634   (exit $ac_status); }; }; then
23635   ac_cv_func_fp_enable=yes
23636 else
23637   echo "$as_me: failed program was:" >&5
23638 sed 's/^/| /' conftest.$ac_ext >&5
23639
23640 ac_cv_func_fp_enable=no
23641 fi
23642 rm -f conftest.err conftest.$ac_objext \
23643       conftest$ac_exeext conftest.$ac_ext
23644 fi
23645 echo "$as_me:$LINENO: result: $ac_cv_func_fp_enable" >&5
23646 echo "${ECHO_T}$ac_cv_func_fp_enable" >&6
23647 if test $ac_cv_func_fp_enable = yes; then
23648   have_fp_enable=yes
23649 cat >>confdefs.h <<\_ACEOF
23650 #define HAVE_FP_ENABLE 1
23651 _ACEOF
23652
23653 fi
23654
23655
23656 # Runs configure.host to set up necessary host-dependent shell variables.
23657 # We then display a message about it, and propagate them through the
23658 # build chain.
23659 . ${srcdir}/configure.host
23660 { echo "$as_me:$LINENO: FPU dependent file will be ${fpu_host}.h" >&5
23661 echo "$as_me: FPU dependent file will be ${fpu_host}.h" >&6;}
23662 FPU_HOST_HEADER=config/${fpu_host}.h
23663
23664
23665 # Attempt to assert that the target is of common type in case we don't
23666 # have C99 integer types at all.
23667
23668   echo "$as_me:$LINENO: checking whether the target is ILP32" >&5
23669 echo $ECHO_N "checking whether the target is ILP32... $ECHO_C" >&6
23670 if test "${target_ilp32+set}" = set; then
23671   echo $ECHO_N "(cached) $ECHO_C" >&6
23672 else
23673
23674   save_CFLAGS="$CFLAGS"
23675   CFLAGS="-O2"
23676   if test x$gcc_no_link = xyes; then
23677   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23678 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23679    { (exit 1); exit 1; }; }
23680 fi
23681 cat >conftest.$ac_ext <<_ACEOF
23682 /* confdefs.h.  */
23683 _ACEOF
23684 cat confdefs.h >>conftest.$ac_ext
23685 cat >>conftest.$ac_ext <<_ACEOF
23686 /* end confdefs.h.  */
23687
23688 int
23689 main ()
23690 {
23691
23692 if (sizeof(int) == 4 && sizeof(long) == 4 && sizeof(void *) == 4)
23693   ;
23694 else
23695   undefined_function ();
23696
23697   ;
23698   return 0;
23699 }
23700 _ACEOF
23701 rm -f conftest.$ac_objext conftest$ac_exeext
23702 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23703   (eval $ac_link) 2>conftest.er1
23704   ac_status=$?
23705   grep -v '^ *+' conftest.er1 >conftest.err
23706   rm -f conftest.er1
23707   cat conftest.err >&5
23708   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23709   (exit $ac_status); } &&
23710          { ac_try='test -z "$ac_c_werror_flag"
23711                          || test ! -s conftest.err'
23712   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23713   (eval $ac_try) 2>&5
23714   ac_status=$?
23715   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23716   (exit $ac_status); }; } &&
23717          { ac_try='test -s conftest$ac_exeext'
23718   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23719   (eval $ac_try) 2>&5
23720   ac_status=$?
23721   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23722   (exit $ac_status); }; }; then
23723   target_ilp32=yes
23724 else
23725   echo "$as_me: failed program was:" >&5
23726 sed 's/^/| /' conftest.$ac_ext >&5
23727
23728 target_ilp32=no
23729 fi
23730 rm -f conftest.err conftest.$ac_objext \
23731       conftest$ac_exeext conftest.$ac_ext
23732   CFLAGS="$save_CFLAGS"
23733 fi
23734 echo "$as_me:$LINENO: result: $target_ilp32" >&5
23735 echo "${ECHO_T}$target_ilp32" >&6
23736   if test $target_ilp32 = yes; then
23737
23738 cat >>confdefs.h <<\_ACEOF
23739 #define TARGET_ILP32 1
23740 _ACEOF
23741
23742   fi
23743
23744
23745 # Check out attribute support.
23746
23747   echo "$as_me:$LINENO: checking whether the target supports hidden visibility" >&5
23748 echo $ECHO_N "checking whether the target supports hidden visibility... $ECHO_C" >&6
23749 if test "${have_attribute_visibility+set}" = set; then
23750   echo $ECHO_N "(cached) $ECHO_C" >&6
23751 else
23752
23753   save_CFLAGS="$CFLAGS"
23754   CFLAGS="$CFLAGS -Werror"
23755   cat >conftest.$ac_ext <<_ACEOF
23756 /* confdefs.h.  */
23757 _ACEOF
23758 cat confdefs.h >>conftest.$ac_ext
23759 cat >>conftest.$ac_ext <<_ACEOF
23760 /* end confdefs.h.  */
23761 void __attribute__((visibility("hidden"))) foo(void) { }
23762 int
23763 main ()
23764 {
23765
23766   ;
23767   return 0;
23768 }
23769 _ACEOF
23770 rm -f conftest.$ac_objext
23771 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
23772   (eval $ac_compile) 2>conftest.er1
23773   ac_status=$?
23774   grep -v '^ *+' conftest.er1 >conftest.err
23775   rm -f conftest.er1
23776   cat conftest.err >&5
23777   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23778   (exit $ac_status); } &&
23779          { ac_try='test -z "$ac_c_werror_flag"
23780                          || test ! -s conftest.err'
23781   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23782   (eval $ac_try) 2>&5
23783   ac_status=$?
23784   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23785   (exit $ac_status); }; } &&
23786          { ac_try='test -s conftest.$ac_objext'
23787   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23788   (eval $ac_try) 2>&5
23789   ac_status=$?
23790   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23791   (exit $ac_status); }; }; then
23792   have_attribute_visibility=yes
23793 else
23794   echo "$as_me: failed program was:" >&5
23795 sed 's/^/| /' conftest.$ac_ext >&5
23796
23797 have_attribute_visibility=no
23798 fi
23799 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
23800   CFLAGS="$save_CFLAGS"
23801 fi
23802 echo "$as_me:$LINENO: result: $have_attribute_visibility" >&5
23803 echo "${ECHO_T}$have_attribute_visibility" >&6
23804   if test $have_attribute_visibility = yes; then
23805
23806 cat >>confdefs.h <<\_ACEOF
23807 #define HAVE_ATTRIBUTE_VISIBILITY 1
23808 _ACEOF
23809
23810   fi
23811
23812   echo "$as_me:$LINENO: checking whether the target supports dllexport" >&5
23813 echo $ECHO_N "checking whether the target supports dllexport... $ECHO_C" >&6
23814 if test "${have_attribute_dllexport+set}" = set; then
23815   echo $ECHO_N "(cached) $ECHO_C" >&6
23816 else
23817
23818   save_CFLAGS="$CFLAGS"
23819   CFLAGS="$CFLAGS -Werror"
23820   cat >conftest.$ac_ext <<_ACEOF
23821 /* confdefs.h.  */
23822 _ACEOF
23823 cat confdefs.h >>conftest.$ac_ext
23824 cat >>conftest.$ac_ext <<_ACEOF
23825 /* end confdefs.h.  */
23826 void __attribute__((dllexport)) foo(void) { }
23827 int
23828 main ()
23829 {
23830
23831   ;
23832   return 0;
23833 }
23834 _ACEOF
23835 rm -f conftest.$ac_objext
23836 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
23837   (eval $ac_compile) 2>conftest.er1
23838   ac_status=$?
23839   grep -v '^ *+' conftest.er1 >conftest.err
23840   rm -f conftest.er1
23841   cat conftest.err >&5
23842   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23843   (exit $ac_status); } &&
23844          { ac_try='test -z "$ac_c_werror_flag"
23845                          || test ! -s conftest.err'
23846   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23847   (eval $ac_try) 2>&5
23848   ac_status=$?
23849   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23850   (exit $ac_status); }; } &&
23851          { ac_try='test -s conftest.$ac_objext'
23852   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23853   (eval $ac_try) 2>&5
23854   ac_status=$?
23855   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23856   (exit $ac_status); }; }; then
23857   have_attribute_dllexport=yes
23858 else
23859   echo "$as_me: failed program was:" >&5
23860 sed 's/^/| /' conftest.$ac_ext >&5
23861
23862 have_attribute_dllexport=no
23863 fi
23864 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
23865   CFLAGS="$save_CFLAGS"
23866 fi
23867 echo "$as_me:$LINENO: result: $have_attribute_dllexport" >&5
23868 echo "${ECHO_T}$have_attribute_dllexport" >&6
23869   if test $have_attribute_dllexport = yes; then
23870
23871 cat >>confdefs.h <<\_ACEOF
23872 #define HAVE_ATTRIBUTE_DLLEXPORT 1
23873 _ACEOF
23874
23875   fi
23876
23877   echo "$as_me:$LINENO: checking whether the target supports symbol aliases" >&5
23878 echo $ECHO_N "checking whether the target supports symbol aliases... $ECHO_C" >&6
23879 if test "${have_attribute_alias+set}" = set; then
23880   echo $ECHO_N "(cached) $ECHO_C" >&6
23881 else
23882
23883   if test x$gcc_no_link = xyes; then
23884   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23885 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23886    { (exit 1); exit 1; }; }
23887 fi
23888 cat >conftest.$ac_ext <<_ACEOF
23889 /* confdefs.h.  */
23890 _ACEOF
23891 cat confdefs.h >>conftest.$ac_ext
23892 cat >>conftest.$ac_ext <<_ACEOF
23893 /* end confdefs.h.  */
23894
23895 void foo(void) { }
23896 extern void bar(void) __attribute__((alias("foo")));
23897 int
23898 main ()
23899 {
23900 bar();
23901   ;
23902   return 0;
23903 }
23904 _ACEOF
23905 rm -f conftest.$ac_objext conftest$ac_exeext
23906 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23907   (eval $ac_link) 2>conftest.er1
23908   ac_status=$?
23909   grep -v '^ *+' conftest.er1 >conftest.err
23910   rm -f conftest.er1
23911   cat conftest.err >&5
23912   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23913   (exit $ac_status); } &&
23914          { ac_try='test -z "$ac_c_werror_flag"
23915                          || test ! -s conftest.err'
23916   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23917   (eval $ac_try) 2>&5
23918   ac_status=$?
23919   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23920   (exit $ac_status); }; } &&
23921          { ac_try='test -s conftest$ac_exeext'
23922   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23923   (eval $ac_try) 2>&5
23924   ac_status=$?
23925   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23926   (exit $ac_status); }; }; then
23927   have_attribute_alias=yes
23928 else
23929   echo "$as_me: failed program was:" >&5
23930 sed 's/^/| /' conftest.$ac_ext >&5
23931
23932 have_attribute_alias=no
23933 fi
23934 rm -f conftest.err conftest.$ac_objext \
23935       conftest$ac_exeext conftest.$ac_ext
23936 fi
23937 echo "$as_me:$LINENO: result: $have_attribute_alias" >&5
23938 echo "${ECHO_T}$have_attribute_alias" >&6
23939   if test $have_attribute_alias = yes; then
23940
23941 cat >>confdefs.h <<\_ACEOF
23942 #define HAVE_ATTRIBUTE_ALIAS 1
23943 _ACEOF
23944
23945   fi
23946
23947 # Check out sync builtins support.
23948
23949   echo "$as_me:$LINENO: checking whether the target supports __sync_fetch_and_add" >&5
23950 echo $ECHO_N "checking whether the target supports __sync_fetch_and_add... $ECHO_C" >&6
23951 if test "${have_sync_fetch_and_add+set}" = set; then
23952   echo $ECHO_N "(cached) $ECHO_C" >&6
23953 else
23954
23955   if test x$gcc_no_link = xyes; then
23956   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23957 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23958    { (exit 1); exit 1; }; }
23959 fi
23960 cat >conftest.$ac_ext <<_ACEOF
23961 /* confdefs.h.  */
23962 _ACEOF
23963 cat confdefs.h >>conftest.$ac_ext
23964 cat >>conftest.$ac_ext <<_ACEOF
23965 /* end confdefs.h.  */
23966 int foovar = 0;
23967 int
23968 main ()
23969 {
23970
23971 if (foovar <= 0) return __sync_fetch_and_add (&foovar, 1);
23972 if (foovar > 10) return __sync_add_and_fetch (&foovar, -1);
23973   ;
23974   return 0;
23975 }
23976 _ACEOF
23977 rm -f conftest.$ac_objext conftest$ac_exeext
23978 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23979   (eval $ac_link) 2>conftest.er1
23980   ac_status=$?
23981   grep -v '^ *+' conftest.er1 >conftest.err
23982   rm -f conftest.er1
23983   cat conftest.err >&5
23984   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23985   (exit $ac_status); } &&
23986          { ac_try='test -z "$ac_c_werror_flag"
23987                          || test ! -s conftest.err'
23988   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23989   (eval $ac_try) 2>&5
23990   ac_status=$?
23991   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23992   (exit $ac_status); }; } &&
23993          { ac_try='test -s conftest$ac_exeext'
23994   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23995   (eval $ac_try) 2>&5
23996   ac_status=$?
23997   echo "$as_me:$LINENO: \$? = $ac_status" >&5
23998   (exit $ac_status); }; }; then
23999   have_sync_fetch_and_add=yes
24000 else
24001   echo "$as_me: failed program was:" >&5
24002 sed 's/^/| /' conftest.$ac_ext >&5
24003
24004 have_sync_fetch_and_add=no
24005 fi
24006 rm -f conftest.err conftest.$ac_objext \
24007       conftest$ac_exeext conftest.$ac_ext
24008 fi
24009 echo "$as_me:$LINENO: result: $have_sync_fetch_and_add" >&5
24010 echo "${ECHO_T}$have_sync_fetch_and_add" >&6
24011   if test $have_sync_fetch_and_add = yes; then
24012
24013 cat >>confdefs.h <<\_ACEOF
24014 #define HAVE_SYNC_FETCH_AND_ADD 1
24015 _ACEOF
24016
24017   fi
24018
24019 # Check out thread support.
24020
24021   echo "$as_me:$LINENO: checking configured target thread model" >&5
24022 echo $ECHO_N "checking configured target thread model... $ECHO_C" >&6
24023 if test "${target_thread_file+set}" = set; then
24024   echo $ECHO_N "(cached) $ECHO_C" >&6
24025 else
24026
24027 target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`
24028 fi
24029 echo "$as_me:$LINENO: result: $target_thread_file" >&5
24030 echo "${ECHO_T}$target_thread_file" >&6
24031
24032   if test $target_thread_file != single; then
24033
24034 cat >>confdefs.h <<\_ACEOF
24035 #define HAVE_GTHR_DEFAULT 1
24036 _ACEOF
24037
24038   fi
24039
24040 # Check out #pragma weak.
24041
24042   echo "$as_me:$LINENO: checking whether pragma weak works" >&5
24043 echo $ECHO_N "checking whether pragma weak works... $ECHO_C" >&6
24044 if test "${have_pragma_weak+set}" = set; then
24045   echo $ECHO_N "(cached) $ECHO_C" >&6
24046 else
24047
24048   gfor_save_CFLAGS="$CFLAGS"
24049   CFLAGS="$CFLAGS -Wunknown-pragmas"
24050   cat >conftest.$ac_ext <<_ACEOF
24051 /* confdefs.h.  */
24052 _ACEOF
24053 cat confdefs.h >>conftest.$ac_ext
24054 cat >>conftest.$ac_ext <<_ACEOF
24055 /* end confdefs.h.  */
24056 void foo (void);
24057 #pragma weak foo
24058 int
24059 main ()
24060 {
24061 if (foo) foo ();
24062   ;
24063   return 0;
24064 }
24065 _ACEOF
24066 rm -f conftest.$ac_objext
24067 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
24068   (eval $ac_compile) 2>conftest.er1
24069   ac_status=$?
24070   grep -v '^ *+' conftest.er1 >conftest.err
24071   rm -f conftest.er1
24072   cat conftest.err >&5
24073   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24074   (exit $ac_status); } &&
24075          { ac_try='test -z "$ac_c_werror_flag"
24076                          || test ! -s conftest.err'
24077   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24078   (eval $ac_try) 2>&5
24079   ac_status=$?
24080   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24081   (exit $ac_status); }; } &&
24082          { ac_try='test -s conftest.$ac_objext'
24083   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24084   (eval $ac_try) 2>&5
24085   ac_status=$?
24086   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24087   (exit $ac_status); }; }; then
24088   have_pragma_weak=yes
24089 else
24090   echo "$as_me: failed program was:" >&5
24091 sed 's/^/| /' conftest.$ac_ext >&5
24092
24093 have_pragma_weak=no
24094 fi
24095 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
24096 fi
24097 echo "$as_me:$LINENO: result: $have_pragma_weak" >&5
24098 echo "${ECHO_T}$have_pragma_weak" >&6
24099   if test $have_pragma_weak = yes; then
24100
24101 cat >>confdefs.h <<\_ACEOF
24102 #define SUPPORTS_WEAK 1
24103 _ACEOF
24104
24105   fi
24106   case "$host" in
24107     *-*-darwin* | *-*-hpux* | *-*-cygwin*)
24108
24109 cat >>confdefs.h <<\_ACEOF
24110 #define GTHREAD_USE_WEAK 0
24111 _ACEOF
24112
24113       ;;
24114   esac
24115
24116 # Various other checks on target
24117
24118   echo "$as_me:$LINENO: checking whether the target can unlink an open file" >&5
24119 echo $ECHO_N "checking whether the target can unlink an open file... $ECHO_C" >&6
24120 if test "${have_unlink_open_file+set}" = set; then
24121   echo $ECHO_N "(cached) $ECHO_C" >&6
24122 else
24123
24124   if test "$cross_compiling" = yes; then
24125
24126 case "${target}" in
24127   *mingw*) have_unlink_open_file=no ;;
24128   *) have_unlink_open_file=yes;;
24129 esac
24130 else
24131   cat >conftest.$ac_ext <<_ACEOF
24132 /* confdefs.h.  */
24133 _ACEOF
24134 cat confdefs.h >>conftest.$ac_ext
24135 cat >>conftest.$ac_ext <<_ACEOF
24136 /* end confdefs.h.  */
24137
24138 #include <errno.h>
24139 #include <fcntl.h>
24140 #include <unistd.h>
24141 #include <sys/stat.h>
24142
24143 int main ()
24144 {
24145   int fd;
24146
24147   fd = open ("testfile", O_RDWR | O_CREAT, S_IWRITE | S_IREAD);
24148   if (fd <= 0)
24149     return 0;
24150   if (unlink ("testfile") == -1)
24151     return 1;
24152   write (fd, "This is a test\n", 15);
24153   close (fd);
24154
24155   if (open ("testfile", O_RDONLY, S_IWRITE | S_IREAD) == -1 && errno == ENOENT)
24156     return 0;
24157   else
24158     return 1;
24159 }
24160 _ACEOF
24161 rm -f conftest$ac_exeext
24162 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
24163   (eval $ac_link) 2>&5
24164   ac_status=$?
24165   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24166   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
24167   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24168   (eval $ac_try) 2>&5
24169   ac_status=$?
24170   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24171   (exit $ac_status); }; }; then
24172   have_unlink_open_file=yes
24173 else
24174   echo "$as_me: program exited with status $ac_status" >&5
24175 echo "$as_me: failed program was:" >&5
24176 sed 's/^/| /' conftest.$ac_ext >&5
24177
24178 ( exit $ac_status )
24179 have_unlink_open_file=no
24180 fi
24181 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
24182 fi
24183 fi
24184 echo "$as_me:$LINENO: result: $have_unlink_open_file" >&5
24185 echo "${ECHO_T}$have_unlink_open_file" >&6
24186 if test x"$have_unlink_open_file" = xyes; then
24187
24188 cat >>confdefs.h <<\_ACEOF
24189 #define HAVE_UNLINK_OPEN_FILE 1
24190 _ACEOF
24191
24192 fi
24193
24194 # Check whether line terminator is LF or CRLF
24195
24196   echo "$as_me:$LINENO: checking whether the target has CRLF as line terminator" >&5
24197 echo $ECHO_N "checking whether the target has CRLF as line terminator... $ECHO_C" >&6
24198 if test "${have_crlf+set}" = set; then
24199   echo $ECHO_N "(cached) $ECHO_C" >&6
24200 else
24201
24202   if test "$cross_compiling" = yes; then
24203
24204 case "${target}" in
24205   *mingw*) have_crlf=yes ;;
24206   *) have_crlf=no;;
24207 esac
24208 else
24209   cat >conftest.$ac_ext <<_ACEOF
24210 /* confdefs.h.  */
24211 _ACEOF
24212 cat confdefs.h >>conftest.$ac_ext
24213 cat >>conftest.$ac_ext <<_ACEOF
24214 /* end confdefs.h.  */
24215
24216 /* This test program should exit with status 0 if system uses a CRLF as
24217    line terminator, and status 1 otherwise.
24218    Since it is used to check for mingw systems, and should return 0 in any
24219    other case, in case of a failure we will not use CRLF.  */
24220 #include <sys/stat.h>
24221 #include <stdlib.h>
24222 #include <fcntl.h>
24223 #include <stdio.h>
24224
24225 int main ()
24226 {
24227 #ifndef O_BINARY
24228   exit(1);
24229 #else
24230   int fd, bytes;
24231   char buff[5];
24232
24233   fd = open ("foo", O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
24234   if (fd < 0)
24235     exit(1);
24236   if (write (fd, "\n", 1) < 0)
24237     perror ("write");
24238
24239   close (fd);
24240
24241   if ((fd = open ("foo", O_RDONLY | O_BINARY, S_IRWXU)) < 0)
24242     exit(1);
24243   bytes = read (fd, buff, 5);
24244   if (bytes == 2 && buff[0] == '\r' && buff[1] == '\n')
24245     exit(0);
24246   else
24247     exit(1);
24248 #endif
24249 }
24250 _ACEOF
24251 rm -f conftest$ac_exeext
24252 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
24253   (eval $ac_link) 2>&5
24254   ac_status=$?
24255   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24256   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
24257   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
24258   (eval $ac_try) 2>&5
24259   ac_status=$?
24260   echo "$as_me:$LINENO: \$? = $ac_status" >&5
24261   (exit $ac_status); }; }; then
24262   have_crlf=yes
24263 else
24264   echo "$as_me: program exited with status $ac_status" >&5
24265 echo "$as_me: failed program was:" >&5
24266 sed 's/^/| /' conftest.$ac_ext >&5
24267
24268 ( exit $ac_status )
24269 have_crlf=no
24270 fi
24271 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
24272 fi
24273 fi
24274 echo "$as_me:$LINENO: result: $have_crlf" >&5
24275 echo "${ECHO_T}$have_crlf" >&6
24276 if test x"$have_crlf" = xyes; then
24277
24278 cat >>confdefs.h <<\_ACEOF
24279 #define HAVE_CRLF 1
24280 _ACEOF
24281
24282 fi
24283
24284 cat >confcache <<\_ACEOF
24285 # This file is a shell script that caches the results of configure
24286 # tests run on this system so they can be shared between configure
24287 # scripts and configure runs, see configure's option --config-cache.
24288 # It is not useful on other systems.  If it contains results you don't
24289 # want to keep, you may remove or edit it.
24290 #
24291 # config.status only pays attention to the cache file if you give it
24292 # the --recheck option to rerun configure.
24293 #
24294 # `ac_cv_env_foo' variables (set or unset) will be overridden when
24295 # loading this file, other *unset* `ac_cv_foo' will be assigned the
24296 # following values.
24297
24298 _ACEOF
24299
24300 # The following way of writing the cache mishandles newlines in values,
24301 # but we know of no workaround that is simple, portable, and efficient.
24302 # So, don't put newlines in cache variables' values.
24303 # Ultrix sh set writes to stderr and can't be redirected directly,
24304 # and sets the high bit in the cache file unless we assign to the vars.
24305 {
24306   (set) 2>&1 |
24307     case `(ac_space=' '; set | grep ac_space) 2>&1` in
24308     *ac_space=\ *)
24309       # `set' does not quote correctly, so add quotes (double-quote
24310       # substitution turns \\\\ into \\, and sed turns \\ into \).
24311       sed -n \
24312         "s/'/'\\\\''/g;
24313           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
24314       ;;
24315     *)
24316       # `set' quotes correctly as required by POSIX, so do not add quotes.
24317       sed -n \
24318         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
24319       ;;
24320     esac;
24321 } |
24322   sed '
24323      t clear
24324      : clear
24325      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
24326      t end
24327      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
24328      : end' >>confcache
24329 if diff $cache_file confcache >/dev/null 2>&1; then :; else
24330   if test -w $cache_file; then
24331     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
24332     cat confcache >$cache_file
24333   else
24334     echo "not updating unwritable cache $cache_file"
24335   fi
24336 fi
24337 rm -f confcache
24338
24339 if test ${multilib} = yes; then
24340   multilib_arg="--enable-multilib"
24341 else
24342   multilib_arg=
24343 fi
24344
24345 # Write our Makefile.
24346           ac_config_files="$ac_config_files Makefile"
24347
24348 cat >confcache <<\_ACEOF
24349 # This file is a shell script that caches the results of configure
24350 # tests run on this system so they can be shared between configure
24351 # scripts and configure runs, see configure's option --config-cache.
24352 # It is not useful on other systems.  If it contains results you don't
24353 # want to keep, you may remove or edit it.
24354 #
24355 # config.status only pays attention to the cache file if you give it
24356 # the --recheck option to rerun configure.
24357 #
24358 # `ac_cv_env_foo' variables (set or unset) will be overridden when
24359 # loading this file, other *unset* `ac_cv_foo' will be assigned the
24360 # following values.
24361
24362 _ACEOF
24363
24364 # The following way of writing the cache mishandles newlines in values,
24365 # but we know of no workaround that is simple, portable, and efficient.
24366 # So, don't put newlines in cache variables' values.
24367 # Ultrix sh set writes to stderr and can't be redirected directly,
24368 # and sets the high bit in the cache file unless we assign to the vars.
24369 {
24370   (set) 2>&1 |
24371     case `(ac_space=' '; set | grep ac_space) 2>&1` in
24372     *ac_space=\ *)
24373       # `set' does not quote correctly, so add quotes (double-quote
24374       # substitution turns \\\\ into \\, and sed turns \\ into \).
24375       sed -n \
24376         "s/'/'\\\\''/g;
24377           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
24378       ;;
24379     *)
24380       # `set' quotes correctly as required by POSIX, so do not add quotes.
24381       sed -n \
24382         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
24383       ;;
24384     esac;
24385 } |
24386   sed '
24387      t clear
24388      : clear
24389      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
24390      t end
24391      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
24392      : end' >>confcache
24393 if diff $cache_file confcache >/dev/null 2>&1; then :; else
24394   if test -w $cache_file; then
24395     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
24396     cat confcache >$cache_file
24397   else
24398     echo "not updating unwritable cache $cache_file"
24399   fi
24400 fi
24401 rm -f confcache
24402
24403 test "x$prefix" = xNONE && prefix=$ac_default_prefix
24404 # Let make expand exec_prefix.
24405 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
24406
24407 # VPATH may cause trouble with some makes, so we remove $(srcdir),
24408 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
24409 # trailing colons and then remove the whole line if VPATH becomes empty
24410 # (actually we leave an empty line to preserve line numbers).
24411 if test "x$srcdir" = x.; then
24412   ac_vpsub='/^[  ]*VPATH[        ]*=/{
24413 s/:*\$(srcdir):*/:/;
24414 s/:*\${srcdir}:*/:/;
24415 s/:*@srcdir@:*/:/;
24416 s/^\([^=]*=[     ]*\):*/\1/;
24417 s/:*$//;
24418 s/^[^=]*=[       ]*$//;
24419 }'
24420 fi
24421
24422 DEFS=-DHAVE_CONFIG_H
24423
24424 ac_libobjs=
24425 ac_ltlibobjs=
24426 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
24427   # 1. Remove the extension, and $U if already installed.
24428   ac_i=`echo "$ac_i" |
24429          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
24430   # 2. Add them.
24431   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
24432   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
24433 done
24434 LIBOBJS=$ac_libobjs
24435
24436 LTLIBOBJS=$ac_ltlibobjs
24437
24438
24439 if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then
24440   { { echo "$as_me:$LINENO: error: conditional \"MAINTAINER_MODE\" was never defined.
24441 Usually this means the macro was only invoked conditionally." >&5
24442 echo "$as_me: error: conditional \"MAINTAINER_MODE\" was never defined.
24443 Usually this means the macro was only invoked conditionally." >&2;}
24444    { (exit 1); exit 1; }; }
24445 fi
24446 if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
24447   { { echo "$as_me:$LINENO: error: conditional \"AMDEP\" was never defined.
24448 Usually this means the macro was only invoked conditionally." >&5
24449 echo "$as_me: error: conditional \"AMDEP\" was never defined.
24450 Usually this means the macro was only invoked conditionally." >&2;}
24451    { (exit 1); exit 1; }; }
24452 fi
24453 if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
24454   { { echo "$as_me:$LINENO: error: conditional \"am__fastdepCC\" was never defined.
24455 Usually this means the macro was only invoked conditionally." >&5
24456 echo "$as_me: error: conditional \"am__fastdepCC\" was never defined.
24457 Usually this means the macro was only invoked conditionally." >&2;}
24458    { (exit 1); exit 1; }; }
24459 fi
24460
24461 : ${CONFIG_STATUS=./config.status}
24462 ac_clean_files_save=$ac_clean_files
24463 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
24464 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
24465 echo "$as_me: creating $CONFIG_STATUS" >&6;}
24466 cat >$CONFIG_STATUS <<_ACEOF
24467 #! $SHELL
24468 # Generated by $as_me.
24469 # Run this file to recreate the current configuration.
24470 # Compiler output produced by configure, useful for debugging
24471 # configure, is in config.log if it exists.
24472
24473 debug=false
24474 ac_cs_recheck=false
24475 ac_cs_silent=false
24476 SHELL=\${CONFIG_SHELL-$SHELL}
24477 _ACEOF
24478
24479 cat >>$CONFIG_STATUS <<\_ACEOF
24480 ## --------------------- ##
24481 ## M4sh Initialization.  ##
24482 ## --------------------- ##
24483
24484 # Be Bourne compatible
24485 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
24486   emulate sh
24487   NULLCMD=:
24488   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
24489   # is contrary to our usage.  Disable this feature.
24490   alias -g '${1+"$@"}'='"$@"'
24491 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
24492   set -o posix
24493 fi
24494 DUALCASE=1; export DUALCASE # for MKS sh
24495
24496 # Support unset when possible.
24497 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
24498   as_unset=unset
24499 else
24500   as_unset=false
24501 fi
24502
24503
24504 # Work around bugs in pre-3.0 UWIN ksh.
24505 $as_unset ENV MAIL MAILPATH
24506 PS1='$ '
24507 PS2='> '
24508 PS4='+ '
24509
24510 # NLS nuisances.
24511 for as_var in \
24512   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
24513   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
24514   LC_TELEPHONE LC_TIME
24515 do
24516   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
24517     eval $as_var=C; export $as_var
24518   else
24519     $as_unset $as_var
24520   fi
24521 done
24522
24523 # Required to use basename.
24524 if expr a : '\(a\)' >/dev/null 2>&1; then
24525   as_expr=expr
24526 else
24527   as_expr=false
24528 fi
24529
24530 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
24531   as_basename=basename
24532 else
24533   as_basename=false
24534 fi
24535
24536
24537 # Name of the executable.
24538 as_me=`$as_basename "$0" ||
24539 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
24540          X"$0" : 'X\(//\)$' \| \
24541          X"$0" : 'X\(/\)$' \| \
24542          .     : '\(.\)' 2>/dev/null ||
24543 echo X/"$0" |
24544     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
24545           /^X\/\(\/\/\)$/{ s//\1/; q; }
24546           /^X\/\(\/\).*/{ s//\1/; q; }
24547           s/.*/./; q'`
24548
24549
24550 # PATH needs CR, and LINENO needs CR and PATH.
24551 # Avoid depending upon Character Ranges.
24552 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
24553 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
24554 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
24555 as_cr_digits='0123456789'
24556 as_cr_alnum=$as_cr_Letters$as_cr_digits
24557
24558 # The user is always right.
24559 if test "${PATH_SEPARATOR+set}" != set; then
24560   echo "#! /bin/sh" >conf$$.sh
24561   echo  "exit 0"   >>conf$$.sh
24562   chmod +x conf$$.sh
24563   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
24564     PATH_SEPARATOR=';'
24565   else
24566     PATH_SEPARATOR=:
24567   fi
24568   rm -f conf$$.sh
24569 fi
24570
24571
24572   as_lineno_1=$LINENO
24573   as_lineno_2=$LINENO
24574   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
24575   test "x$as_lineno_1" != "x$as_lineno_2" &&
24576   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
24577   # Find who we are.  Look in the path if we contain no path at all
24578   # relative or not.
24579   case $0 in
24580     *[\\/]* ) as_myself=$0 ;;
24581     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24582 for as_dir in $PATH
24583 do
24584   IFS=$as_save_IFS
24585   test -z "$as_dir" && as_dir=.
24586   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
24587 done
24588
24589        ;;
24590   esac
24591   # We did not find ourselves, most probably we were run as `sh COMMAND'
24592   # in which case we are not to be found in the path.
24593   if test "x$as_myself" = x; then
24594     as_myself=$0
24595   fi
24596   if test ! -f "$as_myself"; then
24597     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
24598 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
24599    { (exit 1); exit 1; }; }
24600   fi
24601   case $CONFIG_SHELL in
24602   '')
24603     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24604 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
24605 do
24606   IFS=$as_save_IFS
24607   test -z "$as_dir" && as_dir=.
24608   for as_base in sh bash ksh sh5; do
24609          case $as_dir in
24610          /*)
24611            if ("$as_dir/$as_base" -c '
24612   as_lineno_1=$LINENO
24613   as_lineno_2=$LINENO
24614   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
24615   test "x$as_lineno_1" != "x$as_lineno_2" &&
24616   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
24617              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
24618              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
24619              CONFIG_SHELL=$as_dir/$as_base
24620              export CONFIG_SHELL
24621              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
24622            fi;;
24623          esac
24624        done
24625 done
24626 ;;
24627   esac
24628
24629   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
24630   # uniformly replaced by the line number.  The first 'sed' inserts a
24631   # line-number line before each line; the second 'sed' does the real
24632   # work.  The second script uses 'N' to pair each line-number line
24633   # with the numbered line, and appends trailing '-' during
24634   # substitution so that $LINENO is not a special case at line end.
24635   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
24636   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
24637   sed '=' <$as_myself |
24638     sed '
24639       N
24640       s,$,-,
24641       : loop
24642       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
24643       t loop
24644       s,-$,,
24645       s,^['$as_cr_digits']*\n,,
24646     ' >$as_me.lineno &&
24647   chmod +x $as_me.lineno ||
24648     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
24649 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
24650    { (exit 1); exit 1; }; }
24651
24652   # Don't try to exec as it changes $[0], causing all sort of problems
24653   # (the dirname of $[0] is not the place where we might find the
24654   # original and so on.  Autoconf is especially sensible to this).
24655   . ./$as_me.lineno
24656   # Exit status is that of the last command.
24657   exit
24658 }
24659
24660
24661 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
24662   *c*,-n*) ECHO_N= ECHO_C='
24663 ' ECHO_T='      ' ;;
24664   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
24665   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
24666 esac
24667
24668 if expr a : '\(a\)' >/dev/null 2>&1; then
24669   as_expr=expr
24670 else
24671   as_expr=false
24672 fi
24673
24674 rm -f conf$$ conf$$.exe conf$$.file
24675 echo >conf$$.file
24676 if ln -s conf$$.file conf$$ 2>/dev/null; then
24677   # We could just check for DJGPP; but this test a) works b) is more generic
24678   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
24679   if test -f conf$$.exe; then
24680     # Don't use ln at all; we don't have any links
24681     as_ln_s='cp -p'
24682   else
24683     as_ln_s='ln -s'
24684   fi
24685 elif ln conf$$.file conf$$ 2>/dev/null; then
24686   as_ln_s=ln
24687 else
24688   as_ln_s='cp -p'
24689 fi
24690 rm -f conf$$ conf$$.exe conf$$.file
24691
24692 if mkdir -p . 2>/dev/null; then
24693   as_mkdir_p=:
24694 else
24695   test -d ./-p && rmdir ./-p
24696   as_mkdir_p=false
24697 fi
24698
24699 as_executable_p="test -f"
24700
24701 # Sed expression to map a string onto a valid CPP name.
24702 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
24703
24704 # Sed expression to map a string onto a valid variable name.
24705 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
24706
24707
24708 # IFS
24709 # We need space, tab and new line, in precisely that order.
24710 as_nl='
24711 '
24712 IFS="   $as_nl"
24713
24714 # CDPATH.
24715 $as_unset CDPATH
24716
24717 exec 6>&1
24718
24719 # Open the log real soon, to keep \$[0] and so on meaningful, and to
24720 # report actual input values of CONFIG_FILES etc. instead of their
24721 # values after options handling.  Logging --version etc. is OK.
24722 exec 5>>config.log
24723 {
24724   echo
24725   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
24726 ## Running $as_me. ##
24727 _ASBOX
24728 } >&5
24729 cat >&5 <<_CSEOF
24730
24731 This file was extended by GNU Fortran Runtime Library $as_me 0.3, which was
24732 generated by GNU Autoconf 2.59.  Invocation command line was
24733
24734   CONFIG_FILES    = $CONFIG_FILES
24735   CONFIG_HEADERS  = $CONFIG_HEADERS
24736   CONFIG_LINKS    = $CONFIG_LINKS
24737   CONFIG_COMMANDS = $CONFIG_COMMANDS
24738   $ $0 $@
24739
24740 _CSEOF
24741 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
24742 echo >&5
24743 _ACEOF
24744
24745 # Files that config.status was made for.
24746 if test -n "$ac_config_files"; then
24747   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
24748 fi
24749
24750 if test -n "$ac_config_headers"; then
24751   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
24752 fi
24753
24754 if test -n "$ac_config_links"; then
24755   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
24756 fi
24757
24758 if test -n "$ac_config_commands"; then
24759   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
24760 fi
24761
24762 cat >>$CONFIG_STATUS <<\_ACEOF
24763
24764 ac_cs_usage="\
24765 \`$as_me' instantiates files from templates according to the
24766 current configuration.
24767
24768 Usage: $0 [OPTIONS] [FILE]...
24769
24770   -h, --help       print this help, then exit
24771   -V, --version    print version number, then exit
24772   -q, --quiet      do not print progress messages
24773   -d, --debug      don't remove temporary files
24774       --recheck    update $as_me by reconfiguring in the same conditions
24775   --file=FILE[:TEMPLATE]
24776                    instantiate the configuration file FILE
24777   --header=FILE[:TEMPLATE]
24778                    instantiate the configuration header FILE
24779
24780 Configuration files:
24781 $config_files
24782
24783 Configuration headers:
24784 $config_headers
24785
24786 Configuration commands:
24787 $config_commands
24788
24789 Report bugs to <bug-autoconf@gnu.org>."
24790 _ACEOF
24791
24792 cat >>$CONFIG_STATUS <<_ACEOF
24793 ac_cs_version="\\
24794 GNU Fortran Runtime Library config.status 0.3
24795 configured by $0, generated by GNU Autoconf 2.59,
24796   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
24797
24798 Copyright (C) 2003 Free Software Foundation, Inc.
24799 This config.status script is free software; the Free Software Foundation
24800 gives unlimited permission to copy, distribute and modify it."
24801 srcdir=$srcdir
24802 INSTALL="$INSTALL"
24803 _ACEOF
24804
24805 cat >>$CONFIG_STATUS <<\_ACEOF
24806 # If no file are specified by the user, then we need to provide default
24807 # value.  By we need to know if files were specified by the user.
24808 ac_need_defaults=:
24809 while test $# != 0
24810 do
24811   case $1 in
24812   --*=*)
24813     ac_option=`expr "x$1" : 'x\([^=]*\)='`
24814     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
24815     ac_shift=:
24816     ;;
24817   -*)
24818     ac_option=$1
24819     ac_optarg=$2
24820     ac_shift=shift
24821     ;;
24822   *) # This is not an option, so the user has probably given explicit
24823      # arguments.
24824      ac_option=$1
24825      ac_need_defaults=false;;
24826   esac
24827
24828   case $ac_option in
24829   # Handling of the options.
24830 _ACEOF
24831 cat >>$CONFIG_STATUS <<\_ACEOF
24832   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
24833     ac_cs_recheck=: ;;
24834   --version | --vers* | -V )
24835     echo "$ac_cs_version"; exit 0 ;;
24836   --he | --h)
24837     # Conflict between --help and --header
24838     { { echo "$as_me:$LINENO: error: ambiguous option: $1
24839 Try \`$0 --help' for more information." >&5
24840 echo "$as_me: error: ambiguous option: $1
24841 Try \`$0 --help' for more information." >&2;}
24842    { (exit 1); exit 1; }; };;
24843   --help | --hel | -h )
24844     echo "$ac_cs_usage"; exit 0 ;;
24845   --debug | --d* | -d )
24846     debug=: ;;
24847   --file | --fil | --fi | --f )
24848     $ac_shift
24849     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
24850     ac_need_defaults=false;;
24851   --header | --heade | --head | --hea )
24852     $ac_shift
24853     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
24854     ac_need_defaults=false;;
24855   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
24856   | -silent | --silent | --silen | --sile | --sil | --si | --s)
24857     ac_cs_silent=: ;;
24858
24859   # This is an error.
24860   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
24861 Try \`$0 --help' for more information." >&5
24862 echo "$as_me: error: unrecognized option: $1
24863 Try \`$0 --help' for more information." >&2;}
24864    { (exit 1); exit 1; }; } ;;
24865
24866   *) ac_config_targets="$ac_config_targets $1" ;;
24867
24868   esac
24869   shift
24870 done
24871
24872 ac_configure_extra_args=
24873
24874 if $ac_cs_silent; then
24875   exec 6>/dev/null
24876   ac_configure_extra_args="$ac_configure_extra_args --silent"
24877 fi
24878
24879 _ACEOF
24880 cat >>$CONFIG_STATUS <<_ACEOF
24881 if \$ac_cs_recheck; then
24882   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
24883   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
24884 fi
24885
24886 _ACEOF
24887
24888 cat >>$CONFIG_STATUS <<_ACEOF
24889 #
24890 # INIT-COMMANDS section.
24891 #
24892
24893
24894 srcdir="$srcdir"
24895 host="$host"
24896 target="$target"
24897 with_multisubdir="$with_multisubdir"
24898 with_multisrctop="$with_multisrctop"
24899 with_target_subdir="$with_target_subdir"
24900 ac_configure_args="${multilib_arg} ${ac_configure_args}"
24901 multi_basedir="$multi_basedir"
24902 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
24903 CC="$CC"
24904 AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
24905
24906 GCC="$GCC"
24907 CC="$CC"
24908 acx_cv_header_stdint="$acx_cv_header_stdint"
24909 acx_cv_type_int8_t="$acx_cv_type_int8_t"
24910 acx_cv_type_int16_t="$acx_cv_type_int16_t"
24911 acx_cv_type_int32_t="$acx_cv_type_int32_t"
24912 acx_cv_type_int64_t="$acx_cv_type_int64_t"
24913 acx_cv_type_intptr_t="$acx_cv_type_intptr_t"
24914 ac_cv_type_uintmax_t="$ac_cv_type_uintmax_t"
24915 ac_cv_type_uintptr_t="$ac_cv_type_uintptr_t"
24916 ac_cv_type_uint64_t="$ac_cv_type_uint64_t"
24917 ac_cv_type_u_int64_t="$ac_cv_type_u_int64_t"
24918 ac_cv_type_u_int32_t="$ac_cv_type_u_int32_t"
24919 ac_cv_type_int_least32_t="$ac_cv_type_int_least32_t"
24920 ac_cv_type_int_fast32_t="$ac_cv_type_int_fast32_t"
24921 ac_cv_sizeof_void_p="$ac_cv_sizeof_void_p"
24922
24923
24924 _ACEOF
24925
24926
24927
24928 cat >>$CONFIG_STATUS <<\_ACEOF
24929 for ac_config_target in $ac_config_targets
24930 do
24931   case "$ac_config_target" in
24932   # Handling of arguments.
24933   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
24934   "default-1" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default-1" ;;
24935   "depfiles" ) CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
24936   "gstdint.h" ) CONFIG_COMMANDS="$CONFIG_COMMANDS gstdint.h" ;;
24937   "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
24938   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
24939 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
24940    { (exit 1); exit 1; }; };;
24941   esac
24942 done
24943
24944 # If the user did not use the arguments to specify the items to instantiate,
24945 # then the envvar interface is used.  Set only those that are not.
24946 # We use the long form for the default assignment because of an extremely
24947 # bizarre bug on SunOS 4.1.3.
24948 if $ac_need_defaults; then
24949   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
24950   test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
24951   test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
24952 fi
24953
24954 # Have a temporary directory for convenience.  Make it in the build tree
24955 # simply because there is no reason to put it here, and in addition,
24956 # creating and moving files from /tmp can sometimes cause problems.
24957 # Create a temporary directory, and hook for its removal unless debugging.
24958 $debug ||
24959 {
24960   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
24961   trap '{ (exit 1); exit 1; }' 1 2 13 15
24962 }
24963
24964 # Create a (secure) tmp directory for tmp files.
24965
24966 {
24967   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
24968   test -n "$tmp" && test -d "$tmp"
24969 }  ||
24970 {
24971   tmp=./confstat$$-$RANDOM
24972   (umask 077 && mkdir $tmp)
24973 } ||
24974 {
24975    echo "$me: cannot create a temporary directory in ." >&2
24976    { (exit 1); exit 1; }
24977 }
24978
24979 _ACEOF
24980
24981 cat >>$CONFIG_STATUS <<_ACEOF
24982
24983 #
24984 # CONFIG_FILES section.
24985 #
24986
24987 # No need to generate the scripts if there are no CONFIG_FILES.
24988 # This happens for instance when ./config.status config.h
24989 if test -n "\$CONFIG_FILES"; then
24990   # Protect against being on the right side of a sed subst in config.status.
24991   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
24992    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
24993 s,@SHELL@,$SHELL,;t t
24994 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
24995 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
24996 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
24997 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
24998 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
24999 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
25000 s,@exec_prefix@,$exec_prefix,;t t
25001 s,@prefix@,$prefix,;t t
25002 s,@program_transform_name@,$program_transform_name,;t t
25003 s,@bindir@,$bindir,;t t
25004 s,@sbindir@,$sbindir,;t t
25005 s,@libexecdir@,$libexecdir,;t t
25006 s,@datadir@,$datadir,;t t
25007 s,@sysconfdir@,$sysconfdir,;t t
25008 s,@sharedstatedir@,$sharedstatedir,;t t
25009 s,@localstatedir@,$localstatedir,;t t
25010 s,@libdir@,$libdir,;t t
25011 s,@includedir@,$includedir,;t t
25012 s,@oldincludedir@,$oldincludedir,;t t
25013 s,@infodir@,$infodir,;t t
25014 s,@mandir@,$mandir,;t t
25015 s,@build_alias@,$build_alias,;t t
25016 s,@host_alias@,$host_alias,;t t
25017 s,@target_alias@,$target_alias,;t t
25018 s,@DEFS@,$DEFS,;t t
25019 s,@ECHO_C@,$ECHO_C,;t t
25020 s,@ECHO_N@,$ECHO_N,;t t
25021 s,@ECHO_T@,$ECHO_T,;t t
25022 s,@LIBS@,$LIBS,;t t
25023 s,@build@,$build,;t t
25024 s,@build_cpu@,$build_cpu,;t t
25025 s,@build_vendor@,$build_vendor,;t t
25026 s,@build_os@,$build_os,;t t
25027 s,@build_libsubdir@,$build_libsubdir,;t t
25028 s,@build_subdir@,$build_subdir,;t t
25029 s,@host_subdir@,$host_subdir,;t t
25030 s,@target_subdir@,$target_subdir,;t t
25031 s,@host@,$host,;t t
25032 s,@host_cpu@,$host_cpu,;t t
25033 s,@host_vendor@,$host_vendor,;t t
25034 s,@host_os@,$host_os,;t t
25035 s,@target@,$target,;t t
25036 s,@target_cpu@,$target_cpu,;t t
25037 s,@target_vendor@,$target_vendor,;t t
25038 s,@target_os@,$target_os,;t t
25039 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
25040 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
25041 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
25042 s,@CYGPATH_W@,$CYGPATH_W,;t t
25043 s,@PACKAGE@,$PACKAGE,;t t
25044 s,@VERSION@,$VERSION,;t t
25045 s,@ACLOCAL@,$ACLOCAL,;t t
25046 s,@AUTOCONF@,$AUTOCONF,;t t
25047 s,@AUTOMAKE@,$AUTOMAKE,;t t
25048 s,@AUTOHEADER@,$AUTOHEADER,;t t
25049 s,@MAKEINFO@,$MAKEINFO,;t t
25050 s,@install_sh@,$install_sh,;t t
25051 s,@STRIP@,$STRIP,;t t
25052 s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t
25053 s,@INSTALL_STRIP_PROGRAM@,$INSTALL_STRIP_PROGRAM,;t t
25054 s,@mkdir_p@,$mkdir_p,;t t
25055 s,@AWK@,$AWK,;t t
25056 s,@SET_MAKE@,$SET_MAKE,;t t
25057 s,@am__leading_dot@,$am__leading_dot,;t t
25058 s,@AMTAR@,$AMTAR,;t t
25059 s,@am__tar@,$am__tar,;t t
25060 s,@am__untar@,$am__untar,;t t
25061 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
25062 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
25063 s,@MAINT@,$MAINT,;t t
25064 s,@multi_basedir@,$multi_basedir,;t t
25065 s,@toolexecdir@,$toolexecdir,;t t
25066 s,@toolexeclibdir@,$toolexeclibdir,;t t
25067 s,@CC@,$CC,;t t
25068 s,@ac_ct_CC@,$ac_ct_CC,;t t
25069 s,@EXEEXT@,$EXEEXT,;t t
25070 s,@OBJEXT@,$OBJEXT,;t t
25071 s,@DEPDIR@,$DEPDIR,;t t
25072 s,@am__include@,$am__include,;t t
25073 s,@am__quote@,$am__quote,;t t
25074 s,@AMDEP_TRUE@,$AMDEP_TRUE,;t t
25075 s,@AMDEP_FALSE@,$AMDEP_FALSE,;t t
25076 s,@AMDEPBACKSLASH@,$AMDEPBACKSLASH,;t t
25077 s,@CCDEPMODE@,$CCDEPMODE,;t t
25078 s,@am__fastdepCC_TRUE@,$am__fastdepCC_TRUE,;t t
25079 s,@am__fastdepCC_FALSE@,$am__fastdepCC_FALSE,;t t
25080 s,@AM_FCFLAGS@,$AM_FCFLAGS,;t t
25081 s,@AM_CFLAGS@,$AM_CFLAGS,;t t
25082 s,@AS@,$AS,;t t
25083 s,@ac_ct_AS@,$ac_ct_AS,;t t
25084 s,@AR@,$AR,;t t
25085 s,@ac_ct_AR@,$ac_ct_AR,;t t
25086 s,@RANLIB@,$RANLIB,;t t
25087 s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
25088 s,@LN_S@,$LN_S,;t t
25089 s,@LIBTOOL@,$LIBTOOL,;t t
25090 s,@enable_shared@,$enable_shared,;t t
25091 s,@enable_static@,$enable_static,;t t
25092 s,@FC@,$FC,;t t
25093 s,@FCFLAGS@,$FCFLAGS,;t t
25094 s,@LDFLAGS@,$LDFLAGS,;t t
25095 s,@ac_ct_FC@,$ac_ct_FC,;t t
25096 s,@extra_ldflags_libgfortran@,$extra_ldflags_libgfortran,;t t
25097 s,@CPP@,$CPP,;t t
25098 s,@CPPFLAGS@,$CPPFLAGS,;t t
25099 s,@EGREP@,$EGREP,;t t
25100 s,@FPU_HOST_HEADER@,$FPU_HOST_HEADER,;t t
25101 s,@LIBOBJS@,$LIBOBJS,;t t
25102 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
25103 CEOF
25104
25105 _ACEOF
25106
25107   cat >>$CONFIG_STATUS <<\_ACEOF
25108   # Split the substitutions into bite-sized pieces for seds with
25109   # small command number limits, like on Digital OSF/1 and HP-UX.
25110   ac_max_sed_lines=48
25111   ac_sed_frag=1 # Number of current file.
25112   ac_beg=1 # First line for current file.
25113   ac_end=$ac_max_sed_lines # Line after last line for current file.
25114   ac_more_lines=:
25115   ac_sed_cmds=
25116   while $ac_more_lines; do
25117     if test $ac_beg -gt 1; then
25118       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
25119     else
25120       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
25121     fi
25122     if test ! -s $tmp/subs.frag; then
25123       ac_more_lines=false
25124     else
25125       # The purpose of the label and of the branching condition is to
25126       # speed up the sed processing (if there are no `@' at all, there
25127       # is no need to browse any of the substitutions).
25128       # These are the two extra sed commands mentioned above.
25129       (echo ':t
25130   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
25131       if test -z "$ac_sed_cmds"; then
25132         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
25133       else
25134         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
25135       fi
25136       ac_sed_frag=`expr $ac_sed_frag + 1`
25137       ac_beg=$ac_end
25138       ac_end=`expr $ac_end + $ac_max_sed_lines`
25139     fi
25140   done
25141   if test -z "$ac_sed_cmds"; then
25142     ac_sed_cmds=cat
25143   fi
25144 fi # test -n "$CONFIG_FILES"
25145
25146 _ACEOF
25147 cat >>$CONFIG_STATUS <<\_ACEOF
25148 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
25149   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
25150   case $ac_file in
25151   - | *:- | *:-:* ) # input from stdin
25152         cat >$tmp/stdin
25153         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25154         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25155   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25156         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25157   * )   ac_file_in=$ac_file.in ;;
25158   esac
25159
25160   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
25161   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
25162 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25163          X"$ac_file" : 'X\(//\)[^/]' \| \
25164          X"$ac_file" : 'X\(//\)$' \| \
25165          X"$ac_file" : 'X\(/\)' \| \
25166          .     : '\(.\)' 2>/dev/null ||
25167 echo X"$ac_file" |
25168     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25169           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25170           /^X\(\/\/\)$/{ s//\1/; q; }
25171           /^X\(\/\).*/{ s//\1/; q; }
25172           s/.*/./; q'`
25173   { if $as_mkdir_p; then
25174     mkdir -p "$ac_dir"
25175   else
25176     as_dir="$ac_dir"
25177     as_dirs=
25178     while test ! -d "$as_dir"; do
25179       as_dirs="$as_dir $as_dirs"
25180       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25181 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25182          X"$as_dir" : 'X\(//\)[^/]' \| \
25183          X"$as_dir" : 'X\(//\)$' \| \
25184          X"$as_dir" : 'X\(/\)' \| \
25185          .     : '\(.\)' 2>/dev/null ||
25186 echo X"$as_dir" |
25187     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25188           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25189           /^X\(\/\/\)$/{ s//\1/; q; }
25190           /^X\(\/\).*/{ s//\1/; q; }
25191           s/.*/./; q'`
25192     done
25193     test ! -n "$as_dirs" || mkdir $as_dirs
25194   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
25195 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
25196    { (exit 1); exit 1; }; }; }
25197
25198   ac_builddir=.
25199
25200 if test "$ac_dir" != .; then
25201   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
25202   # A "../" for each directory in $ac_dir_suffix.
25203   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
25204 else
25205   ac_dir_suffix= ac_top_builddir=
25206 fi
25207
25208 case $srcdir in
25209   .)  # No --srcdir option.  We are building in place.
25210     ac_srcdir=.
25211     if test -z "$ac_top_builddir"; then
25212        ac_top_srcdir=.
25213     else
25214        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
25215     fi ;;
25216   [\\/]* | ?:[\\/]* )  # Absolute path.
25217     ac_srcdir=$srcdir$ac_dir_suffix;
25218     ac_top_srcdir=$srcdir ;;
25219   *) # Relative path.
25220     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
25221     ac_top_srcdir=$ac_top_builddir$srcdir ;;
25222 esac
25223
25224 # Do not use `cd foo && pwd` to compute absolute paths, because
25225 # the directories may not exist.
25226 case `pwd` in
25227 .) ac_abs_builddir="$ac_dir";;
25228 *)
25229   case "$ac_dir" in
25230   .) ac_abs_builddir=`pwd`;;
25231   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
25232   *) ac_abs_builddir=`pwd`/"$ac_dir";;
25233   esac;;
25234 esac
25235 case $ac_abs_builddir in
25236 .) ac_abs_top_builddir=${ac_top_builddir}.;;
25237 *)
25238   case ${ac_top_builddir}. in
25239   .) ac_abs_top_builddir=$ac_abs_builddir;;
25240   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
25241   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
25242   esac;;
25243 esac
25244 case $ac_abs_builddir in
25245 .) ac_abs_srcdir=$ac_srcdir;;
25246 *)
25247   case $ac_srcdir in
25248   .) ac_abs_srcdir=$ac_abs_builddir;;
25249   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
25250   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
25251   esac;;
25252 esac
25253 case $ac_abs_builddir in
25254 .) ac_abs_top_srcdir=$ac_top_srcdir;;
25255 *)
25256   case $ac_top_srcdir in
25257   .) ac_abs_top_srcdir=$ac_abs_builddir;;
25258   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
25259   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
25260   esac;;
25261 esac
25262
25263
25264   case $INSTALL in
25265   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
25266   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
25267   esac
25268
25269   if test x"$ac_file" != x-; then
25270     { echo "$as_me:$LINENO: creating $ac_file" >&5
25271 echo "$as_me: creating $ac_file" >&6;}
25272     rm -f "$ac_file"
25273   fi
25274   # Let's still pretend it is `configure' which instantiates (i.e., don't
25275   # use $as_me), people would be surprised to read:
25276   #    /* config.h.  Generated by config.status.  */
25277   if test x"$ac_file" = x-; then
25278     configure_input=
25279   else
25280     configure_input="$ac_file.  "
25281   fi
25282   configure_input=$configure_input"Generated from `echo $ac_file_in |
25283                                      sed 's,.*/,,'` by configure."
25284
25285   # First look for the input files in the build tree, otherwise in the
25286   # src tree.
25287   ac_file_inputs=`IFS=:
25288     for f in $ac_file_in; do
25289       case $f in
25290       -) echo $tmp/stdin ;;
25291       [\\/$]*)
25292          # Absolute (can't be DOS-style, as IFS=:)
25293          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25294 echo "$as_me: error: cannot find input file: $f" >&2;}
25295    { (exit 1); exit 1; }; }
25296          echo "$f";;
25297       *) # Relative
25298          if test -f "$f"; then
25299            # Build tree
25300            echo "$f"
25301          elif test -f "$srcdir/$f"; then
25302            # Source tree
25303            echo "$srcdir/$f"
25304          else
25305            # /dev/null tree
25306            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25307 echo "$as_me: error: cannot find input file: $f" >&2;}
25308    { (exit 1); exit 1; }; }
25309          fi;;
25310       esac
25311     done` || { (exit 1); exit 1; }
25312 _ACEOF
25313 cat >>$CONFIG_STATUS <<_ACEOF
25314   sed "$ac_vpsub
25315 $extrasub
25316 _ACEOF
25317 cat >>$CONFIG_STATUS <<\_ACEOF
25318 :t
25319 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
25320 s,@configure_input@,$configure_input,;t t
25321 s,@srcdir@,$ac_srcdir,;t t
25322 s,@abs_srcdir@,$ac_abs_srcdir,;t t
25323 s,@top_srcdir@,$ac_top_srcdir,;t t
25324 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
25325 s,@builddir@,$ac_builddir,;t t
25326 s,@abs_builddir@,$ac_abs_builddir,;t t
25327 s,@top_builddir@,$ac_top_builddir,;t t
25328 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
25329 s,@INSTALL@,$ac_INSTALL,;t t
25330 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
25331   rm -f $tmp/stdin
25332   if test x"$ac_file" != x-; then
25333     mv $tmp/out $ac_file
25334   else
25335     cat $tmp/out
25336     rm -f $tmp/out
25337   fi
25338
25339 done
25340 _ACEOF
25341 cat >>$CONFIG_STATUS <<\_ACEOF
25342
25343 #
25344 # CONFIG_HEADER section.
25345 #
25346
25347 # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
25348 # NAME is the cpp macro being defined and VALUE is the value it is being given.
25349 #
25350 # ac_d sets the value in "#define NAME VALUE" lines.
25351 ac_dA='s,^\([    ]*\)#\([        ]*define[       ][      ]*\)'
25352 ac_dB='[         ].*$,\1#\2'
25353 ac_dC=' '
25354 ac_dD=',;t'
25355 # ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
25356 ac_uA='s,^\([    ]*\)#\([        ]*\)undef\([    ][      ]*\)'
25357 ac_uB='$,\1#\2define\3'
25358 ac_uC=' '
25359 ac_uD=',;t'
25360
25361 for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue
25362   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
25363   case $ac_file in
25364   - | *:- | *:-:* ) # input from stdin
25365         cat >$tmp/stdin
25366         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25367         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25368   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
25369         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
25370   * )   ac_file_in=$ac_file.in ;;
25371   esac
25372
25373   test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5
25374 echo "$as_me: creating $ac_file" >&6;}
25375
25376   # First look for the input files in the build tree, otherwise in the
25377   # src tree.
25378   ac_file_inputs=`IFS=:
25379     for f in $ac_file_in; do
25380       case $f in
25381       -) echo $tmp/stdin ;;
25382       [\\/$]*)
25383          # Absolute (can't be DOS-style, as IFS=:)
25384          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25385 echo "$as_me: error: cannot find input file: $f" >&2;}
25386    { (exit 1); exit 1; }; }
25387          # Do quote $f, to prevent DOS paths from being IFS'd.
25388          echo "$f";;
25389       *) # Relative
25390          if test -f "$f"; then
25391            # Build tree
25392            echo "$f"
25393          elif test -f "$srcdir/$f"; then
25394            # Source tree
25395            echo "$srcdir/$f"
25396          else
25397            # /dev/null tree
25398            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
25399 echo "$as_me: error: cannot find input file: $f" >&2;}
25400    { (exit 1); exit 1; }; }
25401          fi;;
25402       esac
25403     done` || { (exit 1); exit 1; }
25404   # Remove the trailing spaces.
25405   sed 's/[       ]*$//' $ac_file_inputs >$tmp/in
25406
25407 _ACEOF
25408
25409 # Transform confdefs.h into two sed scripts, `conftest.defines' and
25410 # `conftest.undefs', that substitutes the proper values into
25411 # config.h.in to produce config.h.  The first handles `#define'
25412 # templates, and the second `#undef' templates.
25413 # And first: Protect against being on the right side of a sed subst in
25414 # config.status.  Protect against being in an unquoted here document
25415 # in config.status.
25416 rm -f conftest.defines conftest.undefs
25417 # Using a here document instead of a string reduces the quoting nightmare.
25418 # Putting comments in sed scripts is not portable.
25419 #
25420 # `end' is used to avoid that the second main sed command (meant for
25421 # 0-ary CPP macros) applies to n-ary macro definitions.
25422 # See the Autoconf documentation for `clear'.
25423 cat >confdef2sed.sed <<\_ACEOF
25424 s/[\\&,]/\\&/g
25425 s,[\\$`],\\&,g
25426 t clear
25427 : clear
25428 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
25429 t end
25430 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
25431 : end
25432 _ACEOF
25433 # If some macros were called several times there might be several times
25434 # the same #defines, which is useless.  Nevertheless, we may not want to
25435 # sort them, since we want the *last* AC-DEFINE to be honored.
25436 uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines
25437 sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs
25438 rm -f confdef2sed.sed
25439
25440 # This sed command replaces #undef with comments.  This is necessary, for
25441 # example, in the case of _POSIX_SOURCE, which is predefined and required
25442 # on some systems where configure will not decide to define it.
25443 cat >>conftest.undefs <<\_ACEOF
25444 s,^[     ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
25445 _ACEOF
25446
25447 # Break up conftest.defines because some shells have a limit on the size
25448 # of here documents, and old seds have small limits too (100 cmds).
25449 echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
25450 echo '  if grep "^[      ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
25451 echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
25452 echo '  :' >>$CONFIG_STATUS
25453 rm -f conftest.tail
25454 while grep . conftest.defines >/dev/null
25455 do
25456   # Write a limited-size here document to $tmp/defines.sed.
25457   echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
25458   # Speed up: don't consider the non `#define' lines.
25459   echo '/^[      ]*#[    ]*define/!b' >>$CONFIG_STATUS
25460   # Work around the forget-to-reset-the-flag bug.
25461   echo 't clr' >>$CONFIG_STATUS
25462   echo ': clr' >>$CONFIG_STATUS
25463   sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS
25464   echo 'CEOF
25465   sed -f $tmp/defines.sed $tmp/in >$tmp/out
25466   rm -f $tmp/in
25467   mv $tmp/out $tmp/in
25468 ' >>$CONFIG_STATUS
25469   sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail
25470   rm -f conftest.defines
25471   mv conftest.tail conftest.defines
25472 done
25473 rm -f conftest.defines
25474 echo '  fi # grep' >>$CONFIG_STATUS
25475 echo >>$CONFIG_STATUS
25476
25477 # Break up conftest.undefs because some shells have a limit on the size
25478 # of here documents, and old seds have small limits too (100 cmds).
25479 echo '  # Handle all the #undef templates' >>$CONFIG_STATUS
25480 rm -f conftest.tail
25481 while grep . conftest.undefs >/dev/null
25482 do
25483   # Write a limited-size here document to $tmp/undefs.sed.
25484   echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
25485   # Speed up: don't consider the non `#undef'
25486   echo '/^[      ]*#[    ]*undef/!b' >>$CONFIG_STATUS
25487   # Work around the forget-to-reset-the-flag bug.
25488   echo 't clr' >>$CONFIG_STATUS
25489   echo ': clr' >>$CONFIG_STATUS
25490   sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS
25491   echo 'CEOF
25492   sed -f $tmp/undefs.sed $tmp/in >$tmp/out
25493   rm -f $tmp/in
25494   mv $tmp/out $tmp/in
25495 ' >>$CONFIG_STATUS
25496   sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail
25497   rm -f conftest.undefs
25498   mv conftest.tail conftest.undefs
25499 done
25500 rm -f conftest.undefs
25501
25502 cat >>$CONFIG_STATUS <<\_ACEOF
25503   # Let's still pretend it is `configure' which instantiates (i.e., don't
25504   # use $as_me), people would be surprised to read:
25505   #    /* config.h.  Generated by config.status.  */
25506   if test x"$ac_file" = x-; then
25507     echo "/* Generated by configure.  */" >$tmp/config.h
25508   else
25509     echo "/* $ac_file.  Generated by configure.  */" >$tmp/config.h
25510   fi
25511   cat $tmp/in >>$tmp/config.h
25512   rm -f $tmp/in
25513   if test x"$ac_file" != x-; then
25514     if diff $ac_file $tmp/config.h >/dev/null 2>&1; then
25515       { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
25516 echo "$as_me: $ac_file is unchanged" >&6;}
25517     else
25518       ac_dir=`(dirname "$ac_file") 2>/dev/null ||
25519 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25520          X"$ac_file" : 'X\(//\)[^/]' \| \
25521          X"$ac_file" : 'X\(//\)$' \| \
25522          X"$ac_file" : 'X\(/\)' \| \
25523          .     : '\(.\)' 2>/dev/null ||
25524 echo X"$ac_file" |
25525     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25526           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25527           /^X\(\/\/\)$/{ s//\1/; q; }
25528           /^X\(\/\).*/{ s//\1/; q; }
25529           s/.*/./; q'`
25530       { if $as_mkdir_p; then
25531     mkdir -p "$ac_dir"
25532   else
25533     as_dir="$ac_dir"
25534     as_dirs=
25535     while test ! -d "$as_dir"; do
25536       as_dirs="$as_dir $as_dirs"
25537       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25538 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25539          X"$as_dir" : 'X\(//\)[^/]' \| \
25540          X"$as_dir" : 'X\(//\)$' \| \
25541          X"$as_dir" : 'X\(/\)' \| \
25542          .     : '\(.\)' 2>/dev/null ||
25543 echo X"$as_dir" |
25544     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25545           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25546           /^X\(\/\/\)$/{ s//\1/; q; }
25547           /^X\(\/\).*/{ s//\1/; q; }
25548           s/.*/./; q'`
25549     done
25550     test ! -n "$as_dirs" || mkdir $as_dirs
25551   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
25552 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
25553    { (exit 1); exit 1; }; }; }
25554
25555       rm -f $ac_file
25556       mv $tmp/config.h $ac_file
25557     fi
25558   else
25559     cat $tmp/config.h
25560     rm -f $tmp/config.h
25561   fi
25562 # Compute $ac_file's index in $config_headers.
25563 _am_stamp_count=1
25564 for _am_header in $config_headers :; do
25565   case $_am_header in
25566     $ac_file | $ac_file:* )
25567       break ;;
25568     * )
25569       _am_stamp_count=`expr $_am_stamp_count + 1` ;;
25570   esac
25571 done
25572 echo "timestamp for $ac_file" >`(dirname $ac_file) 2>/dev/null ||
25573 $as_expr X$ac_file : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25574          X$ac_file : 'X\(//\)[^/]' \| \
25575          X$ac_file : 'X\(//\)$' \| \
25576          X$ac_file : 'X\(/\)' \| \
25577          .     : '\(.\)' 2>/dev/null ||
25578 echo X$ac_file |
25579     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25580           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25581           /^X\(\/\/\)$/{ s//\1/; q; }
25582           /^X\(\/\).*/{ s//\1/; q; }
25583           s/.*/./; q'`/stamp-h$_am_stamp_count
25584 done
25585 _ACEOF
25586 cat >>$CONFIG_STATUS <<\_ACEOF
25587
25588 #
25589 # CONFIG_COMMANDS section.
25590 #
25591 for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue
25592   ac_dest=`echo "$ac_file" | sed 's,:.*,,'`
25593   ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`
25594   ac_dir=`(dirname "$ac_dest") 2>/dev/null ||
25595 $as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25596          X"$ac_dest" : 'X\(//\)[^/]' \| \
25597          X"$ac_dest" : 'X\(//\)$' \| \
25598          X"$ac_dest" : 'X\(/\)' \| \
25599          .     : '\(.\)' 2>/dev/null ||
25600 echo X"$ac_dest" |
25601     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25602           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25603           /^X\(\/\/\)$/{ s//\1/; q; }
25604           /^X\(\/\).*/{ s//\1/; q; }
25605           s/.*/./; q'`
25606   { if $as_mkdir_p; then
25607     mkdir -p "$ac_dir"
25608   else
25609     as_dir="$ac_dir"
25610     as_dirs=
25611     while test ! -d "$as_dir"; do
25612       as_dirs="$as_dir $as_dirs"
25613       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25614 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25615          X"$as_dir" : 'X\(//\)[^/]' \| \
25616          X"$as_dir" : 'X\(//\)$' \| \
25617          X"$as_dir" : 'X\(/\)' \| \
25618          .     : '\(.\)' 2>/dev/null ||
25619 echo X"$as_dir" |
25620     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25621           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25622           /^X\(\/\/\)$/{ s//\1/; q; }
25623           /^X\(\/\).*/{ s//\1/; q; }
25624           s/.*/./; q'`
25625     done
25626     test ! -n "$as_dirs" || mkdir $as_dirs
25627   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
25628 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
25629    { (exit 1); exit 1; }; }; }
25630
25631   ac_builddir=.
25632
25633 if test "$ac_dir" != .; then
25634   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
25635   # A "../" for each directory in $ac_dir_suffix.
25636   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
25637 else
25638   ac_dir_suffix= ac_top_builddir=
25639 fi
25640
25641 case $srcdir in
25642   .)  # No --srcdir option.  We are building in place.
25643     ac_srcdir=.
25644     if test -z "$ac_top_builddir"; then
25645        ac_top_srcdir=.
25646     else
25647        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
25648     fi ;;
25649   [\\/]* | ?:[\\/]* )  # Absolute path.
25650     ac_srcdir=$srcdir$ac_dir_suffix;
25651     ac_top_srcdir=$srcdir ;;
25652   *) # Relative path.
25653     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
25654     ac_top_srcdir=$ac_top_builddir$srcdir ;;
25655 esac
25656
25657 # Do not use `cd foo && pwd` to compute absolute paths, because
25658 # the directories may not exist.
25659 case `pwd` in
25660 .) ac_abs_builddir="$ac_dir";;
25661 *)
25662   case "$ac_dir" in
25663   .) ac_abs_builddir=`pwd`;;
25664   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
25665   *) ac_abs_builddir=`pwd`/"$ac_dir";;
25666   esac;;
25667 esac
25668 case $ac_abs_builddir in
25669 .) ac_abs_top_builddir=${ac_top_builddir}.;;
25670 *)
25671   case ${ac_top_builddir}. in
25672   .) ac_abs_top_builddir=$ac_abs_builddir;;
25673   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
25674   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
25675   esac;;
25676 esac
25677 case $ac_abs_builddir in
25678 .) ac_abs_srcdir=$ac_srcdir;;
25679 *)
25680   case $ac_srcdir in
25681   .) ac_abs_srcdir=$ac_abs_builddir;;
25682   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
25683   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
25684   esac;;
25685 esac
25686 case $ac_abs_builddir in
25687 .) ac_abs_top_srcdir=$ac_top_srcdir;;
25688 *)
25689   case $ac_top_srcdir in
25690   .) ac_abs_top_srcdir=$ac_abs_builddir;;
25691   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
25692   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
25693   esac;;
25694 esac
25695
25696
25697   { echo "$as_me:$LINENO: executing $ac_dest commands" >&5
25698 echo "$as_me: executing $ac_dest commands" >&6;}
25699   case $ac_dest in
25700     default-1 )
25701 # Only add multilib support code if we just rebuilt the top-level
25702 # Makefile.
25703 case " $CONFIG_FILES " in
25704  *" Makefile "*)
25705    ac_file=Makefile . ${multi_basedir}/config-ml.in
25706    ;;
25707 esac ;;
25708     depfiles ) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do
25709   # Strip MF so we end up with the name of the file.
25710   mf=`echo "$mf" | sed -e 's/:.*$//'`
25711   # Check whether this is an Automake generated Makefile or not.
25712   # We used to match only the files named `Makefile.in', but
25713   # some people rename them; so instead we look at the file content.
25714   # Grep'ing the first line is not enough: some people post-process
25715   # each Makefile.in and add a new line on top of each file to say so.
25716   # So let's grep whole file.
25717   if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then
25718     dirpart=`(dirname "$mf") 2>/dev/null ||
25719 $as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25720          X"$mf" : 'X\(//\)[^/]' \| \
25721          X"$mf" : 'X\(//\)$' \| \
25722          X"$mf" : 'X\(/\)' \| \
25723          .     : '\(.\)' 2>/dev/null ||
25724 echo X"$mf" |
25725     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25726           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25727           /^X\(\/\/\)$/{ s//\1/; q; }
25728           /^X\(\/\).*/{ s//\1/; q; }
25729           s/.*/./; q'`
25730   else
25731     continue
25732   fi
25733   # Extract the definition of DEPDIR, am__include, and am__quote
25734   # from the Makefile without running `make'.
25735   DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
25736   test -z "$DEPDIR" && continue
25737   am__include=`sed -n 's/^am__include = //p' < "$mf"`
25738   test -z "am__include" && continue
25739   am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
25740   # When using ansi2knr, U may be empty or an underscore; expand it
25741   U=`sed -n 's/^U = //p' < "$mf"`
25742   # Find all dependency output files, they are included files with
25743   # $(DEPDIR) in their names.  We invoke sed twice because it is the
25744   # simplest approach to changing $(DEPDIR) to its actual value in the
25745   # expansion.
25746   for file in `sed -n "
25747     s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
25748        sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
25749     # Make sure the directory exists.
25750     test -f "$dirpart/$file" && continue
25751     fdir=`(dirname "$file") 2>/dev/null ||
25752 $as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25753          X"$file" : 'X\(//\)[^/]' \| \
25754          X"$file" : 'X\(//\)$' \| \
25755          X"$file" : 'X\(/\)' \| \
25756          .     : '\(.\)' 2>/dev/null ||
25757 echo X"$file" |
25758     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25759           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25760           /^X\(\/\/\)$/{ s//\1/; q; }
25761           /^X\(\/\).*/{ s//\1/; q; }
25762           s/.*/./; q'`
25763     { if $as_mkdir_p; then
25764     mkdir -p $dirpart/$fdir
25765   else
25766     as_dir=$dirpart/$fdir
25767     as_dirs=
25768     while test ! -d "$as_dir"; do
25769       as_dirs="$as_dir $as_dirs"
25770       as_dir=`(dirname "$as_dir") 2>/dev/null ||
25771 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25772          X"$as_dir" : 'X\(//\)[^/]' \| \
25773          X"$as_dir" : 'X\(//\)$' \| \
25774          X"$as_dir" : 'X\(/\)' \| \
25775          .     : '\(.\)' 2>/dev/null ||
25776 echo X"$as_dir" |
25777     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25778           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25779           /^X\(\/\/\)$/{ s//\1/; q; }
25780           /^X\(\/\).*/{ s//\1/; q; }
25781           s/.*/./; q'`
25782     done
25783     test ! -n "$as_dirs" || mkdir $as_dirs
25784   fi || { { echo "$as_me:$LINENO: error: cannot create directory $dirpart/$fdir" >&5
25785 echo "$as_me: error: cannot create directory $dirpart/$fdir" >&2;}
25786    { (exit 1); exit 1; }; }; }
25787
25788     # echo "creating $dirpart/$file"
25789     echo '# dummy' > "$dirpart/$file"
25790   done
25791 done
25792  ;;
25793     gstdint.h )
25794 if test "$GCC" = yes; then
25795   echo "/* generated for " `$CC --version | sed 1q` "*/" > tmp-stdint.h
25796 else
25797   echo "/* generated for $CC */" > tmp-stdint.h
25798 fi
25799
25800 sed 's/^ *//' >> tmp-stdint.h <<EOF
25801
25802   #ifndef GCC_GENERATED_STDINT_H
25803   #define GCC_GENERATED_STDINT_H 1
25804
25805   #include <sys/types.h>
25806 EOF
25807
25808 if test "$acx_cv_header_stdint" != stdint.h; then
25809   echo "#include <stddef.h>" >> tmp-stdint.h
25810 fi
25811 if test "$acx_cv_header_stdint" != stddef.h; then
25812   echo "#include <$acx_cv_header_stdint>" >> tmp-stdint.h
25813 fi
25814
25815 sed 's/^ *//' >> tmp-stdint.h <<EOF
25816   /* glibc uses these symbols as guards to prevent redefinitions.  */
25817   #ifdef __int8_t_defined
25818   #define _INT8_T
25819   #define _INT16_T
25820   #define _INT32_T
25821   #endif
25822   #ifdef __uint32_t_defined
25823   #define _UINT32_T
25824   #endif
25825
25826 EOF
25827
25828 # ----------------- done header, emit basic int types -------------
25829 if test "$acx_cv_header_stdint" = stddef.h; then
25830   sed 's/^ *//' >> tmp-stdint.h <<EOF
25831
25832     #ifndef _UINT8_T
25833     #define _UINT8_T
25834     typedef unsigned $acx_cv_type_int8_t uint8_t;
25835     #endif
25836
25837     #ifndef _UINT16_T
25838     #define _UINT16_T
25839     typedef unsigned $acx_cv_type_int16_t uint16_t;
25840     #endif
25841
25842     #ifndef _UINT32_T
25843     #define _UINT32_T
25844     typedef unsigned $acx_cv_type_int32_t uint32_t;
25845     #endif
25846
25847     #ifndef _INT8_T
25848     #define _INT8_T
25849     typedef $acx_cv_type_int8_t int8_t;
25850     #endif
25851
25852     #ifndef _INT16_T
25853     #define _INT16_T
25854     typedef $acx_cv_type_int16_t int16_t;
25855     #endif
25856
25857     #ifndef _INT32_T
25858     #define _INT32_T
25859     typedef $acx_cv_type_int32_t int32_t;
25860     #endif
25861 EOF
25862 elif test "$ac_cv_type_u_int32_t" = yes; then
25863   sed 's/^ *//' >> tmp-stdint.h <<EOF
25864
25865     /* int8_t int16_t int32_t defined by inet code, we do the u_intXX types */
25866     #ifndef _INT8_T
25867     #define _INT8_T
25868     #endif
25869     #ifndef _INT16_T
25870     #define _INT16_T
25871     #endif
25872     #ifndef _INT32_T
25873     #define _INT32_T
25874     #endif
25875
25876     #ifndef _UINT8_T
25877     #define _UINT8_T
25878     typedef u_int8_t uint8_t;
25879     #endif
25880
25881     #ifndef _UINT16_T
25882     #define _UINT16_T
25883     typedef u_int16_t uint16_t;
25884     #endif
25885
25886     #ifndef _UINT32_T
25887     #define _UINT32_T
25888     typedef u_int32_t uint32_t;
25889     #endif
25890 EOF
25891 else
25892   sed 's/^ *//' >> tmp-stdint.h <<EOF
25893
25894     /* Some systems have guard macros to prevent redefinitions, define them.  */
25895     #ifndef _INT8_T
25896     #define _INT8_T
25897     #endif
25898     #ifndef _INT16_T
25899     #define _INT16_T
25900     #endif
25901     #ifndef _INT32_T
25902     #define _INT32_T
25903     #endif
25904     #ifndef _UINT8_T
25905     #define _UINT8_T
25906     #endif
25907     #ifndef _UINT16_T
25908     #define _UINT16_T
25909     #endif
25910     #ifndef _UINT32_T
25911     #define _UINT32_T
25912     #endif
25913 EOF
25914 fi
25915
25916 # ------------- done basic int types, emit int64_t types ------------
25917 if test "$ac_cv_type_uint64_t" = yes; then
25918   sed 's/^ *//' >> tmp-stdint.h <<EOF
25919
25920     /* system headers have good uint64_t and int64_t */
25921     #ifndef _INT64_T
25922     #define _INT64_T
25923     #endif
25924     #ifndef _UINT64_T
25925     #define _UINT64_T
25926     #endif
25927 EOF
25928 elif test "$ac_cv_type_u_int64_t" = yes; then
25929   sed 's/^ *//' >> tmp-stdint.h <<EOF
25930
25931     /* system headers have an u_int64_t (and int64_t) */
25932     #ifndef _INT64_T
25933     #define _INT64_T
25934     #endif
25935     #ifndef _UINT64_T
25936     #define _UINT64_T
25937     typedef u_int64_t uint64_t;
25938     #endif
25939 EOF
25940 elif test -n "$acx_cv_type_int64_t"; then
25941   sed 's/^ *//' >> tmp-stdint.h <<EOF
25942
25943     /* architecture has a 64-bit type, $acx_cv_type_int64_t */
25944     #ifndef _INT64_T
25945     #define _INT64_T
25946     typedef $acx_cv_type_int64_t int64_t;
25947     #endif
25948     #ifndef _UINT64_T
25949     #define _UINT64_T
25950     typedef unsigned $acx_cv_type_int64_t uint64_t;
25951     #endif
25952 EOF
25953 else
25954   sed 's/^ *//' >> tmp-stdint.h <<EOF
25955
25956     /* some common heuristics for int64_t, using compiler-specific tests */
25957     #if defined __STDC_VERSION__ && (__STDC_VERSION__-0) >= 199901L
25958     #ifndef _INT64_T
25959     #define _INT64_T
25960     typedef long long int64_t;
25961     #endif
25962     #ifndef _UINT64_T
25963     #define _UINT64_T
25964     typedef unsigned long long uint64_t;
25965     #endif
25966
25967     #elif defined __GNUC__ && defined (__STDC__) && __STDC__-0
25968     /* NextStep 2.0 cc is really gcc 1.93 but it defines __GNUC__ = 2 and
25969        does not implement __extension__.  But that compiler doesn't define
25970        __GNUC_MINOR__.  */
25971     # if __GNUC__ < 2 || (__NeXT__ && !__GNUC_MINOR__)
25972     # define __extension__
25973     # endif
25974
25975     # ifndef _INT64_T
25976     # define _INT64_T
25977     __extension__ typedef long long int64_t;
25978     # endif
25979     # ifndef _UINT64_T
25980     # define _UINT64_T
25981     __extension__ typedef unsigned long long uint64_t;
25982     # endif
25983
25984     #elif !defined __STRICT_ANSI__
25985     # if defined _MSC_VER || defined __WATCOMC__ || defined __BORLANDC__
25986
25987     #  ifndef _INT64_T
25988     #  define _INT64_T
25989     typedef __int64 int64_t;
25990     #  endif
25991     #  ifndef _UINT64_T
25992     #  define _UINT64_T
25993     typedef unsigned __int64 uint64_t;
25994     #  endif
25995     # endif /* compiler */
25996
25997     #endif /* ANSI version */
25998 EOF
25999 fi
26000
26001 # ------------- done int64_t types, emit intptr types ------------
26002 if test "$ac_cv_type_uintptr_t" != yes; then
26003   sed 's/^ *//' >> tmp-stdint.h <<EOF
26004
26005     /* Define intptr_t based on sizeof(void*) = $ac_cv_sizeof_void_p */
26006     typedef u$acx_cv_type_intptr_t uintptr_t;
26007     typedef $acx_cv_type_intptr_t  intptr_t;
26008 EOF
26009 fi
26010
26011 # ------------- done intptr types, emit int_least types ------------
26012 if test "$ac_cv_type_int_least32_t" != yes; then
26013   sed 's/^ *//' >> tmp-stdint.h <<EOF
26014
26015     /* Define int_least types */
26016     typedef int8_t     int_least8_t;
26017     typedef int16_t    int_least16_t;
26018     typedef int32_t    int_least32_t;
26019     #ifdef _INT64_T
26020     typedef int64_t    int_least64_t;
26021     #endif
26022
26023     typedef uint8_t    uint_least8_t;
26024     typedef uint16_t   uint_least16_t;
26025     typedef uint32_t   uint_least32_t;
26026     #ifdef _UINT64_T
26027     typedef uint64_t   uint_least64_t;
26028     #endif
26029 EOF
26030 fi
26031
26032 # ------------- done intptr types, emit int_fast types ------------
26033 if test "$ac_cv_type_int_fast32_t" != yes; then
26034       sed 's/^ *//' >> tmp-stdint.h <<EOF
26035
26036     /* Define int_fast types.  short is often slow */
26037     typedef int8_t       int_fast8_t;
26038     typedef int          int_fast16_t;
26039     typedef int32_t      int_fast32_t;
26040     #ifdef _INT64_T
26041     typedef int64_t      int_fast64_t;
26042     #endif
26043
26044     typedef uint8_t      uint_fast8_t;
26045     typedef unsigned int uint_fast16_t;
26046     typedef uint32_t     uint_fast32_t;
26047     #ifdef _UINT64_T
26048     typedef uint64_t     uint_fast64_t;
26049     #endif
26050 EOF
26051 fi
26052
26053 if test "$ac_cv_type_uintmax_t" != yes; then
26054   sed 's/^ *//' >> tmp-stdint.h <<EOF
26055
26056     /* Define intmax based on what we found */
26057     #ifdef _INT64_T
26058     typedef int64_t       intmax_t;
26059     #else
26060     typedef long          intmax_t;
26061     #endif
26062     #ifdef _UINT64_T
26063     typedef uint64_t      uintmax_t;
26064     #else
26065     typedef unsigned long uintmax_t;
26066     #endif
26067 EOF
26068 fi
26069
26070 sed 's/^ *//' >> tmp-stdint.h <<EOF
26071
26072   #endif /* GCC_GENERATED_STDINT_H */
26073 EOF
26074
26075 if test -r gstdint.h && cmp -s tmp-stdint.h gstdint.h; then
26076   rm -f tmp-stdint.h
26077 else
26078   mv -f tmp-stdint.h gstdint.h
26079 fi
26080
26081  ;;
26082   esac
26083 done
26084 _ACEOF
26085
26086 cat >>$CONFIG_STATUS <<\_ACEOF
26087
26088 { (exit 0); exit 0; }
26089 _ACEOF
26090 chmod +x $CONFIG_STATUS
26091 ac_clean_files=$ac_clean_files_save
26092
26093
26094 # configure is writing to config.log, and then calls config.status.
26095 # config.status does its own redirection, appending to config.log.
26096 # Unfortunately, on DOS this fails, as config.log is still kept open
26097 # by configure, so config.status won't be able to write to it; its
26098 # output is simply discarded.  So we exec the FD to /dev/null,
26099 # effectively closing config.log, so it can be properly (re)opened and
26100 # appended to by config.status.  When coming back to configure, we
26101 # need to make the FD available again.
26102 if test "$no_create" != yes; then
26103   ac_cs_success=:
26104   ac_config_status_args=
26105   test "$silent" = yes &&
26106     ac_config_status_args="$ac_config_status_args --quiet"
26107   exec 5>/dev/null
26108   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
26109   exec 5>>config.log
26110   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
26111   # would make configure fail if this is the last instruction.
26112   $ac_cs_success || { (exit 1); exit 1; }
26113 fi
26114