libstdc++-v3/configure

   1 #! /bin/sh
   2
   3 # Guess values for system-dependent variables and create Makefiles.
   4 # Generated automatically using autoconf version 2.13
   5 # Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
   6 #
   7 # This configure script is free software; the Free Software Foundation
   8 # gives unlimited permission to copy, distribute and modify it.
   9
  10 # Defaults:
  11 ac_help=
  12 ac_default_prefix=/usr/local
  13 # Any additions from configure.in:
  14 ac_help="$ac_help
  15   --with-target-subdir=SUBDIR
  16                            configuring in a subdirectory"
  17 ac_help="$ac_help
  18   --with-cross-host=HOST  configuring with a cross compiler"
  19 ac_help="$ac_help
  20   --enable-multilib       build hella library versions (default)"
  21 ac_help="$ac_help
  22   --enable-maintainer-mode enable make rules and dependencies not useful
  23                           (and sometimes confusing) to the casual installer"
  24 ac_help="$ac_help
  25   --enable-shared[=PKGS]  build shared libraries [default=yes]"
  26 ac_help="$ac_help
  27   --enable-static[=PKGS]  build static libraries [default=yes]"
  28 ac_help="$ac_help
  29   --enable-fast-install[=PKGS]  optimize for fast installation [default=yes]"
  30 ac_help="$ac_help
  31   --with-gnu-ld           assume the C compiler uses GNU ld [default=no]"
  32 ac_help="$ac_help
  33   --disable-libtool-lock  avoid locking (might break parallel builds)"
  34 ac_help="$ac_help
  35   --enable-debug          extra debugging, turn off optimization [default=no]"
  36 ac_help="$ac_help
  37   --enable-cstdio         enable GNU libio for target io package. (default)
  38   --enable-cstdio=LIB     use LIB target-speific io package."
  39 ac_help="$ac_help
  40   --enable-long-long      turns on 'long long' [default=yes]"
  41 ac_help="$ac_help
  42   --enable-cshadow-headers construct "shadowed" C header files for
  43                            g++ [default=no]"
  44 ac_help="$ac_help
  45   --enable-threads        enable thread usage for target GCC.
  46   --enable-threads=LIB    use LIB thread package for target GCC."
  47 ac_help="$ac_help
  48   --enable-cxx-flags=FLAGS      pass compiler FLAGS when building library;
  49                                 [default=none]"
  50
  51 # Initialize some variables set by options.
  52 # The variables have the same names as the options, with
  53 # dashes changed to underlines.
  54 build=NONE
  55 cache_file=./config.cache
  56 exec_prefix=NONE
  57 host=NONE
  58 no_create=
  59 nonopt=NONE
  60 no_recursion=
  61 prefix=NONE
  62 program_prefix=NONE
  63 program_suffix=NONE
  64 program_transform_name=s,x,x,
  65 silent=
  66 site=
  67 sitefile=
  68 srcdir=
  69 target=NONE
  70 verbose=
  71 x_includes=NONE
  72 x_libraries=NONE
  73 bindir='${exec_prefix}/bin'
  74 sbindir='${exec_prefix}/sbin'
  75 libexecdir='${exec_prefix}/libexec'
  76 datadir='${prefix}/share'
  77 sysconfdir='${prefix}/etc'
  78 sharedstatedir='${prefix}/com'
  79 localstatedir='${prefix}/var'
  80 libdir='${exec_prefix}/lib'
  81 includedir='${prefix}/include'
  82 oldincludedir='/usr/include'
  83 infodir='${prefix}/info'
  84 mandir='${prefix}/man'
  85
  86 # Initialize some other variables.
  87 subdirs=
  88 MFLAGS= MAKEFLAGS=
  89 SHELL=${CONFIG_SHELL-/bin/sh}
  90 # Maximum number of lines to put in a shell here document.
  91 ac_max_here_lines=12
  92
  93 ac_prev=
  94 for ac_option
  95 do
  96
  97   # If the previous option needs an argument, assign it.
  98   if test -n "$ac_prev"; then
  99     eval "$ac_prev=\$ac_option"
 100     ac_prev=
 101     continue
 102   fi
 103
 104   case "$ac_option" in
 105   -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
 106   *) ac_optarg= ;;
 107   esac
 108
 109   # Accept the important Cygnus configure options, so we can diagnose typos.
 110
 111   case "$ac_option" in
 112
 113   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 114     ac_prev=bindir ;;
 115   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 116     bindir="$ac_optarg" ;;
 117
 118   -build | --build | --buil | --bui | --bu)
 119     ac_prev=build ;;
 120   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 121     build="$ac_optarg" ;;
 122
 123   -cache-file | --cache-file | --cache-fil | --cache-fi \
 124   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 125     ac_prev=cache_file ;;
 126   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 127   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 128     cache_file="$ac_optarg" ;;
 129
 130   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 131     ac_prev=datadir ;;
 132   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 133   | --da=*)
 134     datadir="$ac_optarg" ;;
 135
 136   -disable-* | --disable-*)
 137     ac_feature=`echo $ac_option|sed -e 's/-*disable-//'`
 138     # Reject names that are not valid shell variable names.
 139     if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then
 140       { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
 141     fi
 142     ac_feature=`echo $ac_feature| sed 's/-/_/g'`
 143     eval "enable_${ac_feature}=no" ;;
 144
 145   -enable-* | --enable-*)
 146     ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'`
 147     # Reject names that are not valid shell variable names.
 148     if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then
 149       { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
 150     fi
 151     ac_feature=`echo $ac_feature| sed 's/-/_/g'`
 152     case "$ac_option" in
 153       *=*) ;;
 154       *) ac_optarg=yes ;;
 155     esac
 156     eval "enable_${ac_feature}='$ac_optarg'" ;;
 157
 158   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 159   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 160   | --exec | --exe | --ex)
 161     ac_prev=exec_prefix ;;
 162   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 163   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 164   | --exec=* | --exe=* | --ex=*)
 165     exec_prefix="$ac_optarg" ;;
 166
 167   -gas | --gas | --ga | --g)
 168     # Obsolete; use --with-gas.
 169     with_gas=yes ;;
 170
 171   -help | --help | --hel | --he)
 172     # Omit some internal or obsolete options to make the list less imposing.
 173     # This message is too long to be a string in the A/UX 3.1 sh.
 174     cat << EOF
 175 Usage: configure [options] [host]
 176 Options: [defaults in brackets after descriptions]
 177 Configuration:
 178   --cache-file=FILE       cache test results in FILE
 179   --help                  print this message
 180   --no-create             do not create output files
 181   --quiet, --silent       do not print \`checking...' messages
 182   --site-file=FILE        use FILE as the site file
 183   --version               print the version of autoconf that created configure
 184 Directory and file names:
 185   --prefix=PREFIX         install architecture-independent files in PREFIX
 186                           [$ac_default_prefix]
 187   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 188                           [same as prefix]
 189   --bindir=DIR            user executables in DIR [EPREFIX/bin]
 190   --sbindir=DIR           system admin executables in DIR [EPREFIX/sbin]
 191   --libexecdir=DIR        program executables in DIR [EPREFIX/libexec]
 192   --datadir=DIR           read-only architecture-independent data in DIR
 193                           [PREFIX/share]
 194   --sysconfdir=DIR        read-only single-machine data in DIR [PREFIX/etc]
 195   --sharedstatedir=DIR    modifiable architecture-independent data in DIR
 196                           [PREFIX/com]
 197   --localstatedir=DIR     modifiable single-machine data in DIR [PREFIX/var]
 198   --libdir=DIR            object code libraries in DIR [EPREFIX/lib]
 199   --includedir=DIR        C header files in DIR [PREFIX/include]
 200   --oldincludedir=DIR     C header files for non-gcc in DIR [/usr/include]
 201   --infodir=DIR           info documentation in DIR [PREFIX/info]
 202   --mandir=DIR            man documentation in DIR [PREFIX/man]
 203   --srcdir=DIR            find the sources in DIR [configure dir or ..]
 204   --program-prefix=PREFIX prepend PREFIX to installed program names
 205   --program-suffix=SUFFIX append SUFFIX to installed program names
 206   --program-transform-name=PROGRAM
 207                           run sed PROGRAM on installed program names
 208 EOF
 209     cat << EOF
 210 Host type:
 211   --build=BUILD           configure for building on BUILD [BUILD=HOST]
 212   --host=HOST             configure for HOST [guessed]
 213   --target=TARGET         configure for TARGET [TARGET=HOST]
 214 Features and packages:
 215   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 216   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 217   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 218   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 219   --x-includes=DIR        X include files are in DIR
 220   --x-libraries=DIR       X library files are in DIR
 221 EOF
 222     if test -n "$ac_help"; then
 223       echo "--enable and --with options recognized:$ac_help"
 224     fi
 225     exit 0 ;;
 226
 227   -host | --host | --hos | --ho)
 228     ac_prev=host ;;
 229   -host=* | --host=* | --hos=* | --ho=*)
 230     host="$ac_optarg" ;;
 231
 232   -includedir | --includedir | --includedi | --included | --include \
 233   | --includ | --inclu | --incl | --inc)
 234     ac_prev=includedir ;;
 235   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 236   | --includ=* | --inclu=* | --incl=* | --inc=*)
 237     includedir="$ac_optarg" ;;
 238
 239   -infodir | --infodir | --infodi | --infod | --info | --inf)
 240     ac_prev=infodir ;;
 241   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 242     infodir="$ac_optarg" ;;
 243
 244   -libdir | --libdir | --libdi | --libd)
 245     ac_prev=libdir ;;
 246   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 247     libdir="$ac_optarg" ;;
 248
 249   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 250   | --libexe | --libex | --libe)
 251     ac_prev=libexecdir ;;
 252   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 253   | --libexe=* | --libex=* | --libe=*)
 254     libexecdir="$ac_optarg" ;;
 255
 256   -localstatedir | --localstatedir | --localstatedi | --localstated \
 257   | --localstate | --localstat | --localsta | --localst \
 258   | --locals | --local | --loca | --loc | --lo)
 259     ac_prev=localstatedir ;;
 260   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 261   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 262   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 263     localstatedir="$ac_optarg" ;;
 264
 265   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 266     ac_prev=mandir ;;
 267   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 268     mandir="$ac_optarg" ;;
 269
 270   -nfp | --nfp | --nf)
 271     # Obsolete; use --without-fp.
 272     with_fp=no ;;
 273
 274   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 275   | --no-cr | --no-c)
 276     no_create=yes ;;
 277
 278   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 279   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 280     no_recursion=yes ;;
 281
 282   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 283   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 284   | --oldin | --oldi | --old | --ol | --o)
 285     ac_prev=oldincludedir ;;
 286   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 287   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 288   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 289     oldincludedir="$ac_optarg" ;;
 290
 291   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 292     ac_prev=prefix ;;
 293   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 294     prefix="$ac_optarg" ;;
 295
 296   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 297   | --program-pre | --program-pr | --program-p)
 298     ac_prev=program_prefix ;;
 299   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 300   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 301     program_prefix="$ac_optarg" ;;
 302
 303   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 304   | --program-suf | --program-su | --program-s)
 305     ac_prev=program_suffix ;;
 306   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 307   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 308     program_suffix="$ac_optarg" ;;
 309
 310   -program-transform-name | --program-transform-name \
 311   | --program-transform-nam | --program-transform-na \
 312   | --program-transform-n | --program-transform- \
 313   | --program-transform | --program-transfor \
 314   | --program-transfo | --program-transf \
 315   | --program-trans | --program-tran \
 316   | --progr-tra | --program-tr | --program-t)
 317     ac_prev=program_transform_name ;;
 318   -program-transform-name=* | --program-transform-name=* \
 319   | --program-transform-nam=* | --program-transform-na=* \
 320   | --program-transform-n=* | --program-transform-=* \
 321   | --program-transform=* | --program-transfor=* \
 322   | --program-transfo=* | --program-transf=* \
 323   | --program-trans=* | --program-tran=* \
 324   | --progr-tra=* | --program-tr=* | --program-t=*)
 325     program_transform_name="$ac_optarg" ;;
 326
 327   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 328   | -silent | --silent | --silen | --sile | --sil)
 329     silent=yes ;;
 330
 331   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 332     ac_prev=sbindir ;;
 333   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 334   | --sbi=* | --sb=*)
 335     sbindir="$ac_optarg" ;;
 336
 337   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 338   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 339   | --sharedst | --shareds | --shared | --share | --shar \
 340   | --sha | --sh)
 341     ac_prev=sharedstatedir ;;
 342   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 343   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 344   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 345   | --sha=* | --sh=*)
 346     sharedstatedir="$ac_optarg" ;;
 347
 348   -site | --site | --sit)
 349     ac_prev=site ;;
 350   -site=* | --site=* | --sit=*)
 351     site="$ac_optarg" ;;
 352
 353   -site-file | --site-file | --site-fil | --site-fi | --site-f)
 354     ac_prev=sitefile ;;
 355   -site-file=* | --site-file=* | --site-fil=* | --site-fi=* | --site-f=*)
 356     sitefile="$ac_optarg" ;;
 357
 358   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 359     ac_prev=srcdir ;;
 360   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 361     srcdir="$ac_optarg" ;;
 362
 363   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 364   | --syscon | --sysco | --sysc | --sys | --sy)
 365     ac_prev=sysconfdir ;;
 366   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 367   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 368     sysconfdir="$ac_optarg" ;;
 369
 370   -target | --target | --targe | --targ | --tar | --ta | --t)
 371     ac_prev=target ;;
 372   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 373     target="$ac_optarg" ;;
 374
 375   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 376     verbose=yes ;;
 377
 378   -version | --version | --versio | --versi | --vers)
 379     echo "configure generated by autoconf version 2.13"
 380     exit 0 ;;
 381
 382   -with-* | --with-*)
 383     ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'`
 384     # Reject names that are not valid shell variable names.
 385     if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then
 386       { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
 387     fi
 388     ac_package=`echo $ac_package| sed 's/-/_/g'`
 389     case "$ac_option" in
 390       *=*) ;;
 391       *) ac_optarg=yes ;;
 392     esac
 393     eval "with_${ac_package}='$ac_optarg'" ;;
 394
 395   -without-* | --without-*)
 396     ac_package=`echo $ac_option|sed -e 's/-*without-//'`
 397     # Reject names that are not valid shell variable names.
 398     if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then
 399       { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
 400     fi
 401     ac_package=`echo $ac_package| sed 's/-/_/g'`
 402     eval "with_${ac_package}=no" ;;
 403
 404   --x)
 405     # Obsolete; use --with-x.
 406     with_x=yes ;;
 407
 408   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 409   | --x-incl | --x-inc | --x-in | --x-i)
 410     ac_prev=x_includes ;;
 411   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 412   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 413     x_includes="$ac_optarg" ;;
 414
 415   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 416   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 417     ac_prev=x_libraries ;;
 418   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 419   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 420     x_libraries="$ac_optarg" ;;
 421
 422   -*) { echo "configure: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; }
 423     ;;
 424
 425   *)
 426     if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then
 427       echo "configure: warning: $ac_option: invalid host type" 1>&2
 428     fi
 429     if test "x$nonopt" != xNONE; then
 430       { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; }
 431     fi
 432     nonopt="$ac_option"
 433     ;;
 434
 435   esac
 436 done
 437
 438 if test -n "$ac_prev"; then
 439   { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; }
 440 fi
 441
 442 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
 443
 444 # File descriptor usage:
 445 # 0 standard input
 446 # 1 file creation
 447 # 2 errors and warnings
 448 # 3 some systems may open it to /dev/tty
 449 # 4 used on the Kubota Titan
 450 # 6 checking for... messages and results
 451 # 5 compiler messages saved in config.log
 452 if test "$silent" = yes; then
 453   exec 6>/dev/null
 454 else
 455   exec 6>&1
 456 fi
 457 exec 5>./config.log
 458
 459 echo "\
 460 This file contains any messages produced by compilers while
 461 running configure, to aid debugging if configure makes a mistake.
 462 " 1>&5
 463
 464 # Strip out --no-create and --no-recursion so they do not pile up.
 465 # Also quote any args containing shell metacharacters.
 466 ac_configure_args=
 467 for ac_arg
 468 do
 469   case "$ac_arg" in
 470   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 471   | --no-cr | --no-c) ;;
 472   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 473   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
 474   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*)
 475   ac_configure_args="$ac_configure_args '$ac_arg'" ;;
 476   *) ac_configure_args="$ac_configure_args $ac_arg" ;;
 477   esac
 478 done
 479
 480 # NLS nuisances.
 481 # Only set these to C if already set.  These must not be set unconditionally
 482 # because not all systems understand e.g. LANG=C (notably SCO).
 483 # Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'!
 484 # Non-C LC_CTYPE values break the ctype check.
 485 if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi
 486 if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
 487 if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi
 488 if test "${LC_CTYPE+set}"    = set; then LC_CTYPE=C;    export LC_CTYPE;    fi
 489
 490 # confdefs.h avoids OS command line length limits that DEFS can exceed.
 491 rm -rf conftest* confdefs.h
 492 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
 493 echo > confdefs.h
 494
 495 # A filename unique to this package, relative to the directory that
 496 # configure is in, which we can look for to find out if srcdir is correct.
 497 ac_unique_file=src/complex.cc
 498
 499 # Find the source files, if location was not specified.
 500 if test -z "$srcdir"; then
 501   ac_srcdir_defaulted=yes
 502   # Try the directory containing this script, then its parent.
 503   ac_prog=$0
 504   ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'`
 505   test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
 506   srcdir=$ac_confdir
 507   if test ! -r $srcdir/$ac_unique_file; then
 508     srcdir=..
 509   fi
 510 else
 511   ac_srcdir_defaulted=no
 512 fi
 513 if test ! -r $srcdir/$ac_unique_file; then
 514   if test "$ac_srcdir_defaulted" = yes; then
 515     { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; }
 516   else
 517     { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; }
 518   fi
 519 fi
 520 srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`
 521
 522 # Prefer explicitly selected file to automatically selected ones.
 523 if test -z "$sitefile"; then
 524   if test -z "$CONFIG_SITE"; then
 525     if test "x$prefix" != xNONE; then
 526       CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
 527     else
 528       CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
 529     fi
 530   fi
 531 else
 532   CONFIG_SITE="$sitefile"
 533 fi
 534 for ac_site_file in $CONFIG_SITE; do
 535   if test -r "$ac_site_file"; then
 536     echo "loading site script $ac_site_file"
 537     . "$ac_site_file"
 538   fi
 539 done
 540
 541 if test -r "$cache_file"; then
 542   echo "loading cache $cache_file"
 543   . $cache_file
 544 else
 545   echo "creating cache $cache_file"
 546   > $cache_file
 547 fi
 548
 549 ac_ext=c
 550 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
 551 ac_cpp='$CPP $CPPFLAGS'
 552 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
 553 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
 554 cross_compiling=$ac_cv_prog_cc_cross
 555
 556 ac_exeext=
 557 ac_objext=o
 558 if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
 559   # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
 560   if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
 561     ac_n= ac_c='
 562 ' ac_t='        '
 563   else
 564     ac_n=-n ac_c= ac_t=
 565   fi
 566 else
 567   ac_n= ac_c='\c' ac_t=
 568 fi
 569
 570
 571 ac_aux_dir=
 572 for ac_dir in .. $srcdir/..; do
 573   if test -f $ac_dir/install-sh; then
 574     ac_aux_dir=$ac_dir
 575     ac_install_sh="$ac_aux_dir/install-sh -c"
 576     break
 577   elif test -f $ac_dir/install.sh; then
 578     ac_aux_dir=$ac_dir
 579     ac_install_sh="$ac_aux_dir/install.sh -c"
 580     break
 581   fi
 582 done
 583 if test -z "$ac_aux_dir"; then
 584   { echo "configure: error: can not find install-sh or install.sh in .. $srcdir/.." 1>&2; exit 1; }
 585 fi
 586 ac_config_guess=$ac_aux_dir/config.guess
 587 ac_config_sub=$ac_aux_dir/config.sub
 588 ac_configure=$ac_aux_dir/configure # This should be Cygnus configure.
 589
 590
 591 # Gets and sets build, host, target, *_vendor, *_cpu, *_os, etc.
 592
 593 # Do some error checking and defaulting for the host and target type.
 594 # The inputs are:
 595 #    configure --host=HOST --target=TARGET --build=BUILD NONOPT
 596 #
 597 # The rules are:
 598 # 1. You are not allowed to specify --host, --target, and nonopt at the
 599 #    same time.
 600 # 2. Host defaults to nonopt.
 601 # 3. If nonopt is not specified, then host defaults to the current host,
 602 #    as determined by config.guess.
 603 # 4. Target and build default to nonopt.
 604 # 5. If nonopt is not specified, then target and build default to host.
 605
 606 # The aliases save the names the user supplied, while $host etc.
 607 # will get canonicalized.
 608 case $host---$target---$nonopt in
 609 NONE---*---* | *---NONE---* | *---*---NONE) ;;
 610 *) { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; } ;;
 611 esac
 612
 613
 614 # Make sure we can run config.sub.
 615 if ${CONFIG_SHELL-/bin/sh} $ac_config_sub sun4 >/dev/null 2>&1; then :
 616 else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
 617 fi
 618
 619 echo $ac_n "checking host system type""... $ac_c" 1>&6
 620 echo "configure:621: checking host system type" >&5
 621
 622 host_alias=$host
 623 case "$host_alias" in
 624 NONE)
 625   case $nonopt in
 626   NONE)
 627     if host_alias=`${CONFIG_SHELL-/bin/sh} $ac_config_guess`; then :
 628     else { echo "configure: error: can not guess host type; you must specify one" 1>&2; exit 1; }
 629     fi ;;
 630   *) host_alias=$nonopt ;;
 631   esac ;;
 632 esac
 633
 634 host=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $host_alias`
 635 host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 636 host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 637 host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 638 echo "$ac_t""$host" 1>&6
 639
 640 echo $ac_n "checking target system type""... $ac_c" 1>&6
 641 echo "configure:642: checking target system type" >&5
 642
 643 target_alias=$target
 644 case "$target_alias" in
 645 NONE)
 646   case $nonopt in
 647   NONE) target_alias=$host_alias ;;
 648   *) target_alias=$nonopt ;;
 649   esac ;;
 650 esac
 651
 652 target=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $target_alias`
 653 target_cpu=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 654 target_vendor=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 655 target_os=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 656 echo "$ac_t""$target" 1>&6
 657
 658 echo $ac_n "checking build system type""... $ac_c" 1>&6
 659 echo "configure:660: checking build system type" >&5
 660
 661 build_alias=$build
 662 case "$build_alias" in
 663 NONE)
 664   case $nonopt in
 665   NONE) build_alias=$host_alias ;;
 666   *) build_alias=$nonopt ;;
 667   esac ;;
 668 esac
 669
 670 build=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $build_alias`
 671 build_cpu=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 672 build_vendor=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 673 build_os=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 674 echo "$ac_t""$build" 1>&6
 675
 676 test "$host_alias" != "$target_alias" &&
 677   test "$program_prefix$program_suffix$program_transform_name" = \
 678     NONENONEs,x,x, &&
 679   program_prefix=${target_alias}-
 680
 681
 682 # We use these options to decide which functions to include.
 683 # Check whether --with-target-subdir or --without-target-subdir was given.
 684 if test "${with_target_subdir+set}" = set; then
 685   withval="$with_target_subdir"
 686   :
 687 fi
 688
 689 # Check whether --with-cross-host or --without-cross-host was given.
 690 if test "${with_cross_host+set}" = set; then
 691   withval="$with_cross_host"
 692   :
 693 fi
 694
 695
 696 # Find a good install program.  We prefer a C program (faster),
 697 # so one script is as good as another.  But avoid the broken or
 698 # incompatible versions:
 699 # SysV /etc/install, /usr/sbin/install
 700 # SunOS /usr/etc/install
 701 # IRIX /sbin/install
 702 # AIX /bin/install
 703 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
 704 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
 705 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 706 # ./install, which can be erroneously created by make from ./install.sh.
 707 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
 708 echo "configure:709: checking for a BSD compatible install" >&5
 709 if test -z "$INSTALL"; then
 710 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
 711   echo $ac_n "(cached) $ac_c" 1>&6
 712 else
 713     IFS="${IFS=         }"; ac_save_IFS="$IFS"; IFS=":"
 714   for ac_dir in $PATH; do
 715     # Account for people who put trailing slashes in PATH elements.
 716     case "$ac_dir/" in
 717     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
 718     *)
 719       # OSF1 and SCO ODT 3.0 have their own names for install.
 720       # Don't use installbsd from OSF since it installs stuff as root
 721       # by default.
 722       for ac_prog in ginstall scoinst install; do
 723         if test -f $ac_dir/$ac_prog; then
 724           if test $ac_prog = install &&
 725             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
 726             # AIX install.  It has an incompatible calling convention.
 727             :
 728           else
 729             ac_cv_path_install="$ac_dir/$ac_prog -c"
 730             break 2
 731           fi
 732         fi
 733       done
 734       ;;
 735     esac
 736   done
 737   IFS="$ac_save_IFS"
 738
 739 fi
 740   if test "${ac_cv_path_install+set}" = set; then
 741     INSTALL="$ac_cv_path_install"
 742   else
 743     # As a last resort, use the slow shell script.  We don't cache a
 744     # path for INSTALL within a source directory, because that will
 745     # break other packages using the cache if that directory is
 746     # removed, or if the path is relative.
 747     INSTALL="$ac_install_sh"
 748   fi
 749 fi
 750 echo "$ac_t""$INSTALL" 1>&6
 751
 752 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
 753 # It thinks the first close brace ends the variable substitution.
 754 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
 755
 756 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
 757
 758 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 759
 760 echo $ac_n "checking whether build environment is sane""... $ac_c" 1>&6
 761 echo "configure:762: checking whether build environment is sane" >&5
 762 # Just in case
 763 sleep 1
 764 echo timestamp > conftestfile
 765 # Do `set' in a subshell so we don't clobber the current shell's
 766 # arguments.  Must try -L first in case configure is actually a
 767 # symlink; some systems play weird games with the mod time of symlinks
 768 # (eg FreeBSD returns the mod time of the symlink's containing
 769 # directory).
 770 if (
 771    set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null`
 772    if test "$*" = "X"; then
 773       # -L didn't work.
 774       set X `ls -t $srcdir/configure conftestfile`
 775    fi
 776    if test "$*" != "X $srcdir/configure conftestfile" \
 777       && test "$*" != "X conftestfile $srcdir/configure"; then
 778
 779       # If neither matched, then we have a broken ls.  This can happen
 780       # if, for instance, CONFIG_SHELL is bash and it inherits a
 781       # broken ls alias from the environment.  This has actually
 782       # happened.  Such a system could not be considered "sane".
 783       { echo "configure: error: ls -t appears to fail.  Make sure there is not a broken
 784 alias in your environment" 1>&2; exit 1; }
 785    fi
 786
 787    test "$2" = conftestfile
 788    )
 789 then
 790    # Ok.
 791    :
 792 else
 793    { echo "configure: error: newly created file is older than distributed files!
 794 Check your system clock" 1>&2; exit 1; }
 795 fi
 796 rm -f conftest*
 797 echo "$ac_t""yes" 1>&6
 798 if test "$program_transform_name" = s,x,x,; then
 799   program_transform_name=
 800 else
 801   # Double any \ or $.  echo might interpret backslashes.
 802   cat <<\EOF_SED > conftestsed
 803 s,\\,\\\\,g; s,\$,$$,g
 804 EOF_SED
 805   program_transform_name="`echo $program_transform_name|sed -f conftestsed`"
 806   rm -f conftestsed
 807 fi
 808 test "$program_prefix" != NONE &&
 809   program_transform_name="s,^,${program_prefix},; $program_transform_name"
 810 # Use a double $ so make ignores it.
 811 test "$program_suffix" != NONE &&
 812   program_transform_name="s,\$\$,${program_suffix},; $program_transform_name"
 813
 814 # sed with no file args requires a program.
 815 test "$program_transform_name" = "" && program_transform_name="s,x,x,"
 816
 817 echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6
 818 echo "configure:819: checking whether ${MAKE-make} sets \${MAKE}" >&5
 819 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y%./+-%__p_%'`
 820 if eval "test \"`echo '$''{'ac_cv_prog_make_${ac_make}_set'+set}'`\" = set"; then
 821   echo $ac_n "(cached) $ac_c" 1>&6
 822 else
 823   cat > conftestmake <<\EOF
 824 all:
 825         @echo 'ac_maketemp="${MAKE}"'
 826 EOF
 827 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
 828 eval `${MAKE-make} -f conftestmake 2>/dev/null | grep temp=`
 829 if test -n "$ac_maketemp"; then
 830   eval ac_cv_prog_make_${ac_make}_set=yes
 831 else
 832   eval ac_cv_prog_make_${ac_make}_set=no
 833 fi
 834 rm -f conftestmake
 835 fi
 836 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
 837   echo "$ac_t""yes" 1>&6
 838   SET_MAKE=
 839 else
 840   echo "$ac_t""no" 1>&6
 841   SET_MAKE="MAKE=${MAKE-make}"
 842 fi
 843
 844 if test $host != $build; then
 845   ac_tool_prefix=${host_alias}-
 846 else
 847   ac_tool_prefix=
 848 fi
 849
 850 echo $ac_n "checking for Cygwin environment""... $ac_c" 1>&6
 851 echo "configure:852: checking for Cygwin environment" >&5
 852 if eval "test \"`echo '$''{'ac_cv_cygwin'+set}'`\" = set"; then
 853   echo $ac_n "(cached) $ac_c" 1>&6
 854 else
 855   cat > conftest.$ac_ext <<EOF
 856 #line 857 "configure"
 857 #include "confdefs.h"
 858
 859 int main() {
 860
 861 #ifndef __CYGWIN__
 862 #define __CYGWIN__ __CYGWIN32__
 863 #endif
 864 return __CYGWIN__;
 865 ; return 0; }
 866 EOF
 867 if { (eval echo configure:868: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
 868   rm -rf conftest*
 869   ac_cv_cygwin=yes
 870 else
 871   echo "configure: failed program was:" >&5
 872   cat conftest.$ac_ext >&5
 873   rm -rf conftest*
 874   ac_cv_cygwin=no
 875 fi
 876 rm -f conftest*
 877 rm -f conftest*
 878 fi
 879
 880 echo "$ac_t""$ac_cv_cygwin" 1>&6
 881 CYGWIN=
 882 test "$ac_cv_cygwin" = yes && CYGWIN=yes
 883 echo $ac_n "checking for mingw32 environment""... $ac_c" 1>&6
 884 echo "configure:885: checking for mingw32 environment" >&5
 885 if eval "test \"`echo '$''{'ac_cv_mingw32'+set}'`\" = set"; then
 886   echo $ac_n "(cached) $ac_c" 1>&6
 887 else
 888   cat > conftest.$ac_ext <<EOF
 889 #line 890 "configure"
 890 #include "confdefs.h"
 891
 892 int main() {
 893 return __MINGW32__;
 894 ; return 0; }
 895 EOF
 896 if { (eval echo configure:897: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
 897   rm -rf conftest*
 898   ac_cv_mingw32=yes
 899 else
 900   echo "configure: failed program was:" >&5
 901   cat conftest.$ac_ext >&5
 902   rm -rf conftest*
 903   ac_cv_mingw32=no
 904 fi
 905 rm -f conftest*
 906 rm -f conftest*
 907 fi
 908
 909 echo "$ac_t""$ac_cv_mingw32" 1>&6
 910 MINGW32=
 911 test "$ac_cv_mingw32" = yes && MINGW32=yes
 912
 913     # Check whether --enable-multilib or --disable-multilib was given.
 914 if test "${enable_multilib+set}" = set; then
 915   enableval="$enable_multilib"
 916   case "${enableval}" in
 917     yes) multilib=yes ;;
 918     no)  multilib=no ;;
 919     *)   { echo "configure: error: bad value ${enableval} for multilib option" 1>&2; exit 1; } ;;
 920    esac
 921 else
 922   multilib=yes
 923 fi
 924
 925       if test "${srcdir}" = "."; then
 926     if test "${with_target_subdir}" != "."; then
 927       glibcpp_basedir="${srcdir}/${with_multisrctop}../."
 928     else
 929       glibcpp_basedir="${srcdir}/${with_multisrctop}."
 930     fi
 931   else
 932     glibcpp_basedir="${srcdir}/."
 933   fi
 934
 935
 936
 937 # Make sure we can run config.sub.
 938 if ${CONFIG_SHELL-/bin/sh} $ac_config_sub sun4 >/dev/null 2>&1; then :
 939 else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
 940 fi
 941
 942 echo $ac_n "checking host system type""... $ac_c" 1>&6
 943 echo "configure:944: checking host system type" >&5
 944
 945 host_alias=$host
 946 case "$host_alias" in
 947 NONE)
 948   case $nonopt in
 949   NONE)
 950     if host_alias=`${CONFIG_SHELL-/bin/sh} $ac_config_guess`; then :
 951     else { echo "configure: error: can not guess host type; you must specify one" 1>&2; exit 1; }
 952     fi ;;
 953   *) host_alias=$nonopt ;;
 954   esac ;;
 955 esac
 956
 957 host=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $host_alias`
 958 host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 959 host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 960 host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 961 echo "$ac_t""$host" 1>&6
 962
 963
 964
 965 PACKAGE=libstdc++
 966
 967 VERSION=2.90.8
 968
 969 if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then
 970   { echo "configure: error: source directory already configured; run "make distclean" there first" 1>&2; exit 1; }
 971 fi
 972 cat >> confdefs.h <<EOF
 973 #define PACKAGE "$PACKAGE"
 974 EOF
 975
 976 cat >> confdefs.h <<EOF
 977 #define VERSION "$VERSION"
 978 EOF
 979
 980
 981
 982 missing_dir=`cd $ac_aux_dir && pwd`
 983 echo $ac_n "checking for working aclocal""... $ac_c" 1>&6
 984 echo "configure:985: checking for working aclocal" >&5
 985 # Run test in a subshell; some versions of sh will print an error if
 986 # an executable is not found, even if stderr is redirected.
 987 # Redirect stdin to placate older versions of autoconf.  Sigh.
 988 if (aclocal --version) < /dev/null > /dev/null 2>&1; then
 989    ACLOCAL=aclocal
 990    echo "$ac_t""found" 1>&6
 991 else
 992    ACLOCAL="$missing_dir/missing aclocal"
 993    echo "$ac_t""missing" 1>&6
 994 fi
 995
 996 echo $ac_n "checking for working autoconf""... $ac_c" 1>&6
 997 echo "configure:998: checking for working autoconf" >&5
 998 # Run test in a subshell; some versions of sh will print an error if
 999 # an executable is not found, even if stderr is redirected.
1000 # Redirect stdin to placate older versions of autoconf.  Sigh.
1001 if (autoconf --version) < /dev/null > /dev/null 2>&1; then
1002    AUTOCONF=autoconf
1003    echo "$ac_t""found" 1>&6
1004 else
1005    AUTOCONF="$missing_dir/missing autoconf"
1006    echo "$ac_t""missing" 1>&6
1007 fi
1008
1009 echo $ac_n "checking for working automake""... $ac_c" 1>&6
1010 echo "configure:1011: checking for working automake" >&5
1011 # Run test in a subshell; some versions of sh will print an error if
1012 # an executable is not found, even if stderr is redirected.
1013 # Redirect stdin to placate older versions of autoconf.  Sigh.
1014 if (automake --version) < /dev/null > /dev/null 2>&1; then
1015    AUTOMAKE=automake
1016    echo "$ac_t""found" 1>&6
1017 else
1018    AUTOMAKE="$missing_dir/missing automake"
1019    echo "$ac_t""missing" 1>&6
1020 fi
1021
1022 echo $ac_n "checking for working autoheader""... $ac_c" 1>&6
1023 echo "configure:1024: checking for working autoheader" >&5
1024 # Run test in a subshell; some versions of sh will print an error if
1025 # an executable is not found, even if stderr is redirected.
1026 # Redirect stdin to placate older versions of autoconf.  Sigh.
1027 if (autoheader --version) < /dev/null > /dev/null 2>&1; then
1028    AUTOHEADER=autoheader
1029    echo "$ac_t""found" 1>&6
1030 else
1031    AUTOHEADER="$missing_dir/missing autoheader"
1032    echo "$ac_t""missing" 1>&6
1033 fi
1034
1035 echo $ac_n "checking for working makeinfo""... $ac_c" 1>&6
1036 echo "configure:1037: checking for working makeinfo" >&5
1037 # Run test in a subshell; some versions of sh will print an error if
1038 # an executable is not found, even if stderr is redirected.
1039 # Redirect stdin to placate older versions of autoconf.  Sigh.
1040 if (makeinfo --version) < /dev/null > /dev/null 2>&1; then
1041    MAKEINFO=makeinfo
1042    echo "$ac_t""found" 1>&6
1043 else
1044    MAKEINFO="$missing_dir/missing makeinfo"
1045    echo "$ac_t""missing" 1>&6
1046 fi
1047
1048
1049
1050 # FIXME: We temporarily define our own version of AC_PROG_CC.  This is
1051 # copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS.  We
1052 # are probably using a cross compiler, which will not be able to fully
1053 # link an executable.  This should really be fixed in autoconf
1054 # itself.
1055
1056
1057
1058
1059 # Extract the first word of "gcc", so it can be a program name with args.
1060 set dummy gcc; ac_word=$2
1061 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1062 echo "configure:1063: checking for $ac_word" >&5
1063 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1064   echo $ac_n "(cached) $ac_c" 1>&6
1065 else
1066   if test -n "$CC"; then
1067   ac_cv_prog_CC="$CC" # Let the user override the test.
1068 else
1069   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1070   ac_dummy="$PATH"
1071   for ac_dir in $ac_dummy; do
1072     test -z "$ac_dir" && ac_dir=.
1073     if test -f $ac_dir/$ac_word; then
1074       ac_cv_prog_CC="gcc"
1075       break
1076     fi
1077   done
1078   IFS="$ac_save_ifs"
1079 fi
1080 fi
1081 CC="$ac_cv_prog_CC"
1082 if test -n "$CC"; then
1083   echo "$ac_t""$CC" 1>&6
1084 else
1085   echo "$ac_t""no" 1>&6
1086 fi
1087
1088 if test -z "$CC"; then
1089   # Extract the first word of "cc", so it can be a program name with args.
1090 set dummy cc; ac_word=$2
1091 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1092 echo "configure:1093: checking for $ac_word" >&5
1093 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1094   echo $ac_n "(cached) $ac_c" 1>&6
1095 else
1096   if test -n "$CC"; then
1097   ac_cv_prog_CC="$CC" # Let the user override the test.
1098 else
1099   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1100   ac_prog_rejected=no
1101   ac_dummy="$PATH"
1102   for ac_dir in $ac_dummy; do
1103     test -z "$ac_dir" && ac_dir=.
1104     if test -f $ac_dir/$ac_word; then
1105       if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
1106         ac_prog_rejected=yes
1107         continue
1108       fi
1109       ac_cv_prog_CC="cc"
1110       break
1111     fi
1112   done
1113   IFS="$ac_save_ifs"
1114 if test $ac_prog_rejected = yes; then
1115   # We found a bogon in the path, so make sure we never use it.
1116   set dummy $ac_cv_prog_CC
1117   shift
1118   if test $# -gt 0; then
1119     # We chose a different compiler from the bogus one.
1120     # However, it has the same basename, so the bogon will be chosen
1121     # first if we set CC to just the basename; use the full file name.
1122     shift
1123     set dummy "$ac_dir/$ac_word" "$@"
1124     shift
1125     ac_cv_prog_CC="$@"
1126   fi
1127 fi
1128 fi
1129 fi
1130 CC="$ac_cv_prog_CC"
1131 if test -n "$CC"; then
1132   echo "$ac_t""$CC" 1>&6
1133 else
1134   echo "$ac_t""no" 1>&6
1135 fi
1136
1137   test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; }
1138 fi
1139
1140 echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
1141 echo "configure:1142: checking whether we are using GNU C" >&5
1142 if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
1143   echo $ac_n "(cached) $ac_c" 1>&6
1144 else
1145   cat > conftest.c <<EOF
1146 #ifdef __GNUC__
1147   yes;
1148 #endif
1149 EOF
1150 if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1151: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
1151   ac_cv_prog_gcc=yes
1152 else
1153   ac_cv_prog_gcc=no
1154 fi
1155 fi
1156
1157 echo "$ac_t""$ac_cv_prog_gcc" 1>&6
1158
1159 if test $ac_cv_prog_gcc = yes; then
1160   GCC=yes
1161   ac_test_CFLAGS="${CFLAGS+set}"
1162   ac_save_CFLAGS="$CFLAGS"
1163   CFLAGS=
1164   echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
1165 echo "configure:1166: checking whether ${CC-cc} accepts -g" >&5
1166 if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
1167   echo $ac_n "(cached) $ac_c" 1>&6
1168 else
1169   echo 'void f(){}' > conftest.c
1170 if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then
1171   ac_cv_prog_cc_g=yes
1172 else
1173   ac_cv_prog_cc_g=no
1174 fi
1175 rm -f conftest*
1176
1177 fi
1178
1179 echo "$ac_t""$ac_cv_prog_cc_g" 1>&6
1180   if test "$ac_test_CFLAGS" = set; then
1181     CFLAGS="$ac_save_CFLAGS"
1182   elif test $ac_cv_prog_cc_g = yes; then
1183     CFLAGS="-g -O2"
1184   else
1185     CFLAGS="-O2"
1186   fi
1187 else
1188   GCC=
1189   test "${CFLAGS+set}" = set || CFLAGS="-g"
1190 fi
1191
1192
1193 # Likewise for AC_PROG_CXX.
1194
1195
1196
1197 for ac_prog in $CCC c++ g++ gcc CC cxx cc++
1198 do
1199 # Extract the first word of "$ac_prog", so it can be a program name with args.
1200 set dummy $ac_prog; ac_word=$2
1201 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1202 echo "configure:1203: checking for $ac_word" >&5
1203 if eval "test \"`echo '$''{'ac_cv_prog_CXX'+set}'`\" = set"; then
1204   echo $ac_n "(cached) $ac_c" 1>&6
1205 else
1206   if test -n "$CXX"; then
1207   ac_cv_prog_CXX="$CXX" # Let the user override the test.
1208 else
1209   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1210   ac_dummy="$PATH"
1211   for ac_dir in $ac_dummy; do
1212     test -z "$ac_dir" && ac_dir=.
1213     if test -f $ac_dir/$ac_word; then
1214       ac_cv_prog_CXX="$ac_prog"
1215       break
1216     fi
1217   done
1218   IFS="$ac_save_ifs"
1219 fi
1220 fi
1221 CXX="$ac_cv_prog_CXX"
1222 if test -n "$CXX"; then
1223   echo "$ac_t""$CXX" 1>&6
1224 else
1225   echo "$ac_t""no" 1>&6
1226 fi
1227
1228 test -n "$CXX" && break
1229 done
1230 test -n "$CXX" || CXX="gcc"
1231
1232 test -z "$CXX" && { echo "configure: error: no acceptable c++ found in \$PATH" 1>&2; exit 1; }
1233
1234 echo $ac_n "checking whether we are using GNU C++""... $ac_c" 1>&6
1235 echo "configure:1236: checking whether we are using GNU C++" >&5
1236 if eval "test \"`echo '$''{'ac_cv_prog_gxx'+set}'`\" = set"; then
1237   echo $ac_n "(cached) $ac_c" 1>&6
1238 else
1239   cat > conftest.C <<EOF
1240 #ifdef __GNUC__
1241   yes;
1242 #endif
1243 EOF
1244 if { ac_try='${CXX-g++} -E conftest.C'; { (eval echo configure:1245: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
1245   ac_cv_prog_gxx=yes
1246 else
1247   ac_cv_prog_gxx=no
1248 fi
1249 fi
1250
1251 echo "$ac_t""$ac_cv_prog_gxx" 1>&6
1252
1253 if test $ac_cv_prog_gxx = yes; then
1254   GXX=yes
1255   ac_test_CXXFLAGS="${CXXFLAGS+set}"
1256   ac_save_CXXFLAGS="$CXXFLAGS"
1257   CXXFLAGS=
1258   echo $ac_n "checking whether ${CXX-g++} accepts -g""... $ac_c" 1>&6
1259 echo "configure:1260: checking whether ${CXX-g++} accepts -g" >&5
1260 if eval "test \"`echo '$''{'ac_cv_prog_cxx_g'+set}'`\" = set"; then
1261   echo $ac_n "(cached) $ac_c" 1>&6
1262 else
1263   echo 'void f(){}' > conftest.cc
1264 if test -z "`${CXX-g++} -g -c conftest.cc 2>&1`"; then
1265   ac_cv_prog_cxx_g=yes
1266 else
1267   ac_cv_prog_cxx_g=no
1268 fi
1269 rm -f conftest*
1270
1271 fi
1272
1273 echo "$ac_t""$ac_cv_prog_cxx_g" 1>&6
1274   if test "$ac_test_CXXFLAGS" = set; then
1275     CXXFLAGS="$ac_save_CXXFLAGS"
1276   elif test $ac_cv_prog_cxx_g = yes; then
1277     CXXFLAGS="-g -O2"
1278   else
1279     CXXFLAGS="-O2"
1280   fi
1281 else
1282   GXX=
1283   test "${CXXFLAGS+set}" = set || CXXFLAGS="-g"
1284 fi
1285
1286
1287 # AC_CHECK_TOOL does AC_REQUIRE (AC_CANONICAL_BUILD).  If we dont
1288 # run it explicitly here, it will be run implicitly before
1289 # LIBGCJ_CONFIGURE, which doesn't work because that means that it will
1290 # be run before AC_CANONICAL_HOST.
1291 echo $ac_n "checking build system type""... $ac_c" 1>&6
1292 echo "configure:1293: checking build system type" >&5
1293
1294 build_alias=$build
1295 case "$build_alias" in
1296 NONE)
1297   case $nonopt in
1298   NONE) build_alias=$host_alias ;;
1299   *) build_alias=$nonopt ;;
1300   esac ;;
1301 esac
1302
1303 build=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $build_alias`
1304 build_cpu=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1305 build_vendor=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1306 build_os=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1307 echo "$ac_t""$build" 1>&6
1308
1309
1310 # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
1311 set dummy ${ac_tool_prefix}as; ac_word=$2
1312 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1313 echo "configure:1314: checking for $ac_word" >&5
1314 if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then
1315   echo $ac_n "(cached) $ac_c" 1>&6
1316 else
1317   if test -n "$AS"; then
1318   ac_cv_prog_AS="$AS" # Let the user override the test.
1319 else
1320   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1321   ac_dummy="$PATH"
1322   for ac_dir in $ac_dummy; do
1323     test -z "$ac_dir" && ac_dir=.
1324     if test -f $ac_dir/$ac_word; then
1325       ac_cv_prog_AS="${ac_tool_prefix}as"
1326       break
1327     fi
1328   done
1329   IFS="$ac_save_ifs"
1330   test -z "$ac_cv_prog_AS" && ac_cv_prog_AS="as"
1331 fi
1332 fi
1333 AS="$ac_cv_prog_AS"
1334 if test -n "$AS"; then
1335   echo "$ac_t""$AS" 1>&6
1336 else
1337   echo "$ac_t""no" 1>&6
1338 fi
1339
1340
1341
1342 # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
1343 set dummy ${ac_tool_prefix}ar; ac_word=$2
1344 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1345 echo "configure:1346: checking for $ac_word" >&5
1346 if eval "test \"`echo '$''{'ac_cv_prog_AR'+set}'`\" = set"; then
1347   echo $ac_n "(cached) $ac_c" 1>&6
1348 else
1349   if test -n "$AR"; then
1350   ac_cv_prog_AR="$AR" # Let the user override the test.
1351 else
1352   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1353   ac_dummy="$PATH"
1354   for ac_dir in $ac_dummy; do
1355     test -z "$ac_dir" && ac_dir=.
1356     if test -f $ac_dir/$ac_word; then
1357       ac_cv_prog_AR="${ac_tool_prefix}ar"
1358       break
1359     fi
1360   done
1361   IFS="$ac_save_ifs"
1362   test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="ar"
1363 fi
1364 fi
1365 AR="$ac_cv_prog_AR"
1366 if test -n "$AR"; then
1367   echo "$ac_t""$AR" 1>&6
1368 else
1369   echo "$ac_t""no" 1>&6
1370 fi
1371
1372
1373
1374 # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
1375 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
1376 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1377 echo "configure:1378: checking for $ac_word" >&5
1378 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1379   echo $ac_n "(cached) $ac_c" 1>&6
1380 else
1381   if test -n "$RANLIB"; then
1382   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1383 else
1384   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1385   ac_dummy="$PATH"
1386   for ac_dir in $ac_dummy; do
1387     test -z "$ac_dir" && ac_dir=.
1388     if test -f $ac_dir/$ac_word; then
1389       ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
1390       break
1391     fi
1392   done
1393   IFS="$ac_save_ifs"
1394 fi
1395 fi
1396 RANLIB="$ac_cv_prog_RANLIB"
1397 if test -n "$RANLIB"; then
1398   echo "$ac_t""$RANLIB" 1>&6
1399 else
1400   echo "$ac_t""no" 1>&6
1401 fi
1402
1403
1404 if test -z "$ac_cv_prog_RANLIB"; then
1405 if test -n "$ac_tool_prefix"; then
1406   # Extract the first word of "ranlib", so it can be a program name with args.
1407 set dummy ranlib; ac_word=$2
1408 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1409 echo "configure:1410: checking for $ac_word" >&5
1410 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1411   echo $ac_n "(cached) $ac_c" 1>&6
1412 else
1413   if test -n "$RANLIB"; then
1414   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1415 else
1416   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1417   ac_dummy="$PATH"
1418   for ac_dir in $ac_dummy; do
1419     test -z "$ac_dir" && ac_dir=.
1420     if test -f $ac_dir/$ac_word; then
1421       ac_cv_prog_RANLIB="ranlib"
1422       break
1423     fi
1424   done
1425   IFS="$ac_save_ifs"
1426   test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
1427 fi
1428 fi
1429 RANLIB="$ac_cv_prog_RANLIB"
1430 if test -n "$RANLIB"; then
1431   echo "$ac_t""$RANLIB" 1>&6
1432 else
1433   echo "$ac_t""no" 1>&6
1434 fi
1435
1436 else
1437   RANLIB=":"
1438 fi
1439 fi
1440
1441
1442 # Find a good install program.  We prefer a C program (faster),
1443 # so one script is as good as another.  But avoid the broken or
1444 # incompatible versions:
1445 # SysV /etc/install, /usr/sbin/install
1446 # SunOS /usr/etc/install
1447 # IRIX /sbin/install
1448 # AIX /bin/install
1449 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1450 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1451 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1452 # ./install, which can be erroneously created by make from ./install.sh.
1453 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
1454 echo "configure:1455: checking for a BSD compatible install" >&5
1455 if test -z "$INSTALL"; then
1456 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
1457   echo $ac_n "(cached) $ac_c" 1>&6
1458 else
1459     IFS="${IFS=         }"; ac_save_IFS="$IFS"; IFS=":"
1460   for ac_dir in $PATH; do
1461     # Account for people who put trailing slashes in PATH elements.
1462     case "$ac_dir/" in
1463     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
1464     *)
1465       # OSF1 and SCO ODT 3.0 have their own names for install.
1466       # Don't use installbsd from OSF since it installs stuff as root
1467       # by default.
1468       for ac_prog in ginstall scoinst install; do
1469         if test -f $ac_dir/$ac_prog; then
1470           if test $ac_prog = install &&
1471             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
1472             # AIX install.  It has an incompatible calling convention.
1473             :
1474           else
1475             ac_cv_path_install="$ac_dir/$ac_prog -c"
1476             break 2
1477           fi
1478         fi
1479       done
1480       ;;
1481     esac
1482   done
1483   IFS="$ac_save_IFS"
1484
1485 fi
1486   if test "${ac_cv_path_install+set}" = set; then
1487     INSTALL="$ac_cv_path_install"
1488   else
1489     # As a last resort, use the slow shell script.  We don't cache a
1490     # path for INSTALL within a source directory, because that will
1491     # break other packages using the cache if that directory is
1492     # removed, or if the path is relative.
1493     INSTALL="$ac_install_sh"
1494   fi
1495 fi
1496 echo "$ac_t""$INSTALL" 1>&6
1497
1498 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1499 # It thinks the first close brace ends the variable substitution.
1500 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1501
1502 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
1503
1504 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1505
1506
1507 echo $ac_n "checking whether to enable maintainer-specific portions of Makefiles""... $ac_c" 1>&6
1508 echo "configure:1509: checking whether to enable maintainer-specific portions of Makefiles" >&5
1509     # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
1510 if test "${enable_maintainer_mode+set}" = set; then
1511   enableval="$enable_maintainer_mode"
1512   USE_MAINTAINER_MODE=$enableval
1513 else
1514   USE_MAINTAINER_MODE=no
1515 fi
1516
1517   echo "$ac_t""$USE_MAINTAINER_MODE" 1>&6
1518
1519
1520 if test $USE_MAINTAINER_MODE = yes; then
1521   MAINTAINER_MODE_TRUE=
1522   MAINTAINER_MODE_FALSE='#'
1523 else
1524   MAINTAINER_MODE_TRUE='#'
1525   MAINTAINER_MODE_FALSE=
1526 fi
1527   MAINT=$MAINTAINER_MODE_TRUE
1528
1529
1530
1531 # We need AC_EXEEXT to keep automake happy in cygnus mode.  However,
1532 # at least currently, we never actually build a program, so we never
1533 # need to use $(EXEEXT).  Moreover, the test for EXEEXT normally
1534 # fails, because we are probably configuring with a cross compiler
1535 # which cant create executables.  So we include AC_EXEEXT to keep
1536 # automake happy, but we dont execute it, since we dont care about
1537 # the result.
1538 if false; then
1539
1540
1541 echo $ac_n "checking for executable suffix""... $ac_c" 1>&6
1542 echo "configure:1543: checking for executable suffix" >&5
1543 if eval "test \"`echo '$''{'ac_cv_exeext'+set}'`\" = set"; then
1544   echo $ac_n "(cached) $ac_c" 1>&6
1545 else
1546   if test "$CYGWIN" = yes || test "$MINGW32" = yes; then
1547   ac_cv_exeext=.exe
1548 else
1549   rm -f conftest*
1550   echo 'int main () { return 0; }' > conftest.$ac_ext
1551   ac_cv_exeext=
1552   if { (eval echo configure:1553: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
1553     for file in conftest.*; do
1554       case $file in
1555       *.c | *.o | *.obj | *.ilk | *.pdb) ;;
1556       *) ac_cv_exeext=`echo $file | sed -e s/conftest//` ;;
1557       esac
1558     done
1559   else
1560     { echo "configure: error: installation or configuration problem: compiler cannot create executables." 1>&2; exit 1; }
1561   fi
1562   rm -f conftest*
1563   test x"${ac_cv_exeext}" = x && ac_cv_exeext=no
1564 fi
1565 fi
1566
1567 EXEEXT=""
1568 test x"${ac_cv_exeext}" != xno && EXEEXT=${ac_cv_exeext}
1569 echo "$ac_t""${ac_cv_exeext}" 1>&6
1570 ac_exeext=$EXEEXT
1571
1572 fi
1573
1574 # configure.host sets the following important variables
1575 #       glibcpp_cflags    - host specific C compiler flags
1576 #       glibcpp_cxxflags  - host specific C++ compiler flags
1577
1578 glibcpp_cflags=
1579 glibcpp_cxxflags=
1580
1581 . ${glibcpp_basedir}/configure.host
1582
1583 case ${glibcpp_basedir} in
1584 /* | A-Za-z:/\\*) libgcj_flagbasedir=${glibcpp_basedir} ;;
1585 *) glibcpp_flagbasedir='$(top_builddir)/'${glibcpp_basedir} ;;
1586 esac
1587
1588 GLIBCPP_CFLAGS="${glibcpp_cflags}"
1589 GLIBCPP_CXXFLAGS="${glibcpp_cxxflags}"
1590
1591
1592
1593
1594 # Check whether --enable-shared or --disable-shared was given.
1595 if test "${enable_shared+set}" = set; then
1596   enableval="$enable_shared"
1597   p=${PACKAGE-default}
1598 case "$enableval" in
1599 yes) enable_shared=yes ;;
1600 no) enable_shared=no ;;
1601 *)
1602   enable_shared=no
1603   # Look at the argument we got.  We use all the common list separators.
1604   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1605   for pkg in $enableval; do
1606     if test "X$pkg" = "X$p"; then
1607       enable_shared=yes
1608     fi
1609   done
1610   IFS="$ac_save_ifs"
1611   ;;
1612 esac
1613 else
1614   enable_shared=yes
1615 fi
1616
1617 # Check whether --enable-static or --disable-static was given.
1618 if test "${enable_static+set}" = set; then
1619   enableval="$enable_static"
1620   p=${PACKAGE-default}
1621 case "$enableval" in
1622 yes) enable_static=yes ;;
1623 no) enable_static=no ;;
1624 *)
1625   enable_static=no
1626   # Look at the argument we got.  We use all the common list separators.
1627   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1628   for pkg in $enableval; do
1629     if test "X$pkg" = "X$p"; then
1630       enable_static=yes
1631     fi
1632   done
1633   IFS="$ac_save_ifs"
1634   ;;
1635 esac
1636 else
1637   enable_static=yes
1638 fi
1639
1640 # Check whether --enable-fast-install or --disable-fast-install was given.
1641 if test "${enable_fast_install+set}" = set; then
1642   enableval="$enable_fast_install"
1643   p=${PACKAGE-default}
1644 case "$enableval" in
1645 yes) enable_fast_install=yes ;;
1646 no) enable_fast_install=no ;;
1647 *)
1648   enable_fast_install=no
1649   # Look at the argument we got.  We use all the common list separators.
1650   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1651   for pkg in $enableval; do
1652     if test "X$pkg" = "X$p"; then
1653       enable_fast_install=yes
1654     fi
1655   done
1656   IFS="$ac_save_ifs"
1657   ;;
1658 esac
1659 else
1660   enable_fast_install=yes
1661 fi
1662
1663 # Extract the first word of "ranlib", so it can be a program name with args.
1664 set dummy ranlib; ac_word=$2
1665 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1666 echo "configure:1667: checking for $ac_word" >&5
1667 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1668   echo $ac_n "(cached) $ac_c" 1>&6
1669 else
1670   if test -n "$RANLIB"; then
1671   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1672 else
1673   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1674   ac_dummy="$PATH"
1675   for ac_dir in $ac_dummy; do
1676     test -z "$ac_dir" && ac_dir=.
1677     if test -f $ac_dir/$ac_word; then
1678       ac_cv_prog_RANLIB="ranlib"
1679       break
1680     fi
1681   done
1682   IFS="$ac_save_ifs"
1683   test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
1684 fi
1685 fi
1686 RANLIB="$ac_cv_prog_RANLIB"
1687 if test -n "$RANLIB"; then
1688   echo "$ac_t""$RANLIB" 1>&6
1689 else
1690   echo "$ac_t""no" 1>&6
1691 fi
1692
1693 # Check whether --with-gnu-ld or --without-gnu-ld was given.
1694 if test "${with_gnu_ld+set}" = set; then
1695   withval="$with_gnu_ld"
1696   test "$withval" = no || with_gnu_ld=yes
1697 else
1698   with_gnu_ld=no
1699 fi
1700
1701 ac_prog=ld
1702 if test "$ac_cv_prog_gcc" = yes; then
1703   # Check if gcc -print-prog-name=ld gives a path.
1704   echo $ac_n "checking for ld used by GCC""... $ac_c" 1>&6
1705 echo "configure:1706: checking for ld used by GCC" >&5
1706   ac_prog=`($CC -print-prog-name=ld) 2>&5`
1707   case "$ac_prog" in
1708     # Accept absolute paths.
1709     [\\/]* | [A-Za-z]:[\\/]*)
1710       re_direlt='/[^/][^/]*/\.\./'
1711       # Canonicalize the path of ld
1712       ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
1713       while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
1714         ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
1715       done
1716       test -z "$LD" && LD="$ac_prog"
1717       ;;
1718   "")
1719     # If it fails, then pretend we aren't using GCC.
1720     ac_prog=ld
1721     ;;
1722   *)
1723     # If it is relative, then search for the first ld in PATH.
1724     with_gnu_ld=unknown
1725     ;;
1726   esac
1727 elif test "$with_gnu_ld" = yes; then
1728   echo $ac_n "checking for GNU ld""... $ac_c" 1>&6
1729 echo "configure:1730: checking for GNU ld" >&5
1730 else
1731   echo $ac_n "checking for non-GNU ld""... $ac_c" 1>&6
1732 echo "configure:1733: checking for non-GNU ld" >&5
1733 fi
1734 if eval "test \"`echo '$''{'ac_cv_path_LD'+set}'`\" = set"; then
1735   echo $ac_n "(cached) $ac_c" 1>&6
1736 else
1737   if test -z "$LD"; then
1738   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
1739   for ac_dir in $PATH; do
1740     test -z "$ac_dir" && ac_dir=.
1741     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
1742       ac_cv_path_LD="$ac_dir/$ac_prog"
1743       # Check to see if the program is GNU ld.  I'd rather use --version,
1744       # but apparently some GNU ld's only accept -v.
1745       # Break only if it was the GNU/non-GNU ld that we prefer.
1746       if "$ac_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
1747         test "$with_gnu_ld" != no && break
1748       else
1749         test "$with_gnu_ld" != yes && break
1750       fi
1751     fi
1752   done
1753   IFS="$ac_save_ifs"
1754 else
1755   ac_cv_path_LD="$LD" # Let the user override the test with a path.
1756 fi
1757 fi
1758
1759 LD="$ac_cv_path_LD"
1760 if test -n "$LD"; then
1761   echo "$ac_t""$LD" 1>&6
1762 else
1763   echo "$ac_t""no" 1>&6
1764 fi
1765 test -z "$LD" && { echo "configure: error: no acceptable ld found in \$PATH" 1>&2; exit 1; }
1766 echo $ac_n "checking if the linker ($LD) is GNU ld""... $ac_c" 1>&6
1767 echo "configure:1768: checking if the linker ($LD) is GNU ld" >&5
1768 if eval "test \"`echo '$''{'ac_cv_prog_gnu_ld'+set}'`\" = set"; then
1769   echo $ac_n "(cached) $ac_c" 1>&6
1770 else
1771   # I'd rather use --version here, but apparently some GNU ld's only accept -v.
1772 if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
1773   ac_cv_prog_gnu_ld=yes
1774 else
1775   ac_cv_prog_gnu_ld=no
1776 fi
1777 fi
1778
1779 echo "$ac_t""$ac_cv_prog_gnu_ld" 1>&6
1780
1781
1782 echo $ac_n "checking for BSD-compatible nm""... $ac_c" 1>&6
1783 echo "configure:1784: checking for BSD-compatible nm" >&5
1784 if eval "test \"`echo '$''{'ac_cv_path_NM'+set}'`\" = set"; then
1785   echo $ac_n "(cached) $ac_c" 1>&6
1786 else
1787   if test -n "$NM"; then
1788   # Let the user override the test.
1789   ac_cv_path_NM="$NM"
1790 else
1791   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
1792   for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
1793     test -z "$ac_dir" && ac_dir=.
1794     if test -f $ac_dir/nm || test -f $ac_dir/nm$ac_exeext ; then
1795       # Check to see if the nm accepts a BSD-compat flag.
1796       # Adding the `sed 1q' prevents false positives on HP-UX, which says:
1797       #   nm: unknown option "B" ignored
1798       if ($ac_dir/nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
1799         ac_cv_path_NM="$ac_dir/nm -B"
1800         break
1801       elif ($ac_dir/nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
1802         ac_cv_path_NM="$ac_dir/nm -p"
1803         break
1804       else
1805         ac_cv_path_NM=${ac_cv_path_NM="$ac_dir/nm"} # keep the first match, but
1806         continue # so that we can try to find one that supports BSD flags
1807       fi
1808     fi
1809   done
1810   IFS="$ac_save_ifs"
1811   test -z "$ac_cv_path_NM" && ac_cv_path_NM=nm
1812 fi
1813 fi
1814
1815 NM="$ac_cv_path_NM"
1816 echo "$ac_t""$NM" 1>&6
1817
1818 echo $ac_n "checking whether ln -s works""... $ac_c" 1>&6
1819 echo "configure:1820: checking whether ln -s works" >&5
1820 if eval "test \"`echo '$''{'ac_cv_prog_LN_S'+set}'`\" = set"; then
1821   echo $ac_n "(cached) $ac_c" 1>&6
1822 else
1823   rm -f conftestdata
1824 if ln -s X conftestdata 2>/dev/null
1825 then
1826   rm -f conftestdata
1827   ac_cv_prog_LN_S="ln -s"
1828 else
1829   ac_cv_prog_LN_S=ln
1830 fi
1831 fi
1832 LN_S="$ac_cv_prog_LN_S"
1833 if test "$ac_cv_prog_LN_S" = "ln -s"; then
1834   echo "$ac_t""yes" 1>&6
1835 else
1836   echo "$ac_t""no" 1>&6
1837 fi
1838
1839
1840 # Check for any special flags to pass to ltconfig.
1841 libtool_flags="--cache-file=$cache_file"
1842 test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
1843 test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
1844 test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
1845 test "$ac_cv_prog_gcc" = yes && libtool_flags="$libtool_flags --with-gcc"
1846 test "$ac_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
1847 libtool_flags="$libtool_flags --enable-dlopen"
1848
1849 # Check whether --enable-libtool-lock or --disable-libtool-lock was given.
1850 if test "${enable_libtool_lock+set}" = set; then
1851   enableval="$enable_libtool_lock"
1852   :
1853 fi
1854
1855 test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
1856 test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
1857
1858 # Some flags need to be propagated to the compiler or linker for good
1859 # libtool support.
1860 case "$host" in
1861 *-*-irix6*)
1862   # Find out which ABI we are using.
1863   echo '#line 1864 "configure"' > conftest.$ac_ext
1864   if { (eval echo configure:1865: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
1865     case "`/usr/bin/file conftest.o`" in
1866     *32-bit*)
1867       LD="${LD-ld} -32"
1868       ;;
1869     *N32*)
1870       LD="${LD-ld} -n32"
1871       ;;
1872     *64-bit*)
1873       LD="${LD-ld} -64"
1874       ;;
1875     esac
1876   fi
1877   rm -rf conftest*
1878   ;;
1879
1880 *-*-sco3.2v5*)
1881   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
1882   SAVE_CFLAGS="$CFLAGS"
1883   CFLAGS="$CFLAGS -belf"
1884   echo $ac_n "checking whether the C compiler needs -belf""... $ac_c" 1>&6
1885 echo "configure:1886: checking whether the C compiler needs -belf" >&5
1886 if eval "test \"`echo '$''{'lt_cv_cc_needs_belf'+set}'`\" = set"; then
1887   echo $ac_n "(cached) $ac_c" 1>&6
1888 else
1889   cat > conftest.$ac_ext <<EOF
1890 #line 1891 "configure"
1891 #include "confdefs.h"
1892
1893 int main() {
1894
1895 ; return 0; }
1896 EOF
1897 if { (eval echo configure:1898: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
1898   rm -rf conftest*
1899   lt_cv_cc_needs_belf=yes
1900 else
1901   echo "configure: failed program was:" >&5
1902   cat conftest.$ac_ext >&5
1903   rm -rf conftest*
1904   lt_cv_cc_needs_belf=no
1905 fi
1906 rm -f conftest*
1907 fi
1908
1909 echo "$ac_t""$lt_cv_cc_needs_belf" 1>&6
1910   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
1911     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
1912     CFLAGS="$SAVE_CFLAGS"
1913   fi
1914   ;;
1915
1916
1917 esac
1918
1919
1920 # Save cache, so that ltconfig can load it
1921 cat > confcache <<\EOF
1922 # This file is a shell script that caches the results of configure
1923 # tests run on this system so they can be shared between configure
1924 # scripts and configure runs.  It is not useful on other systems.
1925 # If it contains results you don't want to keep, you may remove or edit it.
1926 #
1927 # By default, configure uses ./config.cache as the cache file,
1928 # creating it if it does not exist already.  You can give configure
1929 # the --cache-file=FILE option to use a different cache file; that is
1930 # what configure does when it calls configure scripts in
1931 # subdirectories, so they share the cache.
1932 # Giving --cache-file=/dev/null disables caching, for debugging configure.
1933 # config.status only pays attention to the cache file if you give it the
1934 # --recheck option to rerun configure.
1935 #
1936 EOF
1937 # The following way of writing the cache mishandles newlines in values,
1938 # but we know of no workaround that is simple, portable, and efficient.
1939 # So, don't put newlines in cache variables' values.
1940 # Ultrix sh set writes to stderr and can't be redirected directly,
1941 # and sets the high bit in the cache file unless we assign to the vars.
1942 (set) 2>&1 |
1943   case `(ac_space=' '; set | grep ac_space) 2>&1` in
1944   *ac_space=\ *)
1945     # `set' does not quote correctly, so add quotes (double-quote substitution
1946     # turns \\\\ into \\, and sed turns \\ into \).
1947     sed -n \
1948       -e "s/'/'\\\\''/g" \
1949       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
1950     ;;
1951   *)
1952     # `set' quotes correctly as required by POSIX, so do not add quotes.
1953     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
1954     ;;
1955   esac >> confcache
1956 if cmp -s $cache_file confcache; then
1957   :
1958 else
1959   if test -w $cache_file; then
1960     echo "updating cache $cache_file"
1961     cat confcache > $cache_file
1962   else
1963     echo "not updating unwritable cache $cache_file"
1964   fi
1965 fi
1966 rm -f confcache
1967
1968
1969 # Actually configure libtool.  ac_aux_dir is where install-sh is found.
1970 CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
1971 LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
1972 LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" \
1973 DLLTOOL="$DLLTOOL" AS="$AS" OBJDUMP="$OBJDUMP" \
1974 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
1975 $libtool_flags --no-verify $ac_aux_dir/ltmain.sh $host \
1976 || { echo "configure: error: libtool configure failed" 1>&2; exit 1; }
1977
1978 # Reload cache, that may have been modified by ltconfig
1979 if test -r "$cache_file"; then
1980   echo "loading cache $cache_file"
1981   . $cache_file
1982 else
1983   echo "creating cache $cache_file"
1984   > $cache_file
1985 fi
1986
1987
1988 # This can be used to rebuild libtool when needed
1989 LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh"
1990
1991 # Always use our own libtool.
1992 LIBTOOL='$(SHELL) $(top_builddir)/libtool'
1993
1994 # Redirect the config.log output again, so that the ltconfig log is not
1995 # clobbered by the next message.
1996 exec 5>>./config.log
1997
1998
1999
2000
2001
2002 # Check for c++ or library specific bits that don't require linking.
2003 echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
2004 echo "configure:2005: checking how to run the C preprocessor" >&5
2005 # On Suns, sometimes $CPP names a directory.
2006 if test -n "$CPP" && test -d "$CPP"; then
2007   CPP=
2008 fi
2009 if test -z "$CPP"; then
2010 if eval "test \"`echo '$''{'ac_cv_prog_CPP'+set}'`\" = set"; then
2011   echo $ac_n "(cached) $ac_c" 1>&6
2012 else
2013     # This must be in double quotes, not single quotes, because CPP may get
2014   # substituted into the Makefile and "${CC-cc}" will confuse make.
2015   CPP="${CC-cc} -E"
2016   # On the NeXT, cc -E runs the code through the compiler's parser,
2017   # not just through cpp.
2018   cat > conftest.$ac_ext <<EOF
2019 #line 2020 "configure"
2020 #include "confdefs.h"
2021 #include <assert.h>
2022 Syntax Error
2023 EOF
2024 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2025 { (eval echo configure:2026: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2026 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2027 if test -z "$ac_err"; then
2028   :
2029 else
2030   echo "$ac_err" >&5
2031   echo "configure: failed program was:" >&5
2032   cat conftest.$ac_ext >&5
2033   rm -rf conftest*
2034   CPP="${CC-cc} -E -traditional-cpp"
2035   cat > conftest.$ac_ext <<EOF
2036 #line 2037 "configure"
2037 #include "confdefs.h"
2038 #include <assert.h>
2039 Syntax Error
2040 EOF
2041 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2042 { (eval echo configure:2043: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2043 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2044 if test -z "$ac_err"; then
2045   :
2046 else
2047   echo "$ac_err" >&5
2048   echo "configure: failed program was:" >&5
2049   cat conftest.$ac_ext >&5
2050   rm -rf conftest*
2051   CPP="${CC-cc} -nologo -E"
2052   cat > conftest.$ac_ext <<EOF
2053 #line 2054 "configure"
2054 #include "confdefs.h"
2055 #include <assert.h>
2056 Syntax Error
2057 EOF
2058 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2059 { (eval echo configure:2060: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2060 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2061 if test -z "$ac_err"; then
2062   :
2063 else
2064   echo "$ac_err" >&5
2065   echo "configure: failed program was:" >&5
2066   cat conftest.$ac_ext >&5
2067   rm -rf conftest*
2068   CPP=/lib/cpp
2069 fi
2070 rm -f conftest*
2071 fi
2072 rm -f conftest*
2073 fi
2074 rm -f conftest*
2075   ac_cv_prog_CPP="$CPP"
2076 fi
2077   CPP="$ac_cv_prog_CPP"
2078 else
2079   ac_cv_prog_CPP="$CPP"
2080 fi
2081 echo "$ac_t""$CPP" 1>&6
2082
2083
2084   # Sanity check that g++ is capable of dealing with v-3.
2085   echo $ac_n "checking for g++ that will successfully compile this code""... $ac_c" 1>&6
2086 echo "configure:2087: checking for g++ that will successfully compile this code" >&5
2087   cat > conftest.$ac_ext <<EOF
2088 #line 2089 "configure"
2089 #include "confdefs.h"
2090
2091   #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
2092     ok
2093   #endif
2094
2095 EOF
2096 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
2097   egrep "ok" >/dev/null 2>&1; then
2098   rm -rf conftest*
2099   gpp_satisfactory=yes
2100 else
2101   rm -rf conftest*
2102   { echo "configure: error: "please upgrade to gcc-2.95 or above"" 1>&2; exit 1; }
2103 fi
2104 rm -f conftest*
2105
2106   echo "$ac_t""$gpp_satisfactory" 1>&6
2107
2108
2109     echo $ac_n "checking for cpu primitives directory""... $ac_c" 1>&6
2110 echo "configure:2111: checking for cpu primitives directory" >&5
2111     CPU_FLAGS=
2112     case "$target_cpu" in
2113       alpha*)
2114         cpu_include_dir="config/cpu/alpha"
2115         ;;
2116       arm*)
2117         cpu_include_dir="config/cpu/arm"
2118         ;;
2119       i386)
2120         cpu_include_dir="config/cpu/i386"
2121         ;;
2122       i486 | i586 | i686 | i786)
2123         cpu_include_dir="config/cpu/i486"
2124         ;;
2125       powerpc | rs6000)
2126         cpu_include_dir="config/cpu/powerpc"
2127         CPU_FLAGS='-mcpu=powerpc'
2128         ;;
2129       sparc64 | ultrasparc)
2130         cpu_include_dir="config/cpu/sparc/sparc64"
2131         ;;
2132       sparc*)
2133         cpu_include_dir="config/cpu/sparc/sparc32"
2134         ;;
2135       *)
2136         cpu_include_dir="config/cpu/generic"
2137         ;;
2138     esac
2139     echo "$ac_t""$cpu_include_dir" 1>&6
2140
2141
2142
2143
2144 # Enable all the crazy c++ stuff.
2145 # Check whether --enable-debug or --disable-debug was given.
2146 if test "${enable_debug+set}" = set; then
2147   enableval="$enable_debug"
2148   case "$enableval" in
2149  yes) enable_debug=yes ;;
2150  no)  enable_debug=no ;;
2151  *)   { echo "configure: error: Unknown argument to enable/disable extra debugging" 1>&2; exit 1; } ;;
2152  esac
2153 else
2154   enable_debug=no
2155 fi
2156 case "$enable_debug" in
2157     yes)
2158         DEBUG_FLAGS='-O0 -ggdb'
2159         ;;
2160     no)
2161         DEBUG_FLAGS='-g'
2162         ;;
2163 esac
2164
2165
2166
2167   echo $ac_n "checking for cstdio to use""... $ac_c" 1>&6
2168 echo "configure:2169: checking for cstdio to use" >&5
2169   # Check whether --enable-cstdio or --disable-cstdio was given.
2170 if test "${enable_cstdio+set}" = set; then
2171   enableval="$enable_cstdio"
2172   if test x$enable_cstdio = xno; then
2173     enable_cstdio=libio
2174   fi
2175 else
2176   enable_cstdio=libio
2177 fi
2178
2179
2180   enable_cstdio_flag=$enable_cstdio
2181
2182     case x${enable_cstdio_flag} in
2183         xlibio | x | xno | xnone | xyes)
2184                 # default
2185                 CSTDIO_H=c_io_libio.h
2186                 CSTDIO_CC=c_io_libio.cc
2187                 echo "$ac_t""libio" 1>&6
2188
2189                 # see if we are on a system with libio native (ie, linux)
2190                 ac_safe=`echo "libio.h" | sed 'y%./+-%__p_%'`
2191 echo $ac_n "checking for libio.h""... $ac_c" 1>&6
2192 echo "configure:2193: checking for libio.h" >&5
2193 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
2194   echo $ac_n "(cached) $ac_c" 1>&6
2195 else
2196   cat > conftest.$ac_ext <<EOF
2197 #line 2198 "configure"
2198 #include "confdefs.h"
2199 #include <libio.h>
2200 EOF
2201 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2202 { (eval echo configure:2203: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2203 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2204 if test -z "$ac_err"; then
2205   rm -rf conftest*
2206   eval "ac_cv_header_$ac_safe=yes"
2207 else
2208   echo "$ac_err" >&5
2209   echo "configure: failed program was:" >&5
2210   cat conftest.$ac_ext >&5
2211   rm -rf conftest*
2212   eval "ac_cv_header_$ac_safe=no"
2213 fi
2214 rm -f conftest*
2215 fi
2216 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
2217   echo "$ac_t""yes" 1>&6
2218   has_libio=yes
2219 else
2220   echo "$ac_t""no" 1>&6
2221 has_libio=no
2222 fi
2223
2224                 if test $has_libio = "yes"; then
2225                   BUILD_LIBIO_INCLUDE=
2226                   need_libio=no
2227                 else
2228                   BUILD_LIBIO_INCLUDE='-I../libio'
2229                   need_libio=yes
2230                 fi
2231
2232
2233                 # see if the _G_config.h header needs to be built.
2234                 # NB: This replaces the _G_CONFIG_H machinery in libio-v2
2235                 ac_safe=`echo "_G_config.h" | sed 'y%./+-%__p_%'`
2236 echo $ac_n "checking for _G_config.h""... $ac_c" 1>&6
2237 echo "configure:2238: checking for _G_config.h" >&5
2238 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
2239   echo $ac_n "(cached) $ac_c" 1>&6
2240 else
2241   cat > conftest.$ac_ext <<EOF
2242 #line 2243 "configure"
2243 #include "confdefs.h"
2244 #include <_G_config.h>
2245 EOF
2246 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2247 { (eval echo configure:2248: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2248 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2249 if test -z "$ac_err"; then
2250   rm -rf conftest*
2251   eval "ac_cv_header_$ac_safe=yes"
2252 else
2253   echo "$ac_err" >&5
2254   echo "configure: failed program was:" >&5
2255   cat conftest.$ac_ext >&5
2256   rm -rf conftest*
2257   eval "ac_cv_header_$ac_safe=no"
2258 fi
2259 rm -f conftest*
2260 fi
2261 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
2262   echo "$ac_t""yes" 1>&6
2263   has_gconf_h=yes
2264 else
2265   echo "$ac_t""no" 1>&6
2266 has_gconf_h=no
2267 fi
2268
2269
2270
2271 if test "$has_gconf_h" = no; then
2272   GLIBCPP_NEED_LIBIO_CONFIG_H_TRUE=
2273   GLIBCPP_NEED_LIBIO_CONFIG_H_FALSE='#'
2274 else
2275   GLIBCPP_NEED_LIBIO_CONFIG_H_TRUE='#'
2276   GLIBCPP_NEED_LIBIO_CONFIG_H_FALSE=
2277 fi
2278                 ;;
2279         xwince)
2280                 CSTDIO_H=c_io_wince.h
2281                 CSTDIO_CC=c_io_wince.cc
2282                 echo "$ac_t""wince" 1>&6
2283
2284                 need_libio=no
2285                 BUILD_LIBIO_INCLUDE=
2286
2287                 ;;
2288         *)
2289                 echo "$enable_cstdio is an unknown io package" 1>&2
2290                 exit 1
2291                 ;;
2292   esac
2293
2294
2295
2296
2297 if test "$need_libio" = yes; then
2298   GLIBCPP_NEED_LIBIO_TRUE=
2299   GLIBCPP_NEED_LIBIO_FALSE='#'
2300 else
2301   GLIBCPP_NEED_LIBIO_TRUE='#'
2302   GLIBCPP_NEED_LIBIO_FALSE=
2303 fi
2304
2305
2306   # Check whether --enable-long-long or --disable-long-long was given.
2307 if test "${enable_long_long+set}" = set; then
2308   enableval="$enable_long_long"
2309     case "$enableval" in
2310    yes) enable_long_long=yes ;;
2311    no)  enable_long_long=no ;;
2312    *)   { echo "configure: error: Unknown argument to enable/disable long long" 1>&2; exit 1; } ;;
2313    esac
2314 else
2315   enable_long_long=yes
2316 fi
2317
2318   # Check for the existance of functions used if long long is enabled.
2319   echo $ac_n "checking for strtoll""... $ac_c" 1>&6
2320 echo "configure:2321: checking for strtoll" >&5
2321 if eval "test \"`echo '$''{'ac_cv_func_strtoll'+set}'`\" = set"; then
2322   echo $ac_n "(cached) $ac_c" 1>&6
2323 else
2324   cat > conftest.$ac_ext <<EOF
2325 #line 2326 "configure"
2326 #include "confdefs.h"
2327 /* System header to define __stub macros and hopefully few prototypes,
2328     which can conflict with char strtoll(); below.  */
2329 #include <assert.h>
2330 /* Override any gcc2 internal prototype to avoid an error.  */
2331 /* We use char because int might match the return type of a gcc2
2332     builtin and then its argument prototype would still apply.  */
2333 char strtoll();
2334
2335 int main() {
2336
2337 /* The GNU C library defines this for functions which it implements
2338     to always fail with ENOSYS.  Some functions are actually named
2339     something starting with __ and the normal name is an alias.  */
2340 #if defined (__stub_strtoll) || defined (__stub___strtoll)
2341 choke me
2342 #else
2343 strtoll();
2344 #endif
2345
2346 ; return 0; }
2347 EOF
2348 if { (eval echo configure:2349: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2349   rm -rf conftest*
2350   eval "ac_cv_func_strtoll=yes"
2351 else
2352   echo "configure: failed program was:" >&5
2353   cat conftest.$ac_ext >&5
2354   rm -rf conftest*
2355   eval "ac_cv_func_strtoll=no"
2356 fi
2357 rm -f conftest*
2358 fi
2359
2360 if eval "test \"`echo '$ac_cv_func_'strtoll`\" = yes"; then
2361   echo "$ac_t""yes" 1>&6
2362   :
2363 else
2364   echo "$ac_t""no" 1>&6
2365 ac_strtoll=no
2366 fi
2367
2368   echo $ac_n "checking for strtoull""... $ac_c" 1>&6
2369 echo "configure:2370: checking for strtoull" >&5
2370 if eval "test \"`echo '$''{'ac_cv_func_strtoull'+set}'`\" = set"; then
2371   echo $ac_n "(cached) $ac_c" 1>&6
2372 else
2373   cat > conftest.$ac_ext <<EOF
2374 #line 2375 "configure"
2375 #include "confdefs.h"
2376 /* System header to define __stub macros and hopefully few prototypes,
2377     which can conflict with char strtoull(); below.  */
2378 #include <assert.h>
2379 /* Override any gcc2 internal prototype to avoid an error.  */
2380 /* We use char because int might match the return type of a gcc2
2381     builtin and then its argument prototype would still apply.  */
2382 char strtoull();
2383
2384 int main() {
2385
2386 /* The GNU C library defines this for functions which it implements
2387     to always fail with ENOSYS.  Some functions are actually named
2388     something starting with __ and the normal name is an alias.  */
2389 #if defined (__stub_strtoull) || defined (__stub___strtoull)
2390 choke me
2391 #else
2392 strtoull();
2393 #endif
2394
2395 ; return 0; }
2396 EOF
2397 if { (eval echo configure:2398: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2398   rm -rf conftest*
2399   eval "ac_cv_func_strtoull=yes"
2400 else
2401   echo "configure: failed program was:" >&5
2402   cat conftest.$ac_ext >&5
2403   rm -rf conftest*
2404   eval "ac_cv_func_strtoull=no"
2405 fi
2406 rm -f conftest*
2407 fi
2408
2409 if eval "test \"`echo '$ac_cv_func_'strtoull`\" = yes"; then
2410   echo "$ac_t""yes" 1>&6
2411   :
2412 else
2413   echo "$ac_t""no" 1>&6
2414 ac_strtoull=no
2415 fi
2416
2417
2418   echo $ac_n "checking for enabled long long""... $ac_c" 1>&6
2419 echo "configure:2420: checking for enabled long long" >&5
2420   if test x"$ac_strtoll" = xno || test x"$ac_strtoull" = xno; then
2421     enable_long_long=no;
2422   fi;
2423   echo "$ac_t""$enable_long_long" 1>&6
2424
2425     case "$enable_long_long" in
2426     yes)  cat >> confdefs.h <<\EOF
2427 #define _GLIBCPP_USE_LONG_LONG 1
2428 EOF
2429
2430           ;;
2431   esac
2432
2433 echo $ac_n "checking for enabled cshadow headers""... $ac_c" 1>&6
2434 echo "configure:2435: checking for enabled cshadow headers" >&5
2435 # Check whether --enable-cshadow-headers or --disable-cshadow-headers was given.
2436 if test "${enable_cshadow_headers+set}" = set; then
2437   enableval="$enable_cshadow_headers"
2438   case "$enableval" in
2439  yes) enable_cshadow_headers=yes
2440         ;;
2441  no)  enable_cshadow_headers=no
2442         ;;
2443  *)   { echo "configure: error: Unknown argument to enable/disable shadowed C headers" 1>&2; exit 1; }
2444         ;;
2445  esac
2446 else
2447   enable_cshadow_headers=no
2448 fi
2449 echo "$ac_t""$enable_cshadow_headers" 1>&6
2450 case "$enable_cshadow_headers" in
2451     yes)
2452         CSHADOWFLAGS="-D_GNU_SOURCE"
2453         CSHADOW_INCLUDES=" -I$srcdir/shadow -I$blddir/cshadow"
2454         ;;
2455     no)
2456         CSHADOWFLAGS=""
2457         CSHADOW_INCLUDES=""
2458         ;;
2459 esac
2460
2461
2462
2463
2464
2465 if test "$enable_cshadow_headers" = yes; then
2466   GLIBCPP_USE_CSHADOW_TRUE=
2467   GLIBCPP_USE_CSHADOW_FALSE='#'
2468 else
2469   GLIBCPP_USE_CSHADOW_TRUE='#'
2470   GLIBCPP_USE_CSHADOW_FALSE=
2471 fi
2472
2473
2474       echo $ac_n "checking for threads package to use""... $ac_c" 1>&6
2475 echo "configure:2476: checking for threads package to use" >&5
2476   # Check whether --enable-threads or --disable-threads was given.
2477 if test "${enable_threads+set}" = set; then
2478   enableval="$enable_threads"
2479   if test x$enable_threads = xno; then
2480     enable_threads=''
2481   fi
2482 else
2483   enable_threads=''
2484 fi
2485
2486
2487   enable_threads_flag=$enable_threads
2488
2489     case x${enable_threads_flag} in
2490         x | xno | xnone)
2491                 # No threads
2492                 target_thread_file='single'
2493                 ;;
2494         xyes)
2495                 # default
2496                 target_thread_file=''
2497                 ;;
2498         xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \
2499         xsolaris | xwin32 | xdce | xvxworks)
2500                 target_thread_file=$enable_threads_flag
2501                 ;;
2502         *)
2503                 echo "$enable_threads is an unknown thread package" 1>&2
2504                 exit 1
2505                 ;;
2506   esac
2507
2508     case "$target_thread_file" in
2509     no | none | single)
2510       THREADS=none
2511       ;;
2512     posix | pthreads)
2513       THREADS=posix
2514       case "$host" in
2515         *-*-linux*)
2516         ;;
2517       esac
2518       ;;
2519     decosf1 | irix | mach | os2 | solaris | win32 | dce | vxworks)
2520       { echo "configure: error: thread package $THREADS not yet supported" 1>&2; exit 1; }
2521       ;;
2522     *)
2523       { echo "configure: error: $THREADS is an unknown thread package" 1>&2; exit 1; }
2524       ;;
2525   esac
2526   echo "$ac_t""$THREADS" 1>&6
2527
2528   THREADLIBS=
2529   THREADINCS=
2530   THREADDEPS=
2531   THREADOBJS=
2532   THREADH=
2533   THREADSPEC=
2534   case "$THREADS" in
2535     posix)
2536       ac_safe=`echo "pthread.h" | sed 'y%./+-%__p_%'`
2537 echo $ac_n "checking for pthread.h""... $ac_c" 1>&6
2538 echo "configure:2539: checking for pthread.h" >&5
2539 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
2540   echo $ac_n "(cached) $ac_c" 1>&6
2541 else
2542   cat > conftest.$ac_ext <<EOF
2543 #line 2544 "configure"
2544 #include "confdefs.h"
2545 #include <pthread.h>
2546 EOF
2547 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2548 { (eval echo configure:2549: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2549 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2550 if test -z "$ac_err"; then
2551   rm -rf conftest*
2552   eval "ac_cv_header_$ac_safe=yes"
2553 else
2554   echo "$ac_err" >&5
2555   echo "configure: failed program was:" >&5
2556   cat conftest.$ac_ext >&5
2557   rm -rf conftest*
2558   eval "ac_cv_header_$ac_safe=no"
2559 fi
2560 rm -f conftest*
2561 fi
2562 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
2563   echo "$ac_t""yes" 1>&6
2564   have_pthread_h=yes
2565 else
2566   echo "$ac_t""no" 1>&6
2567 have_pthread_h=
2568 fi
2569
2570       THREADLIBS=-lpthread
2571       THREADSPEC=-lpthread
2572                   THREADH=threads-posix.h
2573       ;;
2574     none)
2575                   THREADH=threads-no.h
2576       ;;
2577   esac
2578
2579
2580
2581
2582
2583
2584 #GLIBCPP_ENABLE_RELIBGCC([../..])
2585 # Check whether --enable-cxx-flags or --disable-cxx-flags was given.
2586 if test "${enable_cxx_flags+set}" = set; then
2587   enableval="$enable_cxx_flags"
2588   case "x$enableval" in
2589  xyes)   { echo "configure: error: --enable-cxx-flags needs compiler flags as arguments" 1>&2; exit 1; } ;;
2590  xno|x)  enable_cxx_flags='' ;;
2591  *)      enable_cxx_flags="$enableval" ;;
2592  esac
2593 else
2594   enable_cxx_flags='none'
2595 fi
2596 if test "$enable_cxx_flags" = "none"; then enable_cxx_flags=''; fi
2597 if test -n "$enable_cxx_flags"; then
2598     for f in $enable_cxx_flags; do
2599         case "$f" in
2600             -fhonor-std)  ;;
2601             -*)  ;;
2602             *)   # and we're trying to pass /what/ exactly?
2603                  { echo "configure: error: compiler flags start with a -" 1>&2; exit 1; } ;;
2604         esac
2605     done
2606 fi
2607 EXTRA_CXX_FLAGS="$enable_cxx_flags"
2608
2609
2610
2611
2612 if test -n "$with_cross_host"; then
2613
2614   # We are being configured with a cross compiler.  AC_REPLACE_FUNCS
2615   # may not work correctly, because the compiler may not be able to
2616   # link executables.
2617
2618   xcompiling=1
2619   NATIVE=no
2620   # If Canadian cross, then don't pick up tools from the build
2621   # directory.
2622   if test "$build" != "$with_cross_host"; then
2623     CANADIAN=yes
2624     NULL_TARGET=yes
2625   else
2626     CANADIAN=no
2627     NULL_TARGET=no
2628   fi
2629
2630   case "$target_alias" in
2631     *-wince-*)
2632         # Configure for Microsoft Windows CE, or whatever they are
2633         # currently calling it.
2634         cat >> confdefs.h <<\EOF
2635 #define HAVE_FLOAT_H 1
2636 EOF
2637
2638
2639         cat >> confdefs.h <<\EOF
2640 #define HAVE__FINITE 1
2641 EOF
2642
2643         cat >> confdefs.h <<\EOF
2644 #define HAVE__ISNAN 1
2645 EOF
2646
2647         cat >> confdefs.h <<\EOF
2648 #define HAVE__COPYSIGN 1
2649 EOF
2650
2651         cat >> confdefs.h <<\EOF
2652 #define HAVE__FPCLASS 1
2653 EOF
2654
2655         cat >> confdefs.h <<\EOF
2656 #define HAVE_MODF 1
2657 EOF
2658
2659
2660         ctype_include_dir="config/wince"
2661
2662
2663         cat >> confdefs.h <<\EOF
2664 #define _GLIBCPP_NEED_MBSTATE_T 1
2665 EOF
2666
2667
2668         cat >> confdefs.h <<\EOF
2669 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
2670 EOF
2671
2672         cat >> confdefs.h <<\EOF
2673 #define _GLIBCPP_BUGGY_COMPLEX 1
2674 EOF
2675
2676         ;;
2677     *)
2678         # We assume newlib.  This lets us hard-code the functions we know
2679         # we'll have.
2680         cat >> confdefs.h <<\EOF
2681 #define HAVE_FINITE 1
2682 EOF
2683
2684         cat >> confdefs.h <<\EOF
2685 #define HAVE_ISNAN 1
2686 EOF
2687
2688         cat >> confdefs.h <<\EOF
2689 #define HAVE_ISNANF 1
2690 EOF
2691
2692         cat >> confdefs.h <<\EOF
2693 #define HAVE_ISINF 1
2694 EOF
2695
2696         cat >> confdefs.h <<\EOF
2697 #define HAVE_ISINFF 1
2698 EOF
2699
2700
2701         ctype_include_dir="config/newlib"
2702
2703
2704         cat >> confdefs.h <<\EOF
2705 #define _GLIBCPP_NEED_MBSTATE_T 1
2706 EOF
2707
2708
2709         cat >> confdefs.h <<\EOF
2710 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
2711 EOF
2712
2713         cat >> confdefs.h <<\EOF
2714 #define _GLIBCPP_BUGGY_COMPLEX 1
2715 EOF
2716
2717         # need to ceck for faster f versions of math functions, ie sinf?
2718         ;;
2719   esac
2720 else
2721
2722   # We are being configured natively. We can do more elaborate tests
2723   # that include AC_TRY_COMPILE now, as the linker is assumed to be
2724   # working.
2725
2726   xcompiling=0
2727   NATIVE=yes
2728   CANADIAN=no
2729   NULL_TARGET=no
2730
2731   # Check for available headers.
2732   for ac_hdr in nan.h ieeefp.h endian.h sys/isa_defs.h machine/endian.h \
2733   machine/param.h sys/machine.h fp.h locale.h float.h inttypes.h
2734 do
2735 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
2736 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
2737 echo "configure:2738: checking for $ac_hdr" >&5
2738 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
2739   echo $ac_n "(cached) $ac_c" 1>&6
2740 else
2741   cat > conftest.$ac_ext <<EOF
2742 #line 2743 "configure"
2743 #include "confdefs.h"
2744 #include <$ac_hdr>
2745 EOF
2746 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2747 { (eval echo configure:2748: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2748 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2749 if test -z "$ac_err"; then
2750   rm -rf conftest*
2751   eval "ac_cv_header_$ac_safe=yes"
2752 else
2753   echo "$ac_err" >&5
2754   echo "configure: failed program was:" >&5
2755   cat conftest.$ac_ext >&5
2756   rm -rf conftest*
2757   eval "ac_cv_header_$ac_safe=no"
2758 fi
2759 rm -f conftest*
2760 fi
2761 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
2762   echo "$ac_t""yes" 1>&6
2763     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
2764   cat >> confdefs.h <<EOF
2765 #define $ac_tr_hdr 1
2766 EOF
2767
2768 else
2769   echo "$ac_t""no" 1>&6
2770 fi
2771 done
2772
2773
2774
2775   # All these tests are for C++; save the language and the compiler flags.
2776   # The CXXFLAGS thing is suspicious, but based on similar bits
2777   # found in GLIBCPP_CONFIGURE.
2778
2779   ac_ext=C
2780 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2781 ac_cpp='$CXXCPP $CPPFLAGS'
2782 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2783 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2784 cross_compiling=$ac_cv_prog_cxx_cross
2785
2786   ac_test_CXXFLAGS="${CXXFLAGS+set}"
2787   ac_save_CXXFLAGS="$CXXFLAGS"
2788   WERROR='-Werror'
2789
2790   # Check for pragma system_header.
2791   echo $ac_n "checking for g++ that supports pragma system_header""... $ac_c" 1>&6
2792 echo "configure:2793: checking for g++ that supports pragma system_header" >&5
2793   CXXFLAGS='-Wunknown-pragmas -Werror'
2794   cat > conftest.$ac_ext <<EOF
2795 #line 2796 "configure"
2796 #include "confdefs.h"
2797 #pragma system_header
2798 int main() {
2799 int foo;
2800
2801 ; return 0; }
2802 EOF
2803 if { (eval echo configure:2804: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2804   rm -rf conftest*
2805   ac_newpragma=yes
2806 else
2807   echo "configure: failed program was:" >&5
2808   cat conftest.$ac_ext >&5
2809   rm -rf conftest*
2810   ac_newpragma=no
2811 fi
2812 rm -f conftest*
2813   if test "$ac_test_CXXFLAGS" = set; then
2814     CXXFLAGS="$ac_save_CXXFLAGS"
2815   else
2816     # this is the suspicious part
2817     CXXFLAGS=''
2818   fi
2819   if test "$ac_newpragma" = "no"; then
2820     WERROR="$WERROR -Wno-unknown-pragmas"
2821   fi
2822   echo "$ac_t""$ac_newpragma" 1>&6
2823
2824   # Check for more sophisticated diagnostic control.
2825   echo $ac_n "checking for g++ that supports -fdiagnostics-show-location=once""... $ac_c" 1>&6
2826 echo "configure:2827: checking for g++ that supports -fdiagnostics-show-location=once" >&5
2827   CXXFLAGS='-fdiagnostics-show-location=once'
2828   cat > conftest.$ac_ext <<EOF
2829 #line 2830 "configure"
2830 #include "confdefs.h"
2831
2832 int main() {
2833 int foo;
2834
2835 ; return 0; }
2836 EOF
2837 if { (eval echo configure:2838: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2838   rm -rf conftest*
2839   ac_gabydiags=yes
2840 else
2841   echo "configure: failed program was:" >&5
2842   cat conftest.$ac_ext >&5
2843   rm -rf conftest*
2844   ac_gabydiags=no
2845 fi
2846 rm -f conftest*
2847   if test "$ac_test_CXXFLAGS" = set; then
2848     CXXFLAGS="$ac_save_CXXFLAGS"
2849   else
2850     # this is the suspicious part
2851     CXXFLAGS=''
2852   fi
2853   if test "$ac_gabydiags" = "yes"; then
2854     WFMT_FLAGS='-fdiagnostics-show-location=once'
2855   fi
2856   echo "$ac_t""$ac_gabydiags" 1>&6
2857
2858   # Check for -ffunction-sections -fdata-sections
2859   echo $ac_n "checking for g++ that supports -ffunction-sections -fdata-sections""... $ac_c" 1>&6
2860 echo "configure:2861: checking for g++ that supports -ffunction-sections -fdata-sections" >&5
2861   CXXFLAGS='-ffunction-sections -fdata-sections'
2862   cat > conftest.$ac_ext <<EOF
2863 #line 2864 "configure"
2864 #include "confdefs.h"
2865
2866 int main() {
2867 int foo;
2868
2869 ; return 0; }
2870 EOF
2871 if { (eval echo configure:2872: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2872   rm -rf conftest*
2873   ac_fdsections=yes
2874 else
2875   echo "configure: failed program was:" >&5
2876   cat conftest.$ac_ext >&5
2877   rm -rf conftest*
2878   ac_fdsections=no
2879 fi
2880 rm -f conftest*
2881   if test "$ac_test_CXXFLAGS" = set; then
2882     CXXFLAGS="$ac_save_CXXFLAGS"
2883   else
2884     # this is the suspicious part
2885     CXXFLAGS=''
2886   fi
2887   if test "$ac_fdsections" = "yes"; then
2888     SECTION_FLAGS='-ffunction-sections -fdata-sections'
2889   fi
2890   echo "$ac_t""$ac_fdsections" 1>&6
2891
2892   ac_ext=c
2893 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2894 ac_cpp='$CPP $CPPFLAGS'
2895 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2896 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2897 cross_compiling=$ac_cv_prog_cc_cross
2898
2899
2900
2901
2902
2903
2904   # All these tests are for C++; save the language and the compiler flags.
2905   # Need to do this so that g++ won't try to link in libstdc++
2906   ac_test_CFLAGS="${CFLAGS+set}"
2907   ac_save_CFLAGS="$CFLAGS"
2908   CFLAGS='-x c++  -Wl,--gc-sections'
2909
2910   # Check for -Wl,--gc-sections
2911   echo $ac_n "checking for ld that supports -Wl,--gc-sections""... $ac_c" 1>&6
2912 echo "configure:2913: checking for ld that supports -Wl,--gc-sections" >&5
2913   if test "$cross_compiling" = yes; then
2914   ac_sectionLDflags=yes
2915 else
2916   cat > conftest.$ac_ext <<EOF
2917 #line 2918 "configure"
2918 #include "confdefs.h"
2919
2920    int main(void)
2921    {
2922      try { throw 1; }
2923      catch (...) { };
2924      return 0;
2925    }
2926
2927 EOF
2928 if { (eval echo configure:2929: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
2929 then
2930   ac_sectionLDflags=yes
2931 else
2932   echo "configure: failed program was:" >&5
2933   cat conftest.$ac_ext >&5
2934   rm -fr conftest*
2935   ac_sectionLFflags=no
2936 fi
2937 rm -fr conftest*
2938 fi
2939
2940   if test "$ac_test_CFLAGS" = set; then
2941     CFLAGS="$ac_save_CFLAGS"
2942   else
2943     # this is the suspicious part
2944     CFLAGS=''
2945   fi
2946   if test "$ac_sectionLDflags" = "yes"; then
2947     SECTION_LDFLAGS='-Wl,--gc-sections'
2948   fi
2949   echo "$ac_t""$ac_sectionLDflags" 1>&6
2950
2951
2952
2953
2954
2955
2956   ac_ext=C
2957 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2958 ac_cpp='$CXXCPP $CPPFLAGS'
2959 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2960 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2961 cross_compiling=$ac_cv_prog_cxx_cross
2962
2963   echo $ac_n "checking for __builtin_abs declaration""... $ac_c" 1>&6
2964 echo "configure:2965: checking for __builtin_abs declaration" >&5
2965   cat > conftest.$ac_ext <<EOF
2966 #line 2967 "configure"
2967 #include "confdefs.h"
2968 #include <math.h>
2969 int main() {
2970  __builtin_abs(0);
2971 ; return 0; }
2972 EOF
2973 if { (eval echo configure:2974: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2974   rm -rf conftest*
2975   use___builtin_abs=yes
2976 else
2977   echo "configure: failed program was:" >&5
2978   cat conftest.$ac_ext >&5
2979   rm -rf conftest*
2980   use___builtin_abs=no
2981 fi
2982 rm -f conftest*
2983   echo "$ac_t""$use___builtin_abs" 1>&6
2984   ac_ext=c
2985 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2986 ac_cpp='$CPP $CPPFLAGS'
2987 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2988 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2989 cross_compiling=$ac_cv_prog_cc_cross
2990
2991   if test x$use___builtin_abs = x"yes"; then
2992     echo $ac_n "checking for __builtin_abs linkage""... $ac_c" 1>&6
2993 echo "configure:2994: checking for __builtin_abs linkage" >&5
2994       cat > conftest.$ac_ext <<EOF
2995 #line 2996 "configure"
2996 #include "confdefs.h"
2997 #include <math.h>
2998 int main() {
2999  __builtin_abs(0);
3000 ; return 0; }
3001 EOF
3002 if { (eval echo configure:3003: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3003   rm -rf conftest*
3004   link___builtin_abs=yes
3005 else
3006   echo "configure: failed program was:" >&5
3007   cat conftest.$ac_ext >&5
3008   rm -rf conftest*
3009   link___builtin_abs=no
3010 fi
3011 rm -f conftest*
3012     echo "$ac_t""$link___builtin_abs" 1>&6
3013     if test x$link___builtin_abs = x"yes"; then
3014       ac_tr_func=HAVE_`echo __builtin_abs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3015       cat >> confdefs.h <<EOF
3016 #define ${ac_tr_func} 1
3017 EOF
3018
3019     fi
3020   fi
3021
3022
3023
3024   ac_ext=C
3025 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3026 ac_cpp='$CXXCPP $CPPFLAGS'
3027 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3028 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3029 cross_compiling=$ac_cv_prog_cxx_cross
3030
3031   echo $ac_n "checking for __builtin_fabsf declaration""... $ac_c" 1>&6
3032 echo "configure:3033: checking for __builtin_fabsf declaration" >&5
3033   cat > conftest.$ac_ext <<EOF
3034 #line 3035 "configure"
3035 #include "confdefs.h"
3036 #include <math.h>
3037 int main() {
3038  __builtin_fabsf(0);
3039 ; return 0; }
3040 EOF
3041 if { (eval echo configure:3042: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3042   rm -rf conftest*
3043   use___builtin_fabsf=yes
3044 else
3045   echo "configure: failed program was:" >&5
3046   cat conftest.$ac_ext >&5
3047   rm -rf conftest*
3048   use___builtin_fabsf=no
3049 fi
3050 rm -f conftest*
3051   echo "$ac_t""$use___builtin_fabsf" 1>&6
3052   ac_ext=c
3053 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3054 ac_cpp='$CPP $CPPFLAGS'
3055 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3056 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3057 cross_compiling=$ac_cv_prog_cc_cross
3058
3059   if test x$use___builtin_fabsf = x"yes"; then
3060     echo $ac_n "checking for __builtin_fabsf linkage""... $ac_c" 1>&6
3061 echo "configure:3062: checking for __builtin_fabsf linkage" >&5
3062       cat > conftest.$ac_ext <<EOF
3063 #line 3064 "configure"
3064 #include "confdefs.h"
3065 #include <math.h>
3066 int main() {
3067  __builtin_fabsf(0);
3068 ; return 0; }
3069 EOF
3070 if { (eval echo configure:3071: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3071   rm -rf conftest*
3072   link___builtin_fabsf=yes
3073 else
3074   echo "configure: failed program was:" >&5
3075   cat conftest.$ac_ext >&5
3076   rm -rf conftest*
3077   link___builtin_fabsf=no
3078 fi
3079 rm -f conftest*
3080     echo "$ac_t""$link___builtin_fabsf" 1>&6
3081     if test x$link___builtin_fabsf = x"yes"; then
3082       ac_tr_func=HAVE_`echo __builtin_fabsf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3083       cat >> confdefs.h <<EOF
3084 #define ${ac_tr_func} 1
3085 EOF
3086
3087     fi
3088   fi
3089
3090
3091
3092   ac_ext=C
3093 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3094 ac_cpp='$CXXCPP $CPPFLAGS'
3095 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3096 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3097 cross_compiling=$ac_cv_prog_cxx_cross
3098
3099   echo $ac_n "checking for __builtin_fabs declaration""... $ac_c" 1>&6
3100 echo "configure:3101: checking for __builtin_fabs declaration" >&5
3101   cat > conftest.$ac_ext <<EOF
3102 #line 3103 "configure"
3103 #include "confdefs.h"
3104 #include <math.h>
3105 int main() {
3106  __builtin_fabs(0);
3107 ; return 0; }
3108 EOF
3109 if { (eval echo configure:3110: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3110   rm -rf conftest*
3111   use___builtin_fabs=yes
3112 else
3113   echo "configure: failed program was:" >&5
3114   cat conftest.$ac_ext >&5
3115   rm -rf conftest*
3116   use___builtin_fabs=no
3117 fi
3118 rm -f conftest*
3119   echo "$ac_t""$use___builtin_fabs" 1>&6
3120   ac_ext=c
3121 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3122 ac_cpp='$CPP $CPPFLAGS'
3123 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3124 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3125 cross_compiling=$ac_cv_prog_cc_cross
3126
3127   if test x$use___builtin_fabs = x"yes"; then
3128     echo $ac_n "checking for __builtin_fabs linkage""... $ac_c" 1>&6
3129 echo "configure:3130: checking for __builtin_fabs linkage" >&5
3130       cat > conftest.$ac_ext <<EOF
3131 #line 3132 "configure"
3132 #include "confdefs.h"
3133 #include <math.h>
3134 int main() {
3135  __builtin_fabs(0);
3136 ; return 0; }
3137 EOF
3138 if { (eval echo configure:3139: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3139   rm -rf conftest*
3140   link___builtin_fabs=yes
3141 else
3142   echo "configure: failed program was:" >&5
3143   cat conftest.$ac_ext >&5
3144   rm -rf conftest*
3145   link___builtin_fabs=no
3146 fi
3147 rm -f conftest*
3148     echo "$ac_t""$link___builtin_fabs" 1>&6
3149     if test x$link___builtin_fabs = x"yes"; then
3150       ac_tr_func=HAVE_`echo __builtin_fabs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3151       cat >> confdefs.h <<EOF
3152 #define ${ac_tr_func} 1
3153 EOF
3154
3155     fi
3156   fi
3157
3158
3159
3160   ac_ext=C
3161 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3162 ac_cpp='$CXXCPP $CPPFLAGS'
3163 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3164 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3165 cross_compiling=$ac_cv_prog_cxx_cross
3166
3167   echo $ac_n "checking for __builtin_fabsl declaration""... $ac_c" 1>&6
3168 echo "configure:3169: checking for __builtin_fabsl declaration" >&5
3169   cat > conftest.$ac_ext <<EOF
3170 #line 3171 "configure"
3171 #include "confdefs.h"
3172 #include <math.h>
3173 int main() {
3174  __builtin_fabsl(0);
3175 ; return 0; }
3176 EOF
3177 if { (eval echo configure:3178: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3178   rm -rf conftest*
3179   use___builtin_fabsl=yes
3180 else
3181   echo "configure: failed program was:" >&5
3182   cat conftest.$ac_ext >&5
3183   rm -rf conftest*
3184   use___builtin_fabsl=no
3185 fi
3186 rm -f conftest*
3187   echo "$ac_t""$use___builtin_fabsl" 1>&6
3188   ac_ext=c
3189 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3190 ac_cpp='$CPP $CPPFLAGS'
3191 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3192 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3193 cross_compiling=$ac_cv_prog_cc_cross
3194
3195   if test x$use___builtin_fabsl = x"yes"; then
3196     echo $ac_n "checking for __builtin_fabsl linkage""... $ac_c" 1>&6
3197 echo "configure:3198: checking for __builtin_fabsl linkage" >&5
3198       cat > conftest.$ac_ext <<EOF
3199 #line 3200 "configure"
3200 #include "confdefs.h"
3201 #include <math.h>
3202 int main() {
3203  __builtin_fabsl(0);
3204 ; return 0; }
3205 EOF
3206 if { (eval echo configure:3207: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3207   rm -rf conftest*
3208   link___builtin_fabsl=yes
3209 else
3210   echo "configure: failed program was:" >&5
3211   cat conftest.$ac_ext >&5
3212   rm -rf conftest*
3213   link___builtin_fabsl=no
3214 fi
3215 rm -f conftest*
3216     echo "$ac_t""$link___builtin_fabsl" 1>&6
3217     if test x$link___builtin_fabsl = x"yes"; then
3218       ac_tr_func=HAVE_`echo __builtin_fabsl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3219       cat >> confdefs.h <<EOF
3220 #define ${ac_tr_func} 1
3221 EOF
3222
3223     fi
3224   fi
3225
3226
3227
3228   ac_ext=C
3229 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3230 ac_cpp='$CXXCPP $CPPFLAGS'
3231 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3232 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3233 cross_compiling=$ac_cv_prog_cxx_cross
3234
3235   echo $ac_n "checking for __builtin_labs declaration""... $ac_c" 1>&6
3236 echo "configure:3237: checking for __builtin_labs declaration" >&5
3237   cat > conftest.$ac_ext <<EOF
3238 #line 3239 "configure"
3239 #include "confdefs.h"
3240 #include <math.h>
3241 int main() {
3242  __builtin_labs(0);
3243 ; return 0; }
3244 EOF
3245 if { (eval echo configure:3246: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3246   rm -rf conftest*
3247   use___builtin_labs=yes
3248 else
3249   echo "configure: failed program was:" >&5
3250   cat conftest.$ac_ext >&5
3251   rm -rf conftest*
3252   use___builtin_labs=no
3253 fi
3254 rm -f conftest*
3255   echo "$ac_t""$use___builtin_labs" 1>&6
3256   ac_ext=c
3257 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3258 ac_cpp='$CPP $CPPFLAGS'
3259 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3260 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3261 cross_compiling=$ac_cv_prog_cc_cross
3262
3263   if test x$use___builtin_labs = x"yes"; then
3264     echo $ac_n "checking for __builtin_labs linkage""... $ac_c" 1>&6
3265 echo "configure:3266: checking for __builtin_labs linkage" >&5
3266       cat > conftest.$ac_ext <<EOF
3267 #line 3268 "configure"
3268 #include "confdefs.h"
3269 #include <math.h>
3270 int main() {
3271  __builtin_labs(0);
3272 ; return 0; }
3273 EOF
3274 if { (eval echo configure:3275: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3275   rm -rf conftest*
3276   link___builtin_labs=yes
3277 else
3278   echo "configure: failed program was:" >&5
3279   cat conftest.$ac_ext >&5
3280   rm -rf conftest*
3281   link___builtin_labs=no
3282 fi
3283 rm -f conftest*
3284     echo "$ac_t""$link___builtin_labs" 1>&6
3285     if test x$link___builtin_labs = x"yes"; then
3286       ac_tr_func=HAVE_`echo __builtin_labs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3287       cat >> confdefs.h <<EOF
3288 #define ${ac_tr_func} 1
3289 EOF
3290
3291     fi
3292   fi
3293
3294
3295
3296
3297   ac_ext=C
3298 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3299 ac_cpp='$CXXCPP $CPPFLAGS'
3300 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3301 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3302 cross_compiling=$ac_cv_prog_cxx_cross
3303
3304   echo $ac_n "checking for __builtin_sqrtf declaration""... $ac_c" 1>&6
3305 echo "configure:3306: checking for __builtin_sqrtf declaration" >&5
3306   cat > conftest.$ac_ext <<EOF
3307 #line 3308 "configure"
3308 #include "confdefs.h"
3309 #include <math.h>
3310 int main() {
3311  __builtin_sqrtf(0);
3312 ; return 0; }
3313 EOF
3314 if { (eval echo configure:3315: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3315   rm -rf conftest*
3316   use___builtin_sqrtf=yes
3317 else
3318   echo "configure: failed program was:" >&5
3319   cat conftest.$ac_ext >&5
3320   rm -rf conftest*
3321   use___builtin_sqrtf=no
3322 fi
3323 rm -f conftest*
3324   echo "$ac_t""$use___builtin_sqrtf" 1>&6
3325   ac_ext=c
3326 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3327 ac_cpp='$CPP $CPPFLAGS'
3328 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3329 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3330 cross_compiling=$ac_cv_prog_cc_cross
3331
3332   if test x$use___builtin_sqrtf = x"yes"; then
3333     echo $ac_n "checking for __builtin_sqrtf linkage""... $ac_c" 1>&6
3334 echo "configure:3335: checking for __builtin_sqrtf linkage" >&5
3335       cat > conftest.$ac_ext <<EOF
3336 #line 3337 "configure"
3337 #include "confdefs.h"
3338 #include <math.h>
3339 int main() {
3340  __builtin_sqrtf(0);
3341 ; return 0; }
3342 EOF
3343 if { (eval echo configure:3344: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3344   rm -rf conftest*
3345   link___builtin_sqrtf=yes
3346 else
3347   echo "configure: failed program was:" >&5
3348   cat conftest.$ac_ext >&5
3349   rm -rf conftest*
3350   link___builtin_sqrtf=no
3351 fi
3352 rm -f conftest*
3353     echo "$ac_t""$link___builtin_sqrtf" 1>&6
3354     if test x$link___builtin_sqrtf = x"yes"; then
3355       ac_tr_func=HAVE_`echo __builtin_sqrtf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3356       cat >> confdefs.h <<EOF
3357 #define ${ac_tr_func} 1
3358 EOF
3359
3360     fi
3361   fi
3362
3363
3364
3365   ac_ext=C
3366 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3367 ac_cpp='$CXXCPP $CPPFLAGS'
3368 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3369 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3370 cross_compiling=$ac_cv_prog_cxx_cross
3371
3372   echo $ac_n "checking for __builtin_fsqrt declaration""... $ac_c" 1>&6
3373 echo "configure:3374: checking for __builtin_fsqrt declaration" >&5
3374   cat > conftest.$ac_ext <<EOF
3375 #line 3376 "configure"
3376 #include "confdefs.h"
3377 #include <math.h>
3378 int main() {
3379  __builtin_fsqrt(0);
3380 ; return 0; }
3381 EOF
3382 if { (eval echo configure:3383: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3383   rm -rf conftest*
3384   use___builtin_fsqrt=yes
3385 else
3386   echo "configure: failed program was:" >&5
3387   cat conftest.$ac_ext >&5
3388   rm -rf conftest*
3389   use___builtin_fsqrt=no
3390 fi
3391 rm -f conftest*
3392   echo "$ac_t""$use___builtin_fsqrt" 1>&6
3393   ac_ext=c
3394 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3395 ac_cpp='$CPP $CPPFLAGS'
3396 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3397 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3398 cross_compiling=$ac_cv_prog_cc_cross
3399
3400   if test x$use___builtin_fsqrt = x"yes"; then
3401     echo $ac_n "checking for __builtin_fsqrt linkage""... $ac_c" 1>&6
3402 echo "configure:3403: checking for __builtin_fsqrt linkage" >&5
3403       cat > conftest.$ac_ext <<EOF
3404 #line 3405 "configure"
3405 #include "confdefs.h"
3406 #include <math.h>
3407 int main() {
3408  __builtin_fsqrt(0);
3409 ; return 0; }
3410 EOF
3411 if { (eval echo configure:3412: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3412   rm -rf conftest*
3413   link___builtin_fsqrt=yes
3414 else
3415   echo "configure: failed program was:" >&5
3416   cat conftest.$ac_ext >&5
3417   rm -rf conftest*
3418   link___builtin_fsqrt=no
3419 fi
3420 rm -f conftest*
3421     echo "$ac_t""$link___builtin_fsqrt" 1>&6
3422     if test x$link___builtin_fsqrt = x"yes"; then
3423       ac_tr_func=HAVE_`echo __builtin_fsqrt | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3424       cat >> confdefs.h <<EOF
3425 #define ${ac_tr_func} 1
3426 EOF
3427
3428     fi
3429   fi
3430
3431
3432
3433   ac_ext=C
3434 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3435 ac_cpp='$CXXCPP $CPPFLAGS'
3436 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3437 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3438 cross_compiling=$ac_cv_prog_cxx_cross
3439
3440   echo $ac_n "checking for __builtin_sqrtl declaration""... $ac_c" 1>&6
3441 echo "configure:3442: checking for __builtin_sqrtl declaration" >&5
3442   cat > conftest.$ac_ext <<EOF
3443 #line 3444 "configure"
3444 #include "confdefs.h"
3445 #include <math.h>
3446 int main() {
3447  __builtin_sqrtl(0);
3448 ; return 0; }
3449 EOF
3450 if { (eval echo configure:3451: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3451   rm -rf conftest*
3452   use___builtin_sqrtl=yes
3453 else
3454   echo "configure: failed program was:" >&5
3455   cat conftest.$ac_ext >&5
3456   rm -rf conftest*
3457   use___builtin_sqrtl=no
3458 fi
3459 rm -f conftest*
3460   echo "$ac_t""$use___builtin_sqrtl" 1>&6
3461   ac_ext=c
3462 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3463 ac_cpp='$CPP $CPPFLAGS'
3464 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3465 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3466 cross_compiling=$ac_cv_prog_cc_cross
3467
3468   if test x$use___builtin_sqrtl = x"yes"; then
3469     echo $ac_n "checking for __builtin_sqrtl linkage""... $ac_c" 1>&6
3470 echo "configure:3471: checking for __builtin_sqrtl linkage" >&5
3471       cat > conftest.$ac_ext <<EOF
3472 #line 3473 "configure"
3473 #include "confdefs.h"
3474 #include <math.h>
3475 int main() {
3476  __builtin_sqrtl(0);
3477 ; return 0; }
3478 EOF
3479 if { (eval echo configure:3480: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3480   rm -rf conftest*
3481   link___builtin_sqrtl=yes
3482 else
3483   echo "configure: failed program was:" >&5
3484   cat conftest.$ac_ext >&5
3485   rm -rf conftest*
3486   link___builtin_sqrtl=no
3487 fi
3488 rm -f conftest*
3489     echo "$ac_t""$link___builtin_sqrtl" 1>&6
3490     if test x$link___builtin_sqrtl = x"yes"; then
3491       ac_tr_func=HAVE_`echo __builtin_sqrtl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3492       cat >> confdefs.h <<EOF
3493 #define ${ac_tr_func} 1
3494 EOF
3495
3496     fi
3497   fi
3498
3499
3500
3501
3502   ac_ext=C
3503 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3504 ac_cpp='$CXXCPP $CPPFLAGS'
3505 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3506 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3507 cross_compiling=$ac_cv_prog_cxx_cross
3508
3509   echo $ac_n "checking for __builtin_sinf declaration""... $ac_c" 1>&6
3510 echo "configure:3511: checking for __builtin_sinf declaration" >&5
3511   cat > conftest.$ac_ext <<EOF
3512 #line 3513 "configure"
3513 #include "confdefs.h"
3514 #include <math.h>
3515 int main() {
3516  __builtin_sinf(0);
3517 ; return 0; }
3518 EOF
3519 if { (eval echo configure:3520: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3520   rm -rf conftest*
3521   use___builtin_sinf=yes
3522 else
3523   echo "configure: failed program was:" >&5
3524   cat conftest.$ac_ext >&5
3525   rm -rf conftest*
3526   use___builtin_sinf=no
3527 fi
3528 rm -f conftest*
3529   echo "$ac_t""$use___builtin_sinf" 1>&6
3530   ac_ext=c
3531 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3532 ac_cpp='$CPP $CPPFLAGS'
3533 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3534 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3535 cross_compiling=$ac_cv_prog_cc_cross
3536
3537   if test x$use___builtin_sinf = x"yes"; then
3538     echo $ac_n "checking for __builtin_sinf linkage""... $ac_c" 1>&6
3539 echo "configure:3540: checking for __builtin_sinf linkage" >&5
3540       cat > conftest.$ac_ext <<EOF
3541 #line 3542 "configure"
3542 #include "confdefs.h"
3543 #include <math.h>
3544 int main() {
3545  __builtin_sinf(0);
3546 ; return 0; }
3547 EOF
3548 if { (eval echo configure:3549: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3549   rm -rf conftest*
3550   link___builtin_sinf=yes
3551 else
3552   echo "configure: failed program was:" >&5
3553   cat conftest.$ac_ext >&5
3554   rm -rf conftest*
3555   link___builtin_sinf=no
3556 fi
3557 rm -f conftest*
3558     echo "$ac_t""$link___builtin_sinf" 1>&6
3559     if test x$link___builtin_sinf = x"yes"; then
3560       ac_tr_func=HAVE_`echo __builtin_sinf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3561       cat >> confdefs.h <<EOF
3562 #define ${ac_tr_func} 1
3563 EOF
3564
3565     fi
3566   fi
3567
3568
3569
3570   ac_ext=C
3571 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3572 ac_cpp='$CXXCPP $CPPFLAGS'
3573 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3574 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3575 cross_compiling=$ac_cv_prog_cxx_cross
3576
3577   echo $ac_n "checking for __builtin_sin declaration""... $ac_c" 1>&6
3578 echo "configure:3579: checking for __builtin_sin declaration" >&5
3579   cat > conftest.$ac_ext <<EOF
3580 #line 3581 "configure"
3581 #include "confdefs.h"
3582 #include <math.h>
3583 int main() {
3584  __builtin_sin(0);
3585 ; return 0; }
3586 EOF
3587 if { (eval echo configure:3588: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3588   rm -rf conftest*
3589   use___builtin_sin=yes
3590 else
3591   echo "configure: failed program was:" >&5
3592   cat conftest.$ac_ext >&5
3593   rm -rf conftest*
3594   use___builtin_sin=no
3595 fi
3596 rm -f conftest*
3597   echo "$ac_t""$use___builtin_sin" 1>&6
3598   ac_ext=c
3599 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3600 ac_cpp='$CPP $CPPFLAGS'
3601 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3602 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3603 cross_compiling=$ac_cv_prog_cc_cross
3604
3605   if test x$use___builtin_sin = x"yes"; then
3606     echo $ac_n "checking for __builtin_sin linkage""... $ac_c" 1>&6
3607 echo "configure:3608: checking for __builtin_sin linkage" >&5
3608       cat > conftest.$ac_ext <<EOF
3609 #line 3610 "configure"
3610 #include "confdefs.h"
3611 #include <math.h>
3612 int main() {
3613  __builtin_sin(0);
3614 ; return 0; }
3615 EOF
3616 if { (eval echo configure:3617: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3617   rm -rf conftest*
3618   link___builtin_sin=yes
3619 else
3620   echo "configure: failed program was:" >&5
3621   cat conftest.$ac_ext >&5
3622   rm -rf conftest*
3623   link___builtin_sin=no
3624 fi
3625 rm -f conftest*
3626     echo "$ac_t""$link___builtin_sin" 1>&6
3627     if test x$link___builtin_sin = x"yes"; then
3628       ac_tr_func=HAVE_`echo __builtin_sin | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3629       cat >> confdefs.h <<EOF
3630 #define ${ac_tr_func} 1
3631 EOF
3632
3633     fi
3634   fi
3635
3636
3637
3638   ac_ext=C
3639 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3640 ac_cpp='$CXXCPP $CPPFLAGS'
3641 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3642 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3643 cross_compiling=$ac_cv_prog_cxx_cross
3644
3645   echo $ac_n "checking for __builtin_sinl declaration""... $ac_c" 1>&6
3646 echo "configure:3647: checking for __builtin_sinl declaration" >&5
3647   cat > conftest.$ac_ext <<EOF
3648 #line 3649 "configure"
3649 #include "confdefs.h"
3650 #include <math.h>
3651 int main() {
3652  __builtin_sinl(0);
3653 ; return 0; }
3654 EOF
3655 if { (eval echo configure:3656: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3656   rm -rf conftest*
3657   use___builtin_sinl=yes
3658 else
3659   echo "configure: failed program was:" >&5
3660   cat conftest.$ac_ext >&5
3661   rm -rf conftest*
3662   use___builtin_sinl=no
3663 fi
3664 rm -f conftest*
3665   echo "$ac_t""$use___builtin_sinl" 1>&6
3666   ac_ext=c
3667 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3668 ac_cpp='$CPP $CPPFLAGS'
3669 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3670 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3671 cross_compiling=$ac_cv_prog_cc_cross
3672
3673   if test x$use___builtin_sinl = x"yes"; then
3674     echo $ac_n "checking for __builtin_sinl linkage""... $ac_c" 1>&6
3675 echo "configure:3676: checking for __builtin_sinl linkage" >&5
3676       cat > conftest.$ac_ext <<EOF
3677 #line 3678 "configure"
3678 #include "confdefs.h"
3679 #include <math.h>
3680 int main() {
3681  __builtin_sinl(0);
3682 ; return 0; }
3683 EOF
3684 if { (eval echo configure:3685: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3685   rm -rf conftest*
3686   link___builtin_sinl=yes
3687 else
3688   echo "configure: failed program was:" >&5
3689   cat conftest.$ac_ext >&5
3690   rm -rf conftest*
3691   link___builtin_sinl=no
3692 fi
3693 rm -f conftest*
3694     echo "$ac_t""$link___builtin_sinl" 1>&6
3695     if test x$link___builtin_sinl = x"yes"; then
3696       ac_tr_func=HAVE_`echo __builtin_sinl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3697       cat >> confdefs.h <<EOF
3698 #define ${ac_tr_func} 1
3699 EOF
3700
3701     fi
3702   fi
3703
3704
3705
3706
3707   ac_ext=C
3708 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3709 ac_cpp='$CXXCPP $CPPFLAGS'
3710 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3711 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3712 cross_compiling=$ac_cv_prog_cxx_cross
3713
3714   echo $ac_n "checking for __builtin_cosf declaration""... $ac_c" 1>&6
3715 echo "configure:3716: checking for __builtin_cosf declaration" >&5
3716   cat > conftest.$ac_ext <<EOF
3717 #line 3718 "configure"
3718 #include "confdefs.h"
3719 #include <math.h>
3720 int main() {
3721  __builtin_cosf(0);
3722 ; return 0; }
3723 EOF
3724 if { (eval echo configure:3725: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3725   rm -rf conftest*
3726   use___builtin_cosf=yes
3727 else
3728   echo "configure: failed program was:" >&5
3729   cat conftest.$ac_ext >&5
3730   rm -rf conftest*
3731   use___builtin_cosf=no
3732 fi
3733 rm -f conftest*
3734   echo "$ac_t""$use___builtin_cosf" 1>&6
3735   ac_ext=c
3736 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3737 ac_cpp='$CPP $CPPFLAGS'
3738 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3739 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3740 cross_compiling=$ac_cv_prog_cc_cross
3741
3742   if test x$use___builtin_cosf = x"yes"; then
3743     echo $ac_n "checking for __builtin_cosf linkage""... $ac_c" 1>&6
3744 echo "configure:3745: checking for __builtin_cosf linkage" >&5
3745       cat > conftest.$ac_ext <<EOF
3746 #line 3747 "configure"
3747 #include "confdefs.h"
3748 #include <math.h>
3749 int main() {
3750  __builtin_cosf(0);
3751 ; return 0; }
3752 EOF
3753 if { (eval echo configure:3754: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3754   rm -rf conftest*
3755   link___builtin_cosf=yes
3756 else
3757   echo "configure: failed program was:" >&5
3758   cat conftest.$ac_ext >&5
3759   rm -rf conftest*
3760   link___builtin_cosf=no
3761 fi
3762 rm -f conftest*
3763     echo "$ac_t""$link___builtin_cosf" 1>&6
3764     if test x$link___builtin_cosf = x"yes"; then
3765       ac_tr_func=HAVE_`echo __builtin_cosf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3766       cat >> confdefs.h <<EOF
3767 #define ${ac_tr_func} 1
3768 EOF
3769
3770     fi
3771   fi
3772
3773
3774
3775   ac_ext=C
3776 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3777 ac_cpp='$CXXCPP $CPPFLAGS'
3778 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3779 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3780 cross_compiling=$ac_cv_prog_cxx_cross
3781
3782   echo $ac_n "checking for __builtin_cos declaration""... $ac_c" 1>&6
3783 echo "configure:3784: checking for __builtin_cos declaration" >&5
3784   cat > conftest.$ac_ext <<EOF
3785 #line 3786 "configure"
3786 #include "confdefs.h"
3787 #include <math.h>
3788 int main() {
3789  __builtin_cos(0);
3790 ; return 0; }
3791 EOF
3792 if { (eval echo configure:3793: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3793   rm -rf conftest*
3794   use___builtin_cos=yes
3795 else
3796   echo "configure: failed program was:" >&5
3797   cat conftest.$ac_ext >&5
3798   rm -rf conftest*
3799   use___builtin_cos=no
3800 fi
3801 rm -f conftest*
3802   echo "$ac_t""$use___builtin_cos" 1>&6
3803   ac_ext=c
3804 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3805 ac_cpp='$CPP $CPPFLAGS'
3806 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3807 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3808 cross_compiling=$ac_cv_prog_cc_cross
3809
3810   if test x$use___builtin_cos = x"yes"; then
3811     echo $ac_n "checking for __builtin_cos linkage""... $ac_c" 1>&6
3812 echo "configure:3813: checking for __builtin_cos linkage" >&5
3813       cat > conftest.$ac_ext <<EOF
3814 #line 3815 "configure"
3815 #include "confdefs.h"
3816 #include <math.h>
3817 int main() {
3818  __builtin_cos(0);
3819 ; return 0; }
3820 EOF
3821 if { (eval echo configure:3822: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3822   rm -rf conftest*
3823   link___builtin_cos=yes
3824 else
3825   echo "configure: failed program was:" >&5
3826   cat conftest.$ac_ext >&5
3827   rm -rf conftest*
3828   link___builtin_cos=no
3829 fi
3830 rm -f conftest*
3831     echo "$ac_t""$link___builtin_cos" 1>&6
3832     if test x$link___builtin_cos = x"yes"; then
3833       ac_tr_func=HAVE_`echo __builtin_cos | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3834       cat >> confdefs.h <<EOF
3835 #define ${ac_tr_func} 1
3836 EOF
3837
3838     fi
3839   fi
3840
3841
3842
3843   ac_ext=C
3844 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3845 ac_cpp='$CXXCPP $CPPFLAGS'
3846 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3847 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3848 cross_compiling=$ac_cv_prog_cxx_cross
3849
3850   echo $ac_n "checking for __builtin_cosl declaration""... $ac_c" 1>&6
3851 echo "configure:3852: checking for __builtin_cosl declaration" >&5
3852   cat > conftest.$ac_ext <<EOF
3853 #line 3854 "configure"
3854 #include "confdefs.h"
3855 #include <math.h>
3856 int main() {
3857  __builtin_cosl(0);
3858 ; return 0; }
3859 EOF
3860 if { (eval echo configure:3861: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3861   rm -rf conftest*
3862   use___builtin_cosl=yes
3863 else
3864   echo "configure: failed program was:" >&5
3865   cat conftest.$ac_ext >&5
3866   rm -rf conftest*
3867   use___builtin_cosl=no
3868 fi
3869 rm -f conftest*
3870   echo "$ac_t""$use___builtin_cosl" 1>&6
3871   ac_ext=c
3872 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3873 ac_cpp='$CPP $CPPFLAGS'
3874 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3875 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3876 cross_compiling=$ac_cv_prog_cc_cross
3877
3878   if test x$use___builtin_cosl = x"yes"; then
3879     echo $ac_n "checking for __builtin_cosl linkage""... $ac_c" 1>&6
3880 echo "configure:3881: checking for __builtin_cosl linkage" >&5
3881       cat > conftest.$ac_ext <<EOF
3882 #line 3883 "configure"
3883 #include "confdefs.h"
3884 #include <math.h>
3885 int main() {
3886  __builtin_cosl(0);
3887 ; return 0; }
3888 EOF
3889 if { (eval echo configure:3890: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3890   rm -rf conftest*
3891   link___builtin_cosl=yes
3892 else
3893   echo "configure: failed program was:" >&5
3894   cat conftest.$ac_ext >&5
3895   rm -rf conftest*
3896   link___builtin_cosl=no
3897 fi
3898 rm -f conftest*
3899     echo "$ac_t""$link___builtin_cosl" 1>&6
3900     if test x$link___builtin_cosl = x"yes"; then
3901       ac_tr_func=HAVE_`echo __builtin_cosl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3902       cat >> confdefs.h <<EOF
3903 #define ${ac_tr_func} 1
3904 EOF
3905
3906     fi
3907   fi
3908
3909
3910               dummyvar=no
3911   if test x$dummyvar = x"yes"; then
3912     cat >> confdefs.h <<\EOF
3913 #define HAVE___BUILTIN_ABS 1
3914 EOF
3915
3916     cat >> confdefs.h <<\EOF
3917 #define HAVE___BUILTIN_LABS 1
3918 EOF
3919
3920     cat >> confdefs.h <<\EOF
3921 #define HAVE___BUILTIN_COS 1
3922 EOF
3923
3924     cat >> confdefs.h <<\EOF
3925 #define HAVE___BUILTIN_COSF 1
3926 EOF
3927
3928     cat >> confdefs.h <<\EOF
3929 #define HAVE___BUILTIN_COSL 1
3930 EOF
3931
3932     cat >> confdefs.h <<\EOF
3933 #define HAVE___BUILTIN_FABS 1
3934 EOF
3935
3936     cat >> confdefs.h <<\EOF
3937 #define HAVE___BUILTIN_FABSF 1
3938 EOF
3939
3940     cat >> confdefs.h <<\EOF
3941 #define HAVE___BUILTIN_FABSL 1
3942 EOF
3943
3944     cat >> confdefs.h <<\EOF
3945 #define HAVE___BUILTIN_SIN 1
3946 EOF
3947
3948     cat >> confdefs.h <<\EOF
3949 #define HAVE___BUILTIN_SINF 1
3950 EOF
3951
3952     cat >> confdefs.h <<\EOF
3953 #define HAVE___BUILTIN_SINL 1
3954 EOF
3955
3956     cat >> confdefs.h <<\EOF
3957 #define HAVE___BUILTIN_FSQRT 1
3958 EOF
3959
3960     cat >> confdefs.h <<\EOF
3961 #define HAVE___BUILTIN_SQRTF 1
3962 EOF
3963
3964     cat >> confdefs.h <<\EOF
3965 #define HAVE___BUILTIN_SQRTL 1
3966 EOF
3967
3968   fi
3969
3970
3971   ac_test_CXXFLAGS="${CXXFLAGS+set}"
3972   ac_save_CXXFLAGS="$CXXFLAGS"
3973   CXXFLAGS='-fno-builtins'
3974
3975     echo $ac_n "checking for sin in -lm""... $ac_c" 1>&6
3976 echo "configure:3977: checking for sin in -lm" >&5
3977 ac_lib_var=`echo m'_'sin | sed 'y%./+-%__p_%'`
3978 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
3979   echo $ac_n "(cached) $ac_c" 1>&6
3980 else
3981   ac_save_LIBS="$LIBS"
3982 LIBS="-lm  $LIBS"
3983 cat > conftest.$ac_ext <<EOF
3984 #line 3985 "configure"
3985 #include "confdefs.h"
3986 /* Override any gcc2 internal prototype to avoid an error.  */
3987 /* We use char because int might match the return type of a gcc2
3988     builtin and then its argument prototype would still apply.  */
3989 char sin();
3990
3991 int main() {
3992 sin()
3993 ; return 0; }
3994 EOF
3995 if { (eval echo configure:3996: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3996   rm -rf conftest*
3997   eval "ac_cv_lib_$ac_lib_var=yes"
3998 else
3999   echo "configure: failed program was:" >&5
4000   cat conftest.$ac_ext >&5
4001   rm -rf conftest*
4002   eval "ac_cv_lib_$ac_lib_var=no"
4003 fi
4004 rm -f conftest*
4005 LIBS="$ac_save_LIBS"
4006
4007 fi
4008 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
4009   echo "$ac_t""yes" 1>&6
4010   libm="-lm"
4011 else
4012   echo "$ac_t""no" 1>&6
4013 fi
4014
4015   ac_save_LIBS="$LIBS"
4016   LIBS="$LIBS $libm"
4017
4018     for ac_func in strtof strtold
4019 do
4020 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4021 echo "configure:4022: checking for $ac_func" >&5
4022 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4023   echo $ac_n "(cached) $ac_c" 1>&6
4024 else
4025   cat > conftest.$ac_ext <<EOF
4026 #line 4027 "configure"
4027 #include "confdefs.h"
4028 /* System header to define __stub macros and hopefully few prototypes,
4029     which can conflict with char $ac_func(); below.  */
4030 #include <assert.h>
4031 /* Override any gcc2 internal prototype to avoid an error.  */
4032 /* We use char because int might match the return type of a gcc2
4033     builtin and then its argument prototype would still apply.  */
4034 char $ac_func();
4035
4036 int main() {
4037
4038 /* The GNU C library defines this for functions which it implements
4039     to always fail with ENOSYS.  Some functions are actually named
4040     something starting with __ and the normal name is an alias.  */
4041 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4042 choke me
4043 #else
4044 $ac_func();
4045 #endif
4046
4047 ; return 0; }
4048 EOF
4049 if { (eval echo configure:4050: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4050   rm -rf conftest*
4051   eval "ac_cv_func_$ac_func=yes"
4052 else
4053   echo "configure: failed program was:" >&5
4054   cat conftest.$ac_ext >&5
4055   rm -rf conftest*
4056   eval "ac_cv_func_$ac_func=no"
4057 fi
4058 rm -f conftest*
4059 fi
4060
4061 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4062   echo "$ac_t""yes" 1>&6
4063     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4064   cat >> confdefs.h <<EOF
4065 #define $ac_tr_func 1
4066 EOF
4067
4068 else
4069   echo "$ac_t""no" 1>&6
4070 fi
4071 done
4072
4073
4074
4075
4076   ac_ext=C
4077 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4078 ac_cpp='$CXXCPP $CPPFLAGS'
4079 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4080 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4081 cross_compiling=$ac_cv_prog_cxx_cross
4082
4083   echo $ac_n "checking for isinf declaration""... $ac_c" 1>&6
4084 echo "configure:4085: checking for isinf declaration" >&5
4085   cat > conftest.$ac_ext <<EOF
4086 #line 4087 "configure"
4087 #include "confdefs.h"
4088 #include <math.h>
4089 int main() {
4090  isinf(0);
4091 ; return 0; }
4092 EOF
4093 if { (eval echo configure:4094: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4094   rm -rf conftest*
4095   use_isinf=yes
4096 else
4097   echo "configure: failed program was:" >&5
4098   cat conftest.$ac_ext >&5
4099   rm -rf conftest*
4100   use_isinf=no
4101 fi
4102 rm -f conftest*
4103   echo "$ac_t""$use_isinf" 1>&6
4104   ac_ext=c
4105 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4106 ac_cpp='$CPP $CPPFLAGS'
4107 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4108 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4109 cross_compiling=$ac_cv_prog_cc_cross
4110
4111   if test x$use_isinf = x"yes"; then
4112     for ac_func in isinf
4113 do
4114 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4115 echo "configure:4116: checking for $ac_func" >&5
4116 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4117   echo $ac_n "(cached) $ac_c" 1>&6
4118 else
4119   cat > conftest.$ac_ext <<EOF
4120 #line 4121 "configure"
4121 #include "confdefs.h"
4122 /* System header to define __stub macros and hopefully few prototypes,
4123     which can conflict with char $ac_func(); below.  */
4124 #include <assert.h>
4125 /* Override any gcc2 internal prototype to avoid an error.  */
4126 /* We use char because int might match the return type of a gcc2
4127     builtin and then its argument prototype would still apply.  */
4128 char $ac_func();
4129
4130 int main() {
4131
4132 /* The GNU C library defines this for functions which it implements
4133     to always fail with ENOSYS.  Some functions are actually named
4134     something starting with __ and the normal name is an alias.  */
4135 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4136 choke me
4137 #else
4138 $ac_func();
4139 #endif
4140
4141 ; return 0; }
4142 EOF
4143 if { (eval echo configure:4144: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4144   rm -rf conftest*
4145   eval "ac_cv_func_$ac_func=yes"
4146 else
4147   echo "configure: failed program was:" >&5
4148   cat conftest.$ac_ext >&5
4149   rm -rf conftest*
4150   eval "ac_cv_func_$ac_func=no"
4151 fi
4152 rm -f conftest*
4153 fi
4154
4155 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4156   echo "$ac_t""yes" 1>&6
4157     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4158   cat >> confdefs.h <<EOF
4159 #define $ac_tr_func 1
4160 EOF
4161
4162 else
4163   echo "$ac_t""no" 1>&6
4164 fi
4165 done
4166
4167   fi
4168
4169
4170
4171   ac_ext=C
4172 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4173 ac_cpp='$CXXCPP $CPPFLAGS'
4174 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4175 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4176 cross_compiling=$ac_cv_prog_cxx_cross
4177
4178   echo $ac_n "checking for isnan declaration""... $ac_c" 1>&6
4179 echo "configure:4180: checking for isnan declaration" >&5
4180   cat > conftest.$ac_ext <<EOF
4181 #line 4182 "configure"
4182 #include "confdefs.h"
4183 #include <math.h>
4184 int main() {
4185  isnan(0);
4186 ; return 0; }
4187 EOF
4188 if { (eval echo configure:4189: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4189   rm -rf conftest*
4190   use_isnan=yes
4191 else
4192   echo "configure: failed program was:" >&5
4193   cat conftest.$ac_ext >&5
4194   rm -rf conftest*
4195   use_isnan=no
4196 fi
4197 rm -f conftest*
4198   echo "$ac_t""$use_isnan" 1>&6
4199   ac_ext=c
4200 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4201 ac_cpp='$CPP $CPPFLAGS'
4202 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4203 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4204 cross_compiling=$ac_cv_prog_cc_cross
4205
4206   if test x$use_isnan = x"yes"; then
4207     for ac_func in isnan
4208 do
4209 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4210 echo "configure:4211: checking for $ac_func" >&5
4211 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4212   echo $ac_n "(cached) $ac_c" 1>&6
4213 else
4214   cat > conftest.$ac_ext <<EOF
4215 #line 4216 "configure"
4216 #include "confdefs.h"
4217 /* System header to define __stub macros and hopefully few prototypes,
4218     which can conflict with char $ac_func(); below.  */
4219 #include <assert.h>
4220 /* Override any gcc2 internal prototype to avoid an error.  */
4221 /* We use char because int might match the return type of a gcc2
4222     builtin and then its argument prototype would still apply.  */
4223 char $ac_func();
4224
4225 int main() {
4226
4227 /* The GNU C library defines this for functions which it implements
4228     to always fail with ENOSYS.  Some functions are actually named
4229     something starting with __ and the normal name is an alias.  */
4230 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4231 choke me
4232 #else
4233 $ac_func();
4234 #endif
4235
4236 ; return 0; }
4237 EOF
4238 if { (eval echo configure:4239: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4239   rm -rf conftest*
4240   eval "ac_cv_func_$ac_func=yes"
4241 else
4242   echo "configure: failed program was:" >&5
4243   cat conftest.$ac_ext >&5
4244   rm -rf conftest*
4245   eval "ac_cv_func_$ac_func=no"
4246 fi
4247 rm -f conftest*
4248 fi
4249
4250 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4251   echo "$ac_t""yes" 1>&6
4252     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4253   cat >> confdefs.h <<EOF
4254 #define $ac_tr_func 1
4255 EOF
4256
4257 else
4258   echo "$ac_t""no" 1>&6
4259 fi
4260 done
4261
4262   fi
4263
4264
4265
4266   ac_ext=C
4267 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4268 ac_cpp='$CXXCPP $CPPFLAGS'
4269 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4270 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4271 cross_compiling=$ac_cv_prog_cxx_cross
4272
4273   echo $ac_n "checking for finite declaration""... $ac_c" 1>&6
4274 echo "configure:4275: checking for finite declaration" >&5
4275   cat > conftest.$ac_ext <<EOF
4276 #line 4277 "configure"
4277 #include "confdefs.h"
4278 #include <math.h>
4279 int main() {
4280  finite(0);
4281 ; return 0; }
4282 EOF
4283 if { (eval echo configure:4284: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4284   rm -rf conftest*
4285   use_finite=yes
4286 else
4287   echo "configure: failed program was:" >&5
4288   cat conftest.$ac_ext >&5
4289   rm -rf conftest*
4290   use_finite=no
4291 fi
4292 rm -f conftest*
4293   echo "$ac_t""$use_finite" 1>&6
4294   ac_ext=c
4295 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4296 ac_cpp='$CPP $CPPFLAGS'
4297 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4298 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4299 cross_compiling=$ac_cv_prog_cc_cross
4300
4301   if test x$use_finite = x"yes"; then
4302     for ac_func in finite
4303 do
4304 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4305 echo "configure:4306: checking for $ac_func" >&5
4306 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4307   echo $ac_n "(cached) $ac_c" 1>&6
4308 else
4309   cat > conftest.$ac_ext <<EOF
4310 #line 4311 "configure"
4311 #include "confdefs.h"
4312 /* System header to define __stub macros and hopefully few prototypes,
4313     which can conflict with char $ac_func(); below.  */
4314 #include <assert.h>
4315 /* Override any gcc2 internal prototype to avoid an error.  */
4316 /* We use char because int might match the return type of a gcc2
4317     builtin and then its argument prototype would still apply.  */
4318 char $ac_func();
4319
4320 int main() {
4321
4322 /* The GNU C library defines this for functions which it implements
4323     to always fail with ENOSYS.  Some functions are actually named
4324     something starting with __ and the normal name is an alias.  */
4325 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4326 choke me
4327 #else
4328 $ac_func();
4329 #endif
4330
4331 ; return 0; }
4332 EOF
4333 if { (eval echo configure:4334: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4334   rm -rf conftest*
4335   eval "ac_cv_func_$ac_func=yes"
4336 else
4337   echo "configure: failed program was:" >&5
4338   cat conftest.$ac_ext >&5
4339   rm -rf conftest*
4340   eval "ac_cv_func_$ac_func=no"
4341 fi
4342 rm -f conftest*
4343 fi
4344
4345 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4346   echo "$ac_t""yes" 1>&6
4347     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4348   cat >> confdefs.h <<EOF
4349 #define $ac_tr_func 1
4350 EOF
4351
4352 else
4353   echo "$ac_t""no" 1>&6
4354 fi
4355 done
4356
4357   fi
4358
4359
4360
4361   ac_ext=C
4362 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4363 ac_cpp='$CXXCPP $CPPFLAGS'
4364 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4365 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4366 cross_compiling=$ac_cv_prog_cxx_cross
4367
4368   echo $ac_n "checking for copysign declaration""... $ac_c" 1>&6
4369 echo "configure:4370: checking for copysign declaration" >&5
4370   cat > conftest.$ac_ext <<EOF
4371 #line 4372 "configure"
4372 #include "confdefs.h"
4373 #include <math.h>
4374 int main() {
4375  copysign(0, 0);
4376 ; return 0; }
4377 EOF
4378 if { (eval echo configure:4379: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4379   rm -rf conftest*
4380   use_copysign=yes
4381 else
4382   echo "configure: failed program was:" >&5
4383   cat conftest.$ac_ext >&5
4384   rm -rf conftest*
4385   use_copysign=no
4386 fi
4387 rm -f conftest*
4388   echo "$ac_t""$use_copysign" 1>&6
4389   ac_ext=c
4390 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4391 ac_cpp='$CPP $CPPFLAGS'
4392 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4393 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4394 cross_compiling=$ac_cv_prog_cc_cross
4395
4396   if test x$use_copysign = x"yes"; then
4397     for ac_func in copysign
4398 do
4399 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4400 echo "configure:4401: checking for $ac_func" >&5
4401 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4402   echo $ac_n "(cached) $ac_c" 1>&6
4403 else
4404   cat > conftest.$ac_ext <<EOF
4405 #line 4406 "configure"
4406 #include "confdefs.h"
4407 /* System header to define __stub macros and hopefully few prototypes,
4408     which can conflict with char $ac_func(); below.  */
4409 #include <assert.h>
4410 /* Override any gcc2 internal prototype to avoid an error.  */
4411 /* We use char because int might match the return type of a gcc2
4412     builtin and then its argument prototype would still apply.  */
4413 char $ac_func();
4414
4415 int main() {
4416
4417 /* The GNU C library defines this for functions which it implements
4418     to always fail with ENOSYS.  Some functions are actually named
4419     something starting with __ and the normal name is an alias.  */
4420 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4421 choke me
4422 #else
4423 $ac_func();
4424 #endif
4425
4426 ; return 0; }
4427 EOF
4428 if { (eval echo configure:4429: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4429   rm -rf conftest*
4430   eval "ac_cv_func_$ac_func=yes"
4431 else
4432   echo "configure: failed program was:" >&5
4433   cat conftest.$ac_ext >&5
4434   rm -rf conftest*
4435   eval "ac_cv_func_$ac_func=no"
4436 fi
4437 rm -f conftest*
4438 fi
4439
4440 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4441   echo "$ac_t""yes" 1>&6
4442     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4443   cat >> confdefs.h <<EOF
4444 #define $ac_tr_func 1
4445 EOF
4446
4447 else
4448   echo "$ac_t""no" 1>&6
4449 fi
4450 done
4451
4452   fi
4453
4454
4455
4456   ac_ext=C
4457 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4458 ac_cpp='$CXXCPP $CPPFLAGS'
4459 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4460 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4461 cross_compiling=$ac_cv_prog_cxx_cross
4462
4463   echo $ac_n "checking for sincos declaration""... $ac_c" 1>&6
4464 echo "configure:4465: checking for sincos declaration" >&5
4465   cat > conftest.$ac_ext <<EOF
4466 #line 4467 "configure"
4467 #include "confdefs.h"
4468 #include <math.h>
4469 int main() {
4470  sincos(0, 0, 0);
4471 ; return 0; }
4472 EOF
4473 if { (eval echo configure:4474: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4474   rm -rf conftest*
4475   use_sincos=yes
4476 else
4477   echo "configure: failed program was:" >&5
4478   cat conftest.$ac_ext >&5
4479   rm -rf conftest*
4480   use_sincos=no
4481 fi
4482 rm -f conftest*
4483   echo "$ac_t""$use_sincos" 1>&6
4484   ac_ext=c
4485 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4486 ac_cpp='$CPP $CPPFLAGS'
4487 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4488 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4489 cross_compiling=$ac_cv_prog_cc_cross
4490
4491   if test x$use_sincos = x"yes"; then
4492     for ac_func in sincos
4493 do
4494 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4495 echo "configure:4496: checking for $ac_func" >&5
4496 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4497   echo $ac_n "(cached) $ac_c" 1>&6
4498 else
4499   cat > conftest.$ac_ext <<EOF
4500 #line 4501 "configure"
4501 #include "confdefs.h"
4502 /* System header to define __stub macros and hopefully few prototypes,
4503     which can conflict with char $ac_func(); below.  */
4504 #include <assert.h>
4505 /* Override any gcc2 internal prototype to avoid an error.  */
4506 /* We use char because int might match the return type of a gcc2
4507     builtin and then its argument prototype would still apply.  */
4508 char $ac_func();
4509
4510 int main() {
4511
4512 /* The GNU C library defines this for functions which it implements
4513     to always fail with ENOSYS.  Some functions are actually named
4514     something starting with __ and the normal name is an alias.  */
4515 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4516 choke me
4517 #else
4518 $ac_func();
4519 #endif
4520
4521 ; return 0; }
4522 EOF
4523 if { (eval echo configure:4524: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4524   rm -rf conftest*
4525   eval "ac_cv_func_$ac_func=yes"
4526 else
4527   echo "configure: failed program was:" >&5
4528   cat conftest.$ac_ext >&5
4529   rm -rf conftest*
4530   eval "ac_cv_func_$ac_func=no"
4531 fi
4532 rm -f conftest*
4533 fi
4534
4535 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4536   echo "$ac_t""yes" 1>&6
4537     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4538   cat >> confdefs.h <<EOF
4539 #define $ac_tr_func 1
4540 EOF
4541
4542 else
4543   echo "$ac_t""no" 1>&6
4544 fi
4545 done
4546
4547   fi
4548
4549
4550
4551   ac_ext=C
4552 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4553 ac_cpp='$CXXCPP $CPPFLAGS'
4554 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4555 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4556 cross_compiling=$ac_cv_prog_cxx_cross
4557
4558   echo $ac_n "checking for fpclass declaration""... $ac_c" 1>&6
4559 echo "configure:4560: checking for fpclass declaration" >&5
4560   cat > conftest.$ac_ext <<EOF
4561 #line 4562 "configure"
4562 #include "confdefs.h"
4563 #include <math.h>
4564 int main() {
4565  fpclass(0);
4566 ; return 0; }
4567 EOF
4568 if { (eval echo configure:4569: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4569   rm -rf conftest*
4570   use_fpclass=yes
4571 else
4572   echo "configure: failed program was:" >&5
4573   cat conftest.$ac_ext >&5
4574   rm -rf conftest*
4575   use_fpclass=no
4576 fi
4577 rm -f conftest*
4578   echo "$ac_t""$use_fpclass" 1>&6
4579   ac_ext=c
4580 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4581 ac_cpp='$CPP $CPPFLAGS'
4582 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4583 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4584 cross_compiling=$ac_cv_prog_cc_cross
4585
4586   if test x$use_fpclass = x"yes"; then
4587     for ac_func in fpclass
4588 do
4589 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4590 echo "configure:4591: checking for $ac_func" >&5
4591 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4592   echo $ac_n "(cached) $ac_c" 1>&6
4593 else
4594   cat > conftest.$ac_ext <<EOF
4595 #line 4596 "configure"
4596 #include "confdefs.h"
4597 /* System header to define __stub macros and hopefully few prototypes,
4598     which can conflict with char $ac_func(); below.  */
4599 #include <assert.h>
4600 /* Override any gcc2 internal prototype to avoid an error.  */
4601 /* We use char because int might match the return type of a gcc2
4602     builtin and then its argument prototype would still apply.  */
4603 char $ac_func();
4604
4605 int main() {
4606
4607 /* The GNU C library defines this for functions which it implements
4608     to always fail with ENOSYS.  Some functions are actually named
4609     something starting with __ and the normal name is an alias.  */
4610 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4611 choke me
4612 #else
4613 $ac_func();
4614 #endif
4615
4616 ; return 0; }
4617 EOF
4618 if { (eval echo configure:4619: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4619   rm -rf conftest*
4620   eval "ac_cv_func_$ac_func=yes"
4621 else
4622   echo "configure: failed program was:" >&5
4623   cat conftest.$ac_ext >&5
4624   rm -rf conftest*
4625   eval "ac_cv_func_$ac_func=no"
4626 fi
4627 rm -f conftest*
4628 fi
4629
4630 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4631   echo "$ac_t""yes" 1>&6
4632     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4633   cat >> confdefs.h <<EOF
4634 #define $ac_tr_func 1
4635 EOF
4636
4637 else
4638   echo "$ac_t""no" 1>&6
4639 fi
4640 done
4641
4642   fi
4643
4644
4645
4646   ac_ext=C
4647 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4648 ac_cpp='$CXXCPP $CPPFLAGS'
4649 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4650 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4651 cross_compiling=$ac_cv_prog_cxx_cross
4652
4653   echo $ac_n "checking for qfpclass declaration""... $ac_c" 1>&6
4654 echo "configure:4655: checking for qfpclass declaration" >&5
4655   cat > conftest.$ac_ext <<EOF
4656 #line 4657 "configure"
4657 #include "confdefs.h"
4658 #include <math.h>
4659 int main() {
4660  qfpclass(0);
4661 ; return 0; }
4662 EOF
4663 if { (eval echo configure:4664: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4664   rm -rf conftest*
4665   use_qfpclass=yes
4666 else
4667   echo "configure: failed program was:" >&5
4668   cat conftest.$ac_ext >&5
4669   rm -rf conftest*
4670   use_qfpclass=no
4671 fi
4672 rm -f conftest*
4673   echo "$ac_t""$use_qfpclass" 1>&6
4674   ac_ext=c
4675 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4676 ac_cpp='$CPP $CPPFLAGS'
4677 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4678 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4679 cross_compiling=$ac_cv_prog_cc_cross
4680
4681   if test x$use_qfpclass = x"yes"; then
4682     for ac_func in qfpclass
4683 do
4684 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4685 echo "configure:4686: checking for $ac_func" >&5
4686 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4687   echo $ac_n "(cached) $ac_c" 1>&6
4688 else
4689   cat > conftest.$ac_ext <<EOF
4690 #line 4691 "configure"
4691 #include "confdefs.h"
4692 /* System header to define __stub macros and hopefully few prototypes,
4693     which can conflict with char $ac_func(); below.  */
4694 #include <assert.h>
4695 /* Override any gcc2 internal prototype to avoid an error.  */
4696 /* We use char because int might match the return type of a gcc2
4697     builtin and then its argument prototype would still apply.  */
4698 char $ac_func();
4699
4700 int main() {
4701
4702 /* The GNU C library defines this for functions which it implements
4703     to always fail with ENOSYS.  Some functions are actually named
4704     something starting with __ and the normal name is an alias.  */
4705 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4706 choke me
4707 #else
4708 $ac_func();
4709 #endif
4710
4711 ; return 0; }
4712 EOF
4713 if { (eval echo configure:4714: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4714   rm -rf conftest*
4715   eval "ac_cv_func_$ac_func=yes"
4716 else
4717   echo "configure: failed program was:" >&5
4718   cat conftest.$ac_ext >&5
4719   rm -rf conftest*
4720   eval "ac_cv_func_$ac_func=no"
4721 fi
4722 rm -f conftest*
4723 fi
4724
4725 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4726   echo "$ac_t""yes" 1>&6
4727     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4728   cat >> confdefs.h <<EOF
4729 #define $ac_tr_func 1
4730 EOF
4731
4732 else
4733   echo "$ac_t""no" 1>&6
4734 fi
4735 done
4736
4737   fi
4738
4739
4740
4741
4742   ac_ext=C
4743 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4744 ac_cpp='$CXXCPP $CPPFLAGS'
4745 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4746 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4747 cross_compiling=$ac_cv_prog_cxx_cross
4748
4749   echo $ac_n "checking for isnanf declaration""... $ac_c" 1>&6
4750 echo "configure:4751: checking for isnanf declaration" >&5
4751   cat > conftest.$ac_ext <<EOF
4752 #line 4753 "configure"
4753 #include "confdefs.h"
4754 #include <math.h>
4755 int main() {
4756  isnanf(0);
4757 ; return 0; }
4758 EOF
4759 if { (eval echo configure:4760: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4760   rm -rf conftest*
4761   use_isnanf=yes
4762 else
4763   echo "configure: failed program was:" >&5
4764   cat conftest.$ac_ext >&5
4765   rm -rf conftest*
4766   use_isnanf=no
4767 fi
4768 rm -f conftest*
4769   echo "$ac_t""$use_isnanf" 1>&6
4770   ac_ext=c
4771 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4772 ac_cpp='$CPP $CPPFLAGS'
4773 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4774 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4775 cross_compiling=$ac_cv_prog_cc_cross
4776
4777   if test x$use_isnanf = x"yes"; then
4778     for ac_func in isnanf
4779 do
4780 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4781 echo "configure:4782: checking for $ac_func" >&5
4782 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4783   echo $ac_n "(cached) $ac_c" 1>&6
4784 else
4785   cat > conftest.$ac_ext <<EOF
4786 #line 4787 "configure"
4787 #include "confdefs.h"
4788 /* System header to define __stub macros and hopefully few prototypes,
4789     which can conflict with char $ac_func(); below.  */
4790 #include <assert.h>
4791 /* Override any gcc2 internal prototype to avoid an error.  */
4792 /* We use char because int might match the return type of a gcc2
4793     builtin and then its argument prototype would still apply.  */
4794 char $ac_func();
4795
4796 int main() {
4797
4798 /* The GNU C library defines this for functions which it implements
4799     to always fail with ENOSYS.  Some functions are actually named
4800     something starting with __ and the normal name is an alias.  */
4801 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4802 choke me
4803 #else
4804 $ac_func();
4805 #endif
4806
4807 ; return 0; }
4808 EOF
4809 if { (eval echo configure:4810: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4810   rm -rf conftest*
4811   eval "ac_cv_func_$ac_func=yes"
4812 else
4813   echo "configure: failed program was:" >&5
4814   cat conftest.$ac_ext >&5
4815   rm -rf conftest*
4816   eval "ac_cv_func_$ac_func=no"
4817 fi
4818 rm -f conftest*
4819 fi
4820
4821 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4822   echo "$ac_t""yes" 1>&6
4823     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4824   cat >> confdefs.h <<EOF
4825 #define $ac_tr_func 1
4826 EOF
4827
4828 else
4829   echo "$ac_t""no" 1>&6
4830 fi
4831 done
4832
4833   fi
4834
4835
4836
4837   ac_ext=C
4838 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4839 ac_cpp='$CXXCPP $CPPFLAGS'
4840 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4841 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4842 cross_compiling=$ac_cv_prog_cxx_cross
4843
4844   echo $ac_n "checking for isinff declaration""... $ac_c" 1>&6
4845 echo "configure:4846: checking for isinff declaration" >&5
4846   cat > conftest.$ac_ext <<EOF
4847 #line 4848 "configure"
4848 #include "confdefs.h"
4849 #include <math.h>
4850 int main() {
4851  isinff(0);
4852 ; return 0; }
4853 EOF
4854 if { (eval echo configure:4855: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4855   rm -rf conftest*
4856   use_isinff=yes
4857 else
4858   echo "configure: failed program was:" >&5
4859   cat conftest.$ac_ext >&5
4860   rm -rf conftest*
4861   use_isinff=no
4862 fi
4863 rm -f conftest*
4864   echo "$ac_t""$use_isinff" 1>&6
4865   ac_ext=c
4866 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4867 ac_cpp='$CPP $CPPFLAGS'
4868 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4869 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4870 cross_compiling=$ac_cv_prog_cc_cross
4871
4872   if test x$use_isinff = x"yes"; then
4873     for ac_func in isinff
4874 do
4875 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4876 echo "configure:4877: checking for $ac_func" >&5
4877 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4878   echo $ac_n "(cached) $ac_c" 1>&6
4879 else
4880   cat > conftest.$ac_ext <<EOF
4881 #line 4882 "configure"
4882 #include "confdefs.h"
4883 /* System header to define __stub macros and hopefully few prototypes,
4884     which can conflict with char $ac_func(); below.  */
4885 #include <assert.h>
4886 /* Override any gcc2 internal prototype to avoid an error.  */
4887 /* We use char because int might match the return type of a gcc2
4888     builtin and then its argument prototype would still apply.  */
4889 char $ac_func();
4890
4891 int main() {
4892
4893 /* The GNU C library defines this for functions which it implements
4894     to always fail with ENOSYS.  Some functions are actually named
4895     something starting with __ and the normal name is an alias.  */
4896 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4897 choke me
4898 #else
4899 $ac_func();
4900 #endif
4901
4902 ; return 0; }
4903 EOF
4904 if { (eval echo configure:4905: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4905   rm -rf conftest*
4906   eval "ac_cv_func_$ac_func=yes"
4907 else
4908   echo "configure: failed program was:" >&5
4909   cat conftest.$ac_ext >&5
4910   rm -rf conftest*
4911   eval "ac_cv_func_$ac_func=no"
4912 fi
4913 rm -f conftest*
4914 fi
4915
4916 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4917   echo "$ac_t""yes" 1>&6
4918     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4919   cat >> confdefs.h <<EOF
4920 #define $ac_tr_func 1
4921 EOF
4922
4923 else
4924   echo "$ac_t""no" 1>&6
4925 fi
4926 done
4927
4928   fi
4929
4930
4931
4932   ac_ext=C
4933 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4934 ac_cpp='$CXXCPP $CPPFLAGS'
4935 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4936 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4937 cross_compiling=$ac_cv_prog_cxx_cross
4938
4939   echo $ac_n "checking for acosf declaration""... $ac_c" 1>&6
4940 echo "configure:4941: checking for acosf declaration" >&5
4941   cat > conftest.$ac_ext <<EOF
4942 #line 4943 "configure"
4943 #include "confdefs.h"
4944 #include <math.h>
4945 int main() {
4946  acosf(0);
4947 ; return 0; }
4948 EOF
4949 if { (eval echo configure:4950: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4950   rm -rf conftest*
4951   use_acosf=yes
4952 else
4953   echo "configure: failed program was:" >&5
4954   cat conftest.$ac_ext >&5
4955   rm -rf conftest*
4956   use_acosf=no
4957 fi
4958 rm -f conftest*
4959   echo "$ac_t""$use_acosf" 1>&6
4960   ac_ext=c
4961 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4962 ac_cpp='$CPP $CPPFLAGS'
4963 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4964 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4965 cross_compiling=$ac_cv_prog_cc_cross
4966
4967   if test x$use_acosf = x"yes"; then
4968     for ac_func in acosf
4969 do
4970 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4971 echo "configure:4972: checking for $ac_func" >&5
4972 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4973   echo $ac_n "(cached) $ac_c" 1>&6
4974 else
4975   cat > conftest.$ac_ext <<EOF
4976 #line 4977 "configure"
4977 #include "confdefs.h"
4978 /* System header to define __stub macros and hopefully few prototypes,
4979     which can conflict with char $ac_func(); below.  */
4980 #include <assert.h>
4981 /* Override any gcc2 internal prototype to avoid an error.  */
4982 /* We use char because int might match the return type of a gcc2
4983     builtin and then its argument prototype would still apply.  */
4984 char $ac_func();
4985
4986 int main() {
4987
4988 /* The GNU C library defines this for functions which it implements
4989     to always fail with ENOSYS.  Some functions are actually named
4990     something starting with __ and the normal name is an alias.  */
4991 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4992 choke me
4993 #else
4994 $ac_func();
4995 #endif
4996
4997 ; return 0; }
4998 EOF
4999 if { (eval echo configure:5000: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5000   rm -rf conftest*
5001   eval "ac_cv_func_$ac_func=yes"
5002 else
5003   echo "configure: failed program was:" >&5
5004   cat conftest.$ac_ext >&5
5005   rm -rf conftest*
5006   eval "ac_cv_func_$ac_func=no"
5007 fi
5008 rm -f conftest*
5009 fi
5010
5011 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5012   echo "$ac_t""yes" 1>&6
5013     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5014   cat >> confdefs.h <<EOF
5015 #define $ac_tr_func 1
5016 EOF
5017
5018 else
5019   echo "$ac_t""no" 1>&6
5020 fi
5021 done
5022
5023   fi
5024
5025
5026
5027   ac_ext=C
5028 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5029 ac_cpp='$CXXCPP $CPPFLAGS'
5030 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5031 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5032 cross_compiling=$ac_cv_prog_cxx_cross
5033
5034   echo $ac_n "checking for asinf declaration""... $ac_c" 1>&6
5035 echo "configure:5036: checking for asinf declaration" >&5
5036   cat > conftest.$ac_ext <<EOF
5037 #line 5038 "configure"
5038 #include "confdefs.h"
5039 #include <math.h>
5040 int main() {
5041  asinf(0);
5042 ; return 0; }
5043 EOF
5044 if { (eval echo configure:5045: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5045   rm -rf conftest*
5046   use_asinf=yes
5047 else
5048   echo "configure: failed program was:" >&5
5049   cat conftest.$ac_ext >&5
5050   rm -rf conftest*
5051   use_asinf=no
5052 fi
5053 rm -f conftest*
5054   echo "$ac_t""$use_asinf" 1>&6
5055   ac_ext=c
5056 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5057 ac_cpp='$CPP $CPPFLAGS'
5058 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5059 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5060 cross_compiling=$ac_cv_prog_cc_cross
5061
5062   if test x$use_asinf = x"yes"; then
5063     for ac_func in asinf
5064 do
5065 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5066 echo "configure:5067: checking for $ac_func" >&5
5067 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5068   echo $ac_n "(cached) $ac_c" 1>&6
5069 else
5070   cat > conftest.$ac_ext <<EOF
5071 #line 5072 "configure"
5072 #include "confdefs.h"
5073 /* System header to define __stub macros and hopefully few prototypes,
5074     which can conflict with char $ac_func(); below.  */
5075 #include <assert.h>
5076 /* Override any gcc2 internal prototype to avoid an error.  */
5077 /* We use char because int might match the return type of a gcc2
5078     builtin and then its argument prototype would still apply.  */
5079 char $ac_func();
5080
5081 int main() {
5082
5083 /* The GNU C library defines this for functions which it implements
5084     to always fail with ENOSYS.  Some functions are actually named
5085     something starting with __ and the normal name is an alias.  */
5086 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5087 choke me
5088 #else
5089 $ac_func();
5090 #endif
5091
5092 ; return 0; }
5093 EOF
5094 if { (eval echo configure:5095: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5095   rm -rf conftest*
5096   eval "ac_cv_func_$ac_func=yes"
5097 else
5098   echo "configure: failed program was:" >&5
5099   cat conftest.$ac_ext >&5
5100   rm -rf conftest*
5101   eval "ac_cv_func_$ac_func=no"
5102 fi
5103 rm -f conftest*
5104 fi
5105
5106 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5107   echo "$ac_t""yes" 1>&6
5108     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5109   cat >> confdefs.h <<EOF
5110 #define $ac_tr_func 1
5111 EOF
5112
5113 else
5114   echo "$ac_t""no" 1>&6
5115 fi
5116 done
5117
5118   fi
5119
5120
5121
5122   ac_ext=C
5123 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5124 ac_cpp='$CXXCPP $CPPFLAGS'
5125 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5126 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5127 cross_compiling=$ac_cv_prog_cxx_cross
5128
5129   echo $ac_n "checking for atanf declaration""... $ac_c" 1>&6
5130 echo "configure:5131: checking for atanf declaration" >&5
5131   cat > conftest.$ac_ext <<EOF
5132 #line 5133 "configure"
5133 #include "confdefs.h"
5134 #include <math.h>
5135 int main() {
5136  atanf(0);
5137 ; return 0; }
5138 EOF
5139 if { (eval echo configure:5140: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5140   rm -rf conftest*
5141   use_atanf=yes
5142 else
5143   echo "configure: failed program was:" >&5
5144   cat conftest.$ac_ext >&5
5145   rm -rf conftest*
5146   use_atanf=no
5147 fi
5148 rm -f conftest*
5149   echo "$ac_t""$use_atanf" 1>&6
5150   ac_ext=c
5151 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5152 ac_cpp='$CPP $CPPFLAGS'
5153 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5154 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5155 cross_compiling=$ac_cv_prog_cc_cross
5156
5157   if test x$use_atanf = x"yes"; then
5158     for ac_func in atanf
5159 do
5160 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5161 echo "configure:5162: checking for $ac_func" >&5
5162 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5163   echo $ac_n "(cached) $ac_c" 1>&6
5164 else
5165   cat > conftest.$ac_ext <<EOF
5166 #line 5167 "configure"
5167 #include "confdefs.h"
5168 /* System header to define __stub macros and hopefully few prototypes,
5169     which can conflict with char $ac_func(); below.  */
5170 #include <assert.h>
5171 /* Override any gcc2 internal prototype to avoid an error.  */
5172 /* We use char because int might match the return type of a gcc2
5173     builtin and then its argument prototype would still apply.  */
5174 char $ac_func();
5175
5176 int main() {
5177
5178 /* The GNU C library defines this for functions which it implements
5179     to always fail with ENOSYS.  Some functions are actually named
5180     something starting with __ and the normal name is an alias.  */
5181 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5182 choke me
5183 #else
5184 $ac_func();
5185 #endif
5186
5187 ; return 0; }
5188 EOF
5189 if { (eval echo configure:5190: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5190   rm -rf conftest*
5191   eval "ac_cv_func_$ac_func=yes"
5192 else
5193   echo "configure: failed program was:" >&5
5194   cat conftest.$ac_ext >&5
5195   rm -rf conftest*
5196   eval "ac_cv_func_$ac_func=no"
5197 fi
5198 rm -f conftest*
5199 fi
5200
5201 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5202   echo "$ac_t""yes" 1>&6
5203     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5204   cat >> confdefs.h <<EOF
5205 #define $ac_tr_func 1
5206 EOF
5207
5208 else
5209   echo "$ac_t""no" 1>&6
5210 fi
5211 done
5212
5213   fi
5214
5215
5216
5217   ac_ext=C
5218 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5219 ac_cpp='$CXXCPP $CPPFLAGS'
5220 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5221 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5222 cross_compiling=$ac_cv_prog_cxx_cross
5223
5224   echo $ac_n "checking for atan2f declaration""... $ac_c" 1>&6
5225 echo "configure:5226: checking for atan2f declaration" >&5
5226   cat > conftest.$ac_ext <<EOF
5227 #line 5228 "configure"
5228 #include "confdefs.h"
5229 #include <math.h>
5230 int main() {
5231  atan2f(0, 0);
5232 ; return 0; }
5233 EOF
5234 if { (eval echo configure:5235: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5235   rm -rf conftest*
5236   use_atan2f=yes
5237 else
5238   echo "configure: failed program was:" >&5
5239   cat conftest.$ac_ext >&5
5240   rm -rf conftest*
5241   use_atan2f=no
5242 fi
5243 rm -f conftest*
5244   echo "$ac_t""$use_atan2f" 1>&6
5245   ac_ext=c
5246 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5247 ac_cpp='$CPP $CPPFLAGS'
5248 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5249 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5250 cross_compiling=$ac_cv_prog_cc_cross
5251
5252   if test x$use_atan2f = x"yes"; then
5253     for ac_func in atan2f
5254 do
5255 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5256 echo "configure:5257: checking for $ac_func" >&5
5257 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5258   echo $ac_n "(cached) $ac_c" 1>&6
5259 else
5260   cat > conftest.$ac_ext <<EOF
5261 #line 5262 "configure"
5262 #include "confdefs.h"
5263 /* System header to define __stub macros and hopefully few prototypes,
5264     which can conflict with char $ac_func(); below.  */
5265 #include <assert.h>
5266 /* Override any gcc2 internal prototype to avoid an error.  */
5267 /* We use char because int might match the return type of a gcc2
5268     builtin and then its argument prototype would still apply.  */
5269 char $ac_func();
5270
5271 int main() {
5272
5273 /* The GNU C library defines this for functions which it implements
5274     to always fail with ENOSYS.  Some functions are actually named
5275     something starting with __ and the normal name is an alias.  */
5276 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5277 choke me
5278 #else
5279 $ac_func();
5280 #endif
5281
5282 ; return 0; }
5283 EOF
5284 if { (eval echo configure:5285: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5285   rm -rf conftest*
5286   eval "ac_cv_func_$ac_func=yes"
5287 else
5288   echo "configure: failed program was:" >&5
5289   cat conftest.$ac_ext >&5
5290   rm -rf conftest*
5291   eval "ac_cv_func_$ac_func=no"
5292 fi
5293 rm -f conftest*
5294 fi
5295
5296 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5297   echo "$ac_t""yes" 1>&6
5298     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5299   cat >> confdefs.h <<EOF
5300 #define $ac_tr_func 1
5301 EOF
5302
5303 else
5304   echo "$ac_t""no" 1>&6
5305 fi
5306 done
5307
5308   fi
5309
5310
5311
5312   ac_ext=C
5313 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5314 ac_cpp='$CXXCPP $CPPFLAGS'
5315 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5316 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5317 cross_compiling=$ac_cv_prog_cxx_cross
5318
5319   echo $ac_n "checking for ceilf declaration""... $ac_c" 1>&6
5320 echo "configure:5321: checking for ceilf declaration" >&5
5321   cat > conftest.$ac_ext <<EOF
5322 #line 5323 "configure"
5323 #include "confdefs.h"
5324 #include <math.h>
5325 int main() {
5326  ceilf(0);
5327 ; return 0; }
5328 EOF
5329 if { (eval echo configure:5330: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5330   rm -rf conftest*
5331   use_ceilf=yes
5332 else
5333   echo "configure: failed program was:" >&5
5334   cat conftest.$ac_ext >&5
5335   rm -rf conftest*
5336   use_ceilf=no
5337 fi
5338 rm -f conftest*
5339   echo "$ac_t""$use_ceilf" 1>&6
5340   ac_ext=c
5341 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5342 ac_cpp='$CPP $CPPFLAGS'
5343 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5344 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5345 cross_compiling=$ac_cv_prog_cc_cross
5346
5347   if test x$use_ceilf = x"yes"; then
5348     for ac_func in ceilf
5349 do
5350 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5351 echo "configure:5352: checking for $ac_func" >&5
5352 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5353   echo $ac_n "(cached) $ac_c" 1>&6
5354 else
5355   cat > conftest.$ac_ext <<EOF
5356 #line 5357 "configure"
5357 #include "confdefs.h"
5358 /* System header to define __stub macros and hopefully few prototypes,
5359     which can conflict with char $ac_func(); below.  */
5360 #include <assert.h>
5361 /* Override any gcc2 internal prototype to avoid an error.  */
5362 /* We use char because int might match the return type of a gcc2
5363     builtin and then its argument prototype would still apply.  */
5364 char $ac_func();
5365
5366 int main() {
5367
5368 /* The GNU C library defines this for functions which it implements
5369     to always fail with ENOSYS.  Some functions are actually named
5370     something starting with __ and the normal name is an alias.  */
5371 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5372 choke me
5373 #else
5374 $ac_func();
5375 #endif
5376
5377 ; return 0; }
5378 EOF
5379 if { (eval echo configure:5380: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5380   rm -rf conftest*
5381   eval "ac_cv_func_$ac_func=yes"
5382 else
5383   echo "configure: failed program was:" >&5
5384   cat conftest.$ac_ext >&5
5385   rm -rf conftest*
5386   eval "ac_cv_func_$ac_func=no"
5387 fi
5388 rm -f conftest*
5389 fi
5390
5391 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5392   echo "$ac_t""yes" 1>&6
5393     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5394   cat >> confdefs.h <<EOF
5395 #define $ac_tr_func 1
5396 EOF
5397
5398 else
5399   echo "$ac_t""no" 1>&6
5400 fi
5401 done
5402
5403   fi
5404
5405
5406
5407   ac_ext=C
5408 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5409 ac_cpp='$CXXCPP $CPPFLAGS'
5410 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5411 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5412 cross_compiling=$ac_cv_prog_cxx_cross
5413
5414   echo $ac_n "checking for cosf declaration""... $ac_c" 1>&6
5415 echo "configure:5416: checking for cosf declaration" >&5
5416   cat > conftest.$ac_ext <<EOF
5417 #line 5418 "configure"
5418 #include "confdefs.h"
5419 #include <math.h>
5420 int main() {
5421  cosf(0);
5422 ; return 0; }
5423 EOF
5424 if { (eval echo configure:5425: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5425   rm -rf conftest*
5426   use_cosf=yes
5427 else
5428   echo "configure: failed program was:" >&5
5429   cat conftest.$ac_ext >&5
5430   rm -rf conftest*
5431   use_cosf=no
5432 fi
5433 rm -f conftest*
5434   echo "$ac_t""$use_cosf" 1>&6
5435   ac_ext=c
5436 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5437 ac_cpp='$CPP $CPPFLAGS'
5438 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5439 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5440 cross_compiling=$ac_cv_prog_cc_cross
5441
5442   if test x$use_cosf = x"yes"; then
5443     for ac_func in cosf
5444 do
5445 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5446 echo "configure:5447: checking for $ac_func" >&5
5447 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5448   echo $ac_n "(cached) $ac_c" 1>&6
5449 else
5450   cat > conftest.$ac_ext <<EOF
5451 #line 5452 "configure"
5452 #include "confdefs.h"
5453 /* System header to define __stub macros and hopefully few prototypes,
5454     which can conflict with char $ac_func(); below.  */
5455 #include <assert.h>
5456 /* Override any gcc2 internal prototype to avoid an error.  */
5457 /* We use char because int might match the return type of a gcc2
5458     builtin and then its argument prototype would still apply.  */
5459 char $ac_func();
5460
5461 int main() {
5462
5463 /* The GNU C library defines this for functions which it implements
5464     to always fail with ENOSYS.  Some functions are actually named
5465     something starting with __ and the normal name is an alias.  */
5466 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5467 choke me
5468 #else
5469 $ac_func();
5470 #endif
5471
5472 ; return 0; }
5473 EOF
5474 if { (eval echo configure:5475: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5475   rm -rf conftest*
5476   eval "ac_cv_func_$ac_func=yes"
5477 else
5478   echo "configure: failed program was:" >&5
5479   cat conftest.$ac_ext >&5
5480   rm -rf conftest*
5481   eval "ac_cv_func_$ac_func=no"
5482 fi
5483 rm -f conftest*
5484 fi
5485
5486 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5487   echo "$ac_t""yes" 1>&6
5488     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5489   cat >> confdefs.h <<EOF
5490 #define $ac_tr_func 1
5491 EOF
5492
5493 else
5494   echo "$ac_t""no" 1>&6
5495 fi
5496 done
5497
5498   fi
5499
5500
5501
5502   ac_ext=C
5503 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5504 ac_cpp='$CXXCPP $CPPFLAGS'
5505 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5506 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5507 cross_compiling=$ac_cv_prog_cxx_cross
5508
5509   echo $ac_n "checking for coshf declaration""... $ac_c" 1>&6
5510 echo "configure:5511: checking for coshf declaration" >&5
5511   cat > conftest.$ac_ext <<EOF
5512 #line 5513 "configure"
5513 #include "confdefs.h"
5514 #include <math.h>
5515 int main() {
5516  coshf(0);
5517 ; return 0; }
5518 EOF
5519 if { (eval echo configure:5520: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5520   rm -rf conftest*
5521   use_coshf=yes
5522 else
5523   echo "configure: failed program was:" >&5
5524   cat conftest.$ac_ext >&5
5525   rm -rf conftest*
5526   use_coshf=no
5527 fi
5528 rm -f conftest*
5529   echo "$ac_t""$use_coshf" 1>&6
5530   ac_ext=c
5531 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5532 ac_cpp='$CPP $CPPFLAGS'
5533 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5534 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5535 cross_compiling=$ac_cv_prog_cc_cross
5536
5537   if test x$use_coshf = x"yes"; then
5538     for ac_func in coshf
5539 do
5540 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5541 echo "configure:5542: checking for $ac_func" >&5
5542 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5543   echo $ac_n "(cached) $ac_c" 1>&6
5544 else
5545   cat > conftest.$ac_ext <<EOF
5546 #line 5547 "configure"
5547 #include "confdefs.h"
5548 /* System header to define __stub macros and hopefully few prototypes,
5549     which can conflict with char $ac_func(); below.  */
5550 #include <assert.h>
5551 /* Override any gcc2 internal prototype to avoid an error.  */
5552 /* We use char because int might match the return type of a gcc2
5553     builtin and then its argument prototype would still apply.  */
5554 char $ac_func();
5555
5556 int main() {
5557
5558 /* The GNU C library defines this for functions which it implements
5559     to always fail with ENOSYS.  Some functions are actually named
5560     something starting with __ and the normal name is an alias.  */
5561 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5562 choke me
5563 #else
5564 $ac_func();
5565 #endif
5566
5567 ; return 0; }
5568 EOF
5569 if { (eval echo configure:5570: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5570   rm -rf conftest*
5571   eval "ac_cv_func_$ac_func=yes"
5572 else
5573   echo "configure: failed program was:" >&5
5574   cat conftest.$ac_ext >&5
5575   rm -rf conftest*
5576   eval "ac_cv_func_$ac_func=no"
5577 fi
5578 rm -f conftest*
5579 fi
5580
5581 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5582   echo "$ac_t""yes" 1>&6
5583     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5584   cat >> confdefs.h <<EOF
5585 #define $ac_tr_func 1
5586 EOF
5587
5588 else
5589   echo "$ac_t""no" 1>&6
5590 fi
5591 done
5592
5593   fi
5594
5595
5596
5597   ac_ext=C
5598 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5599 ac_cpp='$CXXCPP $CPPFLAGS'
5600 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5601 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5602 cross_compiling=$ac_cv_prog_cxx_cross
5603
5604   echo $ac_n "checking for expf declaration""... $ac_c" 1>&6
5605 echo "configure:5606: checking for expf declaration" >&5
5606   cat > conftest.$ac_ext <<EOF
5607 #line 5608 "configure"
5608 #include "confdefs.h"
5609 #include <math.h>
5610 int main() {
5611  expf(0);
5612 ; return 0; }
5613 EOF
5614 if { (eval echo configure:5615: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5615   rm -rf conftest*
5616   use_expf=yes
5617 else
5618   echo "configure: failed program was:" >&5
5619   cat conftest.$ac_ext >&5
5620   rm -rf conftest*
5621   use_expf=no
5622 fi
5623 rm -f conftest*
5624   echo "$ac_t""$use_expf" 1>&6
5625   ac_ext=c
5626 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5627 ac_cpp='$CPP $CPPFLAGS'
5628 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5629 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5630 cross_compiling=$ac_cv_prog_cc_cross
5631
5632   if test x$use_expf = x"yes"; then
5633     for ac_func in expf
5634 do
5635 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5636 echo "configure:5637: checking for $ac_func" >&5
5637 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5638   echo $ac_n "(cached) $ac_c" 1>&6
5639 else
5640   cat > conftest.$ac_ext <<EOF
5641 #line 5642 "configure"
5642 #include "confdefs.h"
5643 /* System header to define __stub macros and hopefully few prototypes,
5644     which can conflict with char $ac_func(); below.  */
5645 #include <assert.h>
5646 /* Override any gcc2 internal prototype to avoid an error.  */
5647 /* We use char because int might match the return type of a gcc2
5648     builtin and then its argument prototype would still apply.  */
5649 char $ac_func();
5650
5651 int main() {
5652
5653 /* The GNU C library defines this for functions which it implements
5654     to always fail with ENOSYS.  Some functions are actually named
5655     something starting with __ and the normal name is an alias.  */
5656 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5657 choke me
5658 #else
5659 $ac_func();
5660 #endif
5661
5662 ; return 0; }
5663 EOF
5664 if { (eval echo configure:5665: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5665   rm -rf conftest*
5666   eval "ac_cv_func_$ac_func=yes"
5667 else
5668   echo "configure: failed program was:" >&5
5669   cat conftest.$ac_ext >&5
5670   rm -rf conftest*
5671   eval "ac_cv_func_$ac_func=no"
5672 fi
5673 rm -f conftest*
5674 fi
5675
5676 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5677   echo "$ac_t""yes" 1>&6
5678     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5679   cat >> confdefs.h <<EOF
5680 #define $ac_tr_func 1
5681 EOF
5682
5683 else
5684   echo "$ac_t""no" 1>&6
5685 fi
5686 done
5687
5688   fi
5689
5690
5691
5692   ac_ext=C
5693 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5694 ac_cpp='$CXXCPP $CPPFLAGS'
5695 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5696 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5697 cross_compiling=$ac_cv_prog_cxx_cross
5698
5699   echo $ac_n "checking for fabsf declaration""... $ac_c" 1>&6
5700 echo "configure:5701: checking for fabsf declaration" >&5
5701   cat > conftest.$ac_ext <<EOF
5702 #line 5703 "configure"
5703 #include "confdefs.h"
5704 #include <math.h>
5705 int main() {
5706  fabsf(0);
5707 ; return 0; }
5708 EOF
5709 if { (eval echo configure:5710: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5710   rm -rf conftest*
5711   use_fabsf=yes
5712 else
5713   echo "configure: failed program was:" >&5
5714   cat conftest.$ac_ext >&5
5715   rm -rf conftest*
5716   use_fabsf=no
5717 fi
5718 rm -f conftest*
5719   echo "$ac_t""$use_fabsf" 1>&6
5720   ac_ext=c
5721 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5722 ac_cpp='$CPP $CPPFLAGS'
5723 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5724 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5725 cross_compiling=$ac_cv_prog_cc_cross
5726
5727   if test x$use_fabsf = x"yes"; then
5728     for ac_func in fabsf
5729 do
5730 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5731 echo "configure:5732: checking for $ac_func" >&5
5732 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5733   echo $ac_n "(cached) $ac_c" 1>&6
5734 else
5735   cat > conftest.$ac_ext <<EOF
5736 #line 5737 "configure"
5737 #include "confdefs.h"
5738 /* System header to define __stub macros and hopefully few prototypes,
5739     which can conflict with char $ac_func(); below.  */
5740 #include <assert.h>
5741 /* Override any gcc2 internal prototype to avoid an error.  */
5742 /* We use char because int might match the return type of a gcc2
5743     builtin and then its argument prototype would still apply.  */
5744 char $ac_func();
5745
5746 int main() {
5747
5748 /* The GNU C library defines this for functions which it implements
5749     to always fail with ENOSYS.  Some functions are actually named
5750     something starting with __ and the normal name is an alias.  */
5751 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5752 choke me
5753 #else
5754 $ac_func();
5755 #endif
5756
5757 ; return 0; }
5758 EOF
5759 if { (eval echo configure:5760: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5760   rm -rf conftest*
5761   eval "ac_cv_func_$ac_func=yes"
5762 else
5763   echo "configure: failed program was:" >&5
5764   cat conftest.$ac_ext >&5
5765   rm -rf conftest*
5766   eval "ac_cv_func_$ac_func=no"
5767 fi
5768 rm -f conftest*
5769 fi
5770
5771 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5772   echo "$ac_t""yes" 1>&6
5773     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5774   cat >> confdefs.h <<EOF
5775 #define $ac_tr_func 1
5776 EOF
5777
5778 else
5779   echo "$ac_t""no" 1>&6
5780 fi
5781 done
5782
5783   fi
5784
5785
5786
5787   ac_ext=C
5788 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5789 ac_cpp='$CXXCPP $CPPFLAGS'
5790 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5791 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5792 cross_compiling=$ac_cv_prog_cxx_cross
5793
5794   echo $ac_n "checking for floorf declaration""... $ac_c" 1>&6
5795 echo "configure:5796: checking for floorf declaration" >&5
5796   cat > conftest.$ac_ext <<EOF
5797 #line 5798 "configure"
5798 #include "confdefs.h"
5799 #include <math.h>
5800 int main() {
5801  floorf(0);
5802 ; return 0; }
5803 EOF
5804 if { (eval echo configure:5805: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5805   rm -rf conftest*
5806   use_floorf=yes
5807 else
5808   echo "configure: failed program was:" >&5
5809   cat conftest.$ac_ext >&5
5810   rm -rf conftest*
5811   use_floorf=no
5812 fi
5813 rm -f conftest*
5814   echo "$ac_t""$use_floorf" 1>&6
5815   ac_ext=c
5816 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5817 ac_cpp='$CPP $CPPFLAGS'
5818 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5819 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5820 cross_compiling=$ac_cv_prog_cc_cross
5821
5822   if test x$use_floorf = x"yes"; then
5823     for ac_func in floorf
5824 do
5825 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5826 echo "configure:5827: checking for $ac_func" >&5
5827 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5828   echo $ac_n "(cached) $ac_c" 1>&6
5829 else
5830   cat > conftest.$ac_ext <<EOF
5831 #line 5832 "configure"
5832 #include "confdefs.h"
5833 /* System header to define __stub macros and hopefully few prototypes,
5834     which can conflict with char $ac_func(); below.  */
5835 #include <assert.h>
5836 /* Override any gcc2 internal prototype to avoid an error.  */
5837 /* We use char because int might match the return type of a gcc2
5838     builtin and then its argument prototype would still apply.  */
5839 char $ac_func();
5840
5841 int main() {
5842
5843 /* The GNU C library defines this for functions which it implements
5844     to always fail with ENOSYS.  Some functions are actually named
5845     something starting with __ and the normal name is an alias.  */
5846 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5847 choke me
5848 #else
5849 $ac_func();
5850 #endif
5851
5852 ; return 0; }
5853 EOF
5854 if { (eval echo configure:5855: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5855   rm -rf conftest*
5856   eval "ac_cv_func_$ac_func=yes"
5857 else
5858   echo "configure: failed program was:" >&5
5859   cat conftest.$ac_ext >&5
5860   rm -rf conftest*
5861   eval "ac_cv_func_$ac_func=no"
5862 fi
5863 rm -f conftest*
5864 fi
5865
5866 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5867   echo "$ac_t""yes" 1>&6
5868     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5869   cat >> confdefs.h <<EOF
5870 #define $ac_tr_func 1
5871 EOF
5872
5873 else
5874   echo "$ac_t""no" 1>&6
5875 fi
5876 done
5877
5878   fi
5879
5880
5881
5882   ac_ext=C
5883 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5884 ac_cpp='$CXXCPP $CPPFLAGS'
5885 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5886 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5887 cross_compiling=$ac_cv_prog_cxx_cross
5888
5889   echo $ac_n "checking for fmodf declaration""... $ac_c" 1>&6
5890 echo "configure:5891: checking for fmodf declaration" >&5
5891   cat > conftest.$ac_ext <<EOF
5892 #line 5893 "configure"
5893 #include "confdefs.h"
5894 #include <math.h>
5895 int main() {
5896  fmodf(0, 0);
5897 ; return 0; }
5898 EOF
5899 if { (eval echo configure:5900: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5900   rm -rf conftest*
5901   use_fmodf=yes
5902 else
5903   echo "configure: failed program was:" >&5
5904   cat conftest.$ac_ext >&5
5905   rm -rf conftest*
5906   use_fmodf=no
5907 fi
5908 rm -f conftest*
5909   echo "$ac_t""$use_fmodf" 1>&6
5910   ac_ext=c
5911 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5912 ac_cpp='$CPP $CPPFLAGS'
5913 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5914 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5915 cross_compiling=$ac_cv_prog_cc_cross
5916
5917   if test x$use_fmodf = x"yes"; then
5918     for ac_func in fmodf
5919 do
5920 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5921 echo "configure:5922: checking for $ac_func" >&5
5922 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5923   echo $ac_n "(cached) $ac_c" 1>&6
5924 else
5925   cat > conftest.$ac_ext <<EOF
5926 #line 5927 "configure"
5927 #include "confdefs.h"
5928 /* System header to define __stub macros and hopefully few prototypes,
5929     which can conflict with char $ac_func(); below.  */
5930 #include <assert.h>
5931 /* Override any gcc2 internal prototype to avoid an error.  */
5932 /* We use char because int might match the return type of a gcc2
5933     builtin and then its argument prototype would still apply.  */
5934 char $ac_func();
5935
5936 int main() {
5937
5938 /* The GNU C library defines this for functions which it implements
5939     to always fail with ENOSYS.  Some functions are actually named
5940     something starting with __ and the normal name is an alias.  */
5941 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5942 choke me
5943 #else
5944 $ac_func();
5945 #endif
5946
5947 ; return 0; }
5948 EOF
5949 if { (eval echo configure:5950: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5950   rm -rf conftest*
5951   eval "ac_cv_func_$ac_func=yes"
5952 else
5953   echo "configure: failed program was:" >&5
5954   cat conftest.$ac_ext >&5
5955   rm -rf conftest*
5956   eval "ac_cv_func_$ac_func=no"
5957 fi
5958 rm -f conftest*
5959 fi
5960
5961 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
5962   echo "$ac_t""yes" 1>&6
5963     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5964   cat >> confdefs.h <<EOF
5965 #define $ac_tr_func 1
5966 EOF
5967
5968 else
5969   echo "$ac_t""no" 1>&6
5970 fi
5971 done
5972
5973   fi
5974
5975
5976
5977   ac_ext=C
5978 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5979 ac_cpp='$CXXCPP $CPPFLAGS'
5980 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5981 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5982 cross_compiling=$ac_cv_prog_cxx_cross
5983
5984   echo $ac_n "checking for frexpf declaration""... $ac_c" 1>&6
5985 echo "configure:5986: checking for frexpf declaration" >&5
5986   cat > conftest.$ac_ext <<EOF
5987 #line 5988 "configure"
5988 #include "confdefs.h"
5989 #include <math.h>
5990 int main() {
5991  frexpf(0, 0);
5992 ; return 0; }
5993 EOF
5994 if { (eval echo configure:5995: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5995   rm -rf conftest*
5996   use_frexpf=yes
5997 else
5998   echo "configure: failed program was:" >&5
5999   cat conftest.$ac_ext >&5
6000   rm -rf conftest*
6001   use_frexpf=no
6002 fi
6003 rm -f conftest*
6004   echo "$ac_t""$use_frexpf" 1>&6
6005   ac_ext=c
6006 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6007 ac_cpp='$CPP $CPPFLAGS'
6008 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6009 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6010 cross_compiling=$ac_cv_prog_cc_cross
6011
6012   if test x$use_frexpf = x"yes"; then
6013     for ac_func in frexpf
6014 do
6015 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6016 echo "configure:6017: checking for $ac_func" >&5
6017 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6018   echo $ac_n "(cached) $ac_c" 1>&6
6019 else
6020   cat > conftest.$ac_ext <<EOF
6021 #line 6022 "configure"
6022 #include "confdefs.h"
6023 /* System header to define __stub macros and hopefully few prototypes,
6024     which can conflict with char $ac_func(); below.  */
6025 #include <assert.h>
6026 /* Override any gcc2 internal prototype to avoid an error.  */
6027 /* We use char because int might match the return type of a gcc2
6028     builtin and then its argument prototype would still apply.  */
6029 char $ac_func();
6030
6031 int main() {
6032
6033 /* The GNU C library defines this for functions which it implements
6034     to always fail with ENOSYS.  Some functions are actually named
6035     something starting with __ and the normal name is an alias.  */
6036 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6037 choke me
6038 #else
6039 $ac_func();
6040 #endif
6041
6042 ; return 0; }
6043 EOF
6044 if { (eval echo configure:6045: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6045   rm -rf conftest*
6046   eval "ac_cv_func_$ac_func=yes"
6047 else
6048   echo "configure: failed program was:" >&5
6049   cat conftest.$ac_ext >&5
6050   rm -rf conftest*
6051   eval "ac_cv_func_$ac_func=no"
6052 fi
6053 rm -f conftest*
6054 fi
6055
6056 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6057   echo "$ac_t""yes" 1>&6
6058     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6059   cat >> confdefs.h <<EOF
6060 #define $ac_tr_func 1
6061 EOF
6062
6063 else
6064   echo "$ac_t""no" 1>&6
6065 fi
6066 done
6067
6068   fi
6069
6070
6071
6072   ac_ext=C
6073 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6074 ac_cpp='$CXXCPP $CPPFLAGS'
6075 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6076 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6077 cross_compiling=$ac_cv_prog_cxx_cross
6078
6079   echo $ac_n "checking for ldexpf declaration""... $ac_c" 1>&6
6080 echo "configure:6081: checking for ldexpf declaration" >&5
6081   cat > conftest.$ac_ext <<EOF
6082 #line 6083 "configure"
6083 #include "confdefs.h"
6084 #include <math.h>
6085 int main() {
6086  ldexpf(0, 0);
6087 ; return 0; }
6088 EOF
6089 if { (eval echo configure:6090: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6090   rm -rf conftest*
6091   use_ldexpf=yes
6092 else
6093   echo "configure: failed program was:" >&5
6094   cat conftest.$ac_ext >&5
6095   rm -rf conftest*
6096   use_ldexpf=no
6097 fi
6098 rm -f conftest*
6099   echo "$ac_t""$use_ldexpf" 1>&6
6100   ac_ext=c
6101 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6102 ac_cpp='$CPP $CPPFLAGS'
6103 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6104 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6105 cross_compiling=$ac_cv_prog_cc_cross
6106
6107   if test x$use_ldexpf = x"yes"; then
6108     for ac_func in ldexpf
6109 do
6110 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6111 echo "configure:6112: checking for $ac_func" >&5
6112 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6113   echo $ac_n "(cached) $ac_c" 1>&6
6114 else
6115   cat > conftest.$ac_ext <<EOF
6116 #line 6117 "configure"
6117 #include "confdefs.h"
6118 /* System header to define __stub macros and hopefully few prototypes,
6119     which can conflict with char $ac_func(); below.  */
6120 #include <assert.h>
6121 /* Override any gcc2 internal prototype to avoid an error.  */
6122 /* We use char because int might match the return type of a gcc2
6123     builtin and then its argument prototype would still apply.  */
6124 char $ac_func();
6125
6126 int main() {
6127
6128 /* The GNU C library defines this for functions which it implements
6129     to always fail with ENOSYS.  Some functions are actually named
6130     something starting with __ and the normal name is an alias.  */
6131 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6132 choke me
6133 #else
6134 $ac_func();
6135 #endif
6136
6137 ; return 0; }
6138 EOF
6139 if { (eval echo configure:6140: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6140   rm -rf conftest*
6141   eval "ac_cv_func_$ac_func=yes"
6142 else
6143   echo "configure: failed program was:" >&5
6144   cat conftest.$ac_ext >&5
6145   rm -rf conftest*
6146   eval "ac_cv_func_$ac_func=no"
6147 fi
6148 rm -f conftest*
6149 fi
6150
6151 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6152   echo "$ac_t""yes" 1>&6
6153     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6154   cat >> confdefs.h <<EOF
6155 #define $ac_tr_func 1
6156 EOF
6157
6158 else
6159   echo "$ac_t""no" 1>&6
6160 fi
6161 done
6162
6163   fi
6164
6165
6166
6167   ac_ext=C
6168 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6169 ac_cpp='$CXXCPP $CPPFLAGS'
6170 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6171 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6172 cross_compiling=$ac_cv_prog_cxx_cross
6173
6174   echo $ac_n "checking for logf declaration""... $ac_c" 1>&6
6175 echo "configure:6176: checking for logf declaration" >&5
6176   cat > conftest.$ac_ext <<EOF
6177 #line 6178 "configure"
6178 #include "confdefs.h"
6179 #include <math.h>
6180 int main() {
6181  logf(0);
6182 ; return 0; }
6183 EOF
6184 if { (eval echo configure:6185: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6185   rm -rf conftest*
6186   use_logf=yes
6187 else
6188   echo "configure: failed program was:" >&5
6189   cat conftest.$ac_ext >&5
6190   rm -rf conftest*
6191   use_logf=no
6192 fi
6193 rm -f conftest*
6194   echo "$ac_t""$use_logf" 1>&6
6195   ac_ext=c
6196 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6197 ac_cpp='$CPP $CPPFLAGS'
6198 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6199 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6200 cross_compiling=$ac_cv_prog_cc_cross
6201
6202   if test x$use_logf = x"yes"; then
6203     for ac_func in logf
6204 do
6205 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6206 echo "configure:6207: checking for $ac_func" >&5
6207 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6208   echo $ac_n "(cached) $ac_c" 1>&6
6209 else
6210   cat > conftest.$ac_ext <<EOF
6211 #line 6212 "configure"
6212 #include "confdefs.h"
6213 /* System header to define __stub macros and hopefully few prototypes,
6214     which can conflict with char $ac_func(); below.  */
6215 #include <assert.h>
6216 /* Override any gcc2 internal prototype to avoid an error.  */
6217 /* We use char because int might match the return type of a gcc2
6218     builtin and then its argument prototype would still apply.  */
6219 char $ac_func();
6220
6221 int main() {
6222
6223 /* The GNU C library defines this for functions which it implements
6224     to always fail with ENOSYS.  Some functions are actually named
6225     something starting with __ and the normal name is an alias.  */
6226 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6227 choke me
6228 #else
6229 $ac_func();
6230 #endif
6231
6232 ; return 0; }
6233 EOF
6234 if { (eval echo configure:6235: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6235   rm -rf conftest*
6236   eval "ac_cv_func_$ac_func=yes"
6237 else
6238   echo "configure: failed program was:" >&5
6239   cat conftest.$ac_ext >&5
6240   rm -rf conftest*
6241   eval "ac_cv_func_$ac_func=no"
6242 fi
6243 rm -f conftest*
6244 fi
6245
6246 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6247   echo "$ac_t""yes" 1>&6
6248     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6249   cat >> confdefs.h <<EOF
6250 #define $ac_tr_func 1
6251 EOF
6252
6253 else
6254   echo "$ac_t""no" 1>&6
6255 fi
6256 done
6257
6258   fi
6259
6260
6261
6262   ac_ext=C
6263 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6264 ac_cpp='$CXXCPP $CPPFLAGS'
6265 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6266 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6267 cross_compiling=$ac_cv_prog_cxx_cross
6268
6269   echo $ac_n "checking for log10f declaration""... $ac_c" 1>&6
6270 echo "configure:6271: checking for log10f declaration" >&5
6271   cat > conftest.$ac_ext <<EOF
6272 #line 6273 "configure"
6273 #include "confdefs.h"
6274 #include <math.h>
6275 int main() {
6276  log10f(0);
6277 ; return 0; }
6278 EOF
6279 if { (eval echo configure:6280: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6280   rm -rf conftest*
6281   use_log10f=yes
6282 else
6283   echo "configure: failed program was:" >&5
6284   cat conftest.$ac_ext >&5
6285   rm -rf conftest*
6286   use_log10f=no
6287 fi
6288 rm -f conftest*
6289   echo "$ac_t""$use_log10f" 1>&6
6290   ac_ext=c
6291 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6292 ac_cpp='$CPP $CPPFLAGS'
6293 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6294 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6295 cross_compiling=$ac_cv_prog_cc_cross
6296
6297   if test x$use_log10f = x"yes"; then
6298     for ac_func in log10f
6299 do
6300 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6301 echo "configure:6302: checking for $ac_func" >&5
6302 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6303   echo $ac_n "(cached) $ac_c" 1>&6
6304 else
6305   cat > conftest.$ac_ext <<EOF
6306 #line 6307 "configure"
6307 #include "confdefs.h"
6308 /* System header to define __stub macros and hopefully few prototypes,
6309     which can conflict with char $ac_func(); below.  */
6310 #include <assert.h>
6311 /* Override any gcc2 internal prototype to avoid an error.  */
6312 /* We use char because int might match the return type of a gcc2
6313     builtin and then its argument prototype would still apply.  */
6314 char $ac_func();
6315
6316 int main() {
6317
6318 /* The GNU C library defines this for functions which it implements
6319     to always fail with ENOSYS.  Some functions are actually named
6320     something starting with __ and the normal name is an alias.  */
6321 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6322 choke me
6323 #else
6324 $ac_func();
6325 #endif
6326
6327 ; return 0; }
6328 EOF
6329 if { (eval echo configure:6330: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6330   rm -rf conftest*
6331   eval "ac_cv_func_$ac_func=yes"
6332 else
6333   echo "configure: failed program was:" >&5
6334   cat conftest.$ac_ext >&5
6335   rm -rf conftest*
6336   eval "ac_cv_func_$ac_func=no"
6337 fi
6338 rm -f conftest*
6339 fi
6340
6341 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6342   echo "$ac_t""yes" 1>&6
6343     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6344   cat >> confdefs.h <<EOF
6345 #define $ac_tr_func 1
6346 EOF
6347
6348 else
6349   echo "$ac_t""no" 1>&6
6350 fi
6351 done
6352
6353   fi
6354
6355
6356
6357   ac_ext=C
6358 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6359 ac_cpp='$CXXCPP $CPPFLAGS'
6360 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6361 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6362 cross_compiling=$ac_cv_prog_cxx_cross
6363
6364   echo $ac_n "checking for modff declaration""... $ac_c" 1>&6
6365 echo "configure:6366: checking for modff declaration" >&5
6366   cat > conftest.$ac_ext <<EOF
6367 #line 6368 "configure"
6368 #include "confdefs.h"
6369 #include <math.h>
6370 int main() {
6371  modff(0, 0);
6372 ; return 0; }
6373 EOF
6374 if { (eval echo configure:6375: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6375   rm -rf conftest*
6376   use_modff=yes
6377 else
6378   echo "configure: failed program was:" >&5
6379   cat conftest.$ac_ext >&5
6380   rm -rf conftest*
6381   use_modff=no
6382 fi
6383 rm -f conftest*
6384   echo "$ac_t""$use_modff" 1>&6
6385   ac_ext=c
6386 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6387 ac_cpp='$CPP $CPPFLAGS'
6388 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6389 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6390 cross_compiling=$ac_cv_prog_cc_cross
6391
6392   if test x$use_modff = x"yes"; then
6393     for ac_func in modff
6394 do
6395 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6396 echo "configure:6397: checking for $ac_func" >&5
6397 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6398   echo $ac_n "(cached) $ac_c" 1>&6
6399 else
6400   cat > conftest.$ac_ext <<EOF
6401 #line 6402 "configure"
6402 #include "confdefs.h"
6403 /* System header to define __stub macros and hopefully few prototypes,
6404     which can conflict with char $ac_func(); below.  */
6405 #include <assert.h>
6406 /* Override any gcc2 internal prototype to avoid an error.  */
6407 /* We use char because int might match the return type of a gcc2
6408     builtin and then its argument prototype would still apply.  */
6409 char $ac_func();
6410
6411 int main() {
6412
6413 /* The GNU C library defines this for functions which it implements
6414     to always fail with ENOSYS.  Some functions are actually named
6415     something starting with __ and the normal name is an alias.  */
6416 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6417 choke me
6418 #else
6419 $ac_func();
6420 #endif
6421
6422 ; return 0; }
6423 EOF
6424 if { (eval echo configure:6425: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6425   rm -rf conftest*
6426   eval "ac_cv_func_$ac_func=yes"
6427 else
6428   echo "configure: failed program was:" >&5
6429   cat conftest.$ac_ext >&5
6430   rm -rf conftest*
6431   eval "ac_cv_func_$ac_func=no"
6432 fi
6433 rm -f conftest*
6434 fi
6435
6436 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6437   echo "$ac_t""yes" 1>&6
6438     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6439   cat >> confdefs.h <<EOF
6440 #define $ac_tr_func 1
6441 EOF
6442
6443 else
6444   echo "$ac_t""no" 1>&6
6445 fi
6446 done
6447
6448   fi
6449
6450
6451
6452   ac_ext=C
6453 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6454 ac_cpp='$CXXCPP $CPPFLAGS'
6455 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6456 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6457 cross_compiling=$ac_cv_prog_cxx_cross
6458
6459   echo $ac_n "checking for powf declaration""... $ac_c" 1>&6
6460 echo "configure:6461: checking for powf declaration" >&5
6461   cat > conftest.$ac_ext <<EOF
6462 #line 6463 "configure"
6463 #include "confdefs.h"
6464 #include <math.h>
6465 int main() {
6466  powf(0, 0);
6467 ; return 0; }
6468 EOF
6469 if { (eval echo configure:6470: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6470   rm -rf conftest*
6471   use_powf=yes
6472 else
6473   echo "configure: failed program was:" >&5
6474   cat conftest.$ac_ext >&5
6475   rm -rf conftest*
6476   use_powf=no
6477 fi
6478 rm -f conftest*
6479   echo "$ac_t""$use_powf" 1>&6
6480   ac_ext=c
6481 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6482 ac_cpp='$CPP $CPPFLAGS'
6483 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6484 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6485 cross_compiling=$ac_cv_prog_cc_cross
6486
6487   if test x$use_powf = x"yes"; then
6488     for ac_func in powf
6489 do
6490 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6491 echo "configure:6492: checking for $ac_func" >&5
6492 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6493   echo $ac_n "(cached) $ac_c" 1>&6
6494 else
6495   cat > conftest.$ac_ext <<EOF
6496 #line 6497 "configure"
6497 #include "confdefs.h"
6498 /* System header to define __stub macros and hopefully few prototypes,
6499     which can conflict with char $ac_func(); below.  */
6500 #include <assert.h>
6501 /* Override any gcc2 internal prototype to avoid an error.  */
6502 /* We use char because int might match the return type of a gcc2
6503     builtin and then its argument prototype would still apply.  */
6504 char $ac_func();
6505
6506 int main() {
6507
6508 /* The GNU C library defines this for functions which it implements
6509     to always fail with ENOSYS.  Some functions are actually named
6510     something starting with __ and the normal name is an alias.  */
6511 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6512 choke me
6513 #else
6514 $ac_func();
6515 #endif
6516
6517 ; return 0; }
6518 EOF
6519 if { (eval echo configure:6520: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6520   rm -rf conftest*
6521   eval "ac_cv_func_$ac_func=yes"
6522 else
6523   echo "configure: failed program was:" >&5
6524   cat conftest.$ac_ext >&5
6525   rm -rf conftest*
6526   eval "ac_cv_func_$ac_func=no"
6527 fi
6528 rm -f conftest*
6529 fi
6530
6531 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6532   echo "$ac_t""yes" 1>&6
6533     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6534   cat >> confdefs.h <<EOF
6535 #define $ac_tr_func 1
6536 EOF
6537
6538 else
6539   echo "$ac_t""no" 1>&6
6540 fi
6541 done
6542
6543   fi
6544
6545
6546
6547   ac_ext=C
6548 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6549 ac_cpp='$CXXCPP $CPPFLAGS'
6550 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6551 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6552 cross_compiling=$ac_cv_prog_cxx_cross
6553
6554   echo $ac_n "checking for sinf declaration""... $ac_c" 1>&6
6555 echo "configure:6556: checking for sinf declaration" >&5
6556   cat > conftest.$ac_ext <<EOF
6557 #line 6558 "configure"
6558 #include "confdefs.h"
6559 #include <math.h>
6560 int main() {
6561  sinf(0);
6562 ; return 0; }
6563 EOF
6564 if { (eval echo configure:6565: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6565   rm -rf conftest*
6566   use_sinf=yes
6567 else
6568   echo "configure: failed program was:" >&5
6569   cat conftest.$ac_ext >&5
6570   rm -rf conftest*
6571   use_sinf=no
6572 fi
6573 rm -f conftest*
6574   echo "$ac_t""$use_sinf" 1>&6
6575   ac_ext=c
6576 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6577 ac_cpp='$CPP $CPPFLAGS'
6578 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6579 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6580 cross_compiling=$ac_cv_prog_cc_cross
6581
6582   if test x$use_sinf = x"yes"; then
6583     for ac_func in sinf
6584 do
6585 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6586 echo "configure:6587: checking for $ac_func" >&5
6587 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6588   echo $ac_n "(cached) $ac_c" 1>&6
6589 else
6590   cat > conftest.$ac_ext <<EOF
6591 #line 6592 "configure"
6592 #include "confdefs.h"
6593 /* System header to define __stub macros and hopefully few prototypes,
6594     which can conflict with char $ac_func(); below.  */
6595 #include <assert.h>
6596 /* Override any gcc2 internal prototype to avoid an error.  */
6597 /* We use char because int might match the return type of a gcc2
6598     builtin and then its argument prototype would still apply.  */
6599 char $ac_func();
6600
6601 int main() {
6602
6603 /* The GNU C library defines this for functions which it implements
6604     to always fail with ENOSYS.  Some functions are actually named
6605     something starting with __ and the normal name is an alias.  */
6606 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6607 choke me
6608 #else
6609 $ac_func();
6610 #endif
6611
6612 ; return 0; }
6613 EOF
6614 if { (eval echo configure:6615: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6615   rm -rf conftest*
6616   eval "ac_cv_func_$ac_func=yes"
6617 else
6618   echo "configure: failed program was:" >&5
6619   cat conftest.$ac_ext >&5
6620   rm -rf conftest*
6621   eval "ac_cv_func_$ac_func=no"
6622 fi
6623 rm -f conftest*
6624 fi
6625
6626 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6627   echo "$ac_t""yes" 1>&6
6628     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6629   cat >> confdefs.h <<EOF
6630 #define $ac_tr_func 1
6631 EOF
6632
6633 else
6634   echo "$ac_t""no" 1>&6
6635 fi
6636 done
6637
6638   fi
6639
6640
6641
6642   ac_ext=C
6643 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6644 ac_cpp='$CXXCPP $CPPFLAGS'
6645 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6646 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6647 cross_compiling=$ac_cv_prog_cxx_cross
6648
6649   echo $ac_n "checking for sinhf declaration""... $ac_c" 1>&6
6650 echo "configure:6651: checking for sinhf declaration" >&5
6651   cat > conftest.$ac_ext <<EOF
6652 #line 6653 "configure"
6653 #include "confdefs.h"
6654 #include <math.h>
6655 int main() {
6656  sinhf(0);
6657 ; return 0; }
6658 EOF
6659 if { (eval echo configure:6660: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6660   rm -rf conftest*
6661   use_sinhf=yes
6662 else
6663   echo "configure: failed program was:" >&5
6664   cat conftest.$ac_ext >&5
6665   rm -rf conftest*
6666   use_sinhf=no
6667 fi
6668 rm -f conftest*
6669   echo "$ac_t""$use_sinhf" 1>&6
6670   ac_ext=c
6671 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6672 ac_cpp='$CPP $CPPFLAGS'
6673 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6674 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6675 cross_compiling=$ac_cv_prog_cc_cross
6676
6677   if test x$use_sinhf = x"yes"; then
6678     for ac_func in sinhf
6679 do
6680 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6681 echo "configure:6682: checking for $ac_func" >&5
6682 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6683   echo $ac_n "(cached) $ac_c" 1>&6
6684 else
6685   cat > conftest.$ac_ext <<EOF
6686 #line 6687 "configure"
6687 #include "confdefs.h"
6688 /* System header to define __stub macros and hopefully few prototypes,
6689     which can conflict with char $ac_func(); below.  */
6690 #include <assert.h>
6691 /* Override any gcc2 internal prototype to avoid an error.  */
6692 /* We use char because int might match the return type of a gcc2
6693     builtin and then its argument prototype would still apply.  */
6694 char $ac_func();
6695
6696 int main() {
6697
6698 /* The GNU C library defines this for functions which it implements
6699     to always fail with ENOSYS.  Some functions are actually named
6700     something starting with __ and the normal name is an alias.  */
6701 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6702 choke me
6703 #else
6704 $ac_func();
6705 #endif
6706
6707 ; return 0; }
6708 EOF
6709 if { (eval echo configure:6710: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6710   rm -rf conftest*
6711   eval "ac_cv_func_$ac_func=yes"
6712 else
6713   echo "configure: failed program was:" >&5
6714   cat conftest.$ac_ext >&5
6715   rm -rf conftest*
6716   eval "ac_cv_func_$ac_func=no"
6717 fi
6718 rm -f conftest*
6719 fi
6720
6721 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6722   echo "$ac_t""yes" 1>&6
6723     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6724   cat >> confdefs.h <<EOF
6725 #define $ac_tr_func 1
6726 EOF
6727
6728 else
6729   echo "$ac_t""no" 1>&6
6730 fi
6731 done
6732
6733   fi
6734
6735
6736
6737   ac_ext=C
6738 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6739 ac_cpp='$CXXCPP $CPPFLAGS'
6740 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6741 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6742 cross_compiling=$ac_cv_prog_cxx_cross
6743
6744   echo $ac_n "checking for sqrtf declaration""... $ac_c" 1>&6
6745 echo "configure:6746: checking for sqrtf declaration" >&5
6746   cat > conftest.$ac_ext <<EOF
6747 #line 6748 "configure"
6748 #include "confdefs.h"
6749 #include <math.h>
6750 int main() {
6751  sqrtf(0);
6752 ; return 0; }
6753 EOF
6754 if { (eval echo configure:6755: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6755   rm -rf conftest*
6756   use_sqrtf=yes
6757 else
6758   echo "configure: failed program was:" >&5
6759   cat conftest.$ac_ext >&5
6760   rm -rf conftest*
6761   use_sqrtf=no
6762 fi
6763 rm -f conftest*
6764   echo "$ac_t""$use_sqrtf" 1>&6
6765   ac_ext=c
6766 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6767 ac_cpp='$CPP $CPPFLAGS'
6768 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6769 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6770 cross_compiling=$ac_cv_prog_cc_cross
6771
6772   if test x$use_sqrtf = x"yes"; then
6773     for ac_func in sqrtf
6774 do
6775 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6776 echo "configure:6777: checking for $ac_func" >&5
6777 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6778   echo $ac_n "(cached) $ac_c" 1>&6
6779 else
6780   cat > conftest.$ac_ext <<EOF
6781 #line 6782 "configure"
6782 #include "confdefs.h"
6783 /* System header to define __stub macros and hopefully few prototypes,
6784     which can conflict with char $ac_func(); below.  */
6785 #include <assert.h>
6786 /* Override any gcc2 internal prototype to avoid an error.  */
6787 /* We use char because int might match the return type of a gcc2
6788     builtin and then its argument prototype would still apply.  */
6789 char $ac_func();
6790
6791 int main() {
6792
6793 /* The GNU C library defines this for functions which it implements
6794     to always fail with ENOSYS.  Some functions are actually named
6795     something starting with __ and the normal name is an alias.  */
6796 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6797 choke me
6798 #else
6799 $ac_func();
6800 #endif
6801
6802 ; return 0; }
6803 EOF
6804 if { (eval echo configure:6805: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6805   rm -rf conftest*
6806   eval "ac_cv_func_$ac_func=yes"
6807 else
6808   echo "configure: failed program was:" >&5
6809   cat conftest.$ac_ext >&5
6810   rm -rf conftest*
6811   eval "ac_cv_func_$ac_func=no"
6812 fi
6813 rm -f conftest*
6814 fi
6815
6816 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6817   echo "$ac_t""yes" 1>&6
6818     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6819   cat >> confdefs.h <<EOF
6820 #define $ac_tr_func 1
6821 EOF
6822
6823 else
6824   echo "$ac_t""no" 1>&6
6825 fi
6826 done
6827
6828   fi
6829
6830
6831
6832   ac_ext=C
6833 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6834 ac_cpp='$CXXCPP $CPPFLAGS'
6835 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6836 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6837 cross_compiling=$ac_cv_prog_cxx_cross
6838
6839   echo $ac_n "checking for tanf declaration""... $ac_c" 1>&6
6840 echo "configure:6841: checking for tanf declaration" >&5
6841   cat > conftest.$ac_ext <<EOF
6842 #line 6843 "configure"
6843 #include "confdefs.h"
6844 #include <math.h>
6845 int main() {
6846  tanf(0);
6847 ; return 0; }
6848 EOF
6849 if { (eval echo configure:6850: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6850   rm -rf conftest*
6851   use_tanf=yes
6852 else
6853   echo "configure: failed program was:" >&5
6854   cat conftest.$ac_ext >&5
6855   rm -rf conftest*
6856   use_tanf=no
6857 fi
6858 rm -f conftest*
6859   echo "$ac_t""$use_tanf" 1>&6
6860   ac_ext=c
6861 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6862 ac_cpp='$CPP $CPPFLAGS'
6863 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6864 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6865 cross_compiling=$ac_cv_prog_cc_cross
6866
6867   if test x$use_tanf = x"yes"; then
6868     for ac_func in tanf
6869 do
6870 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6871 echo "configure:6872: checking for $ac_func" >&5
6872 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6873   echo $ac_n "(cached) $ac_c" 1>&6
6874 else
6875   cat > conftest.$ac_ext <<EOF
6876 #line 6877 "configure"
6877 #include "confdefs.h"
6878 /* System header to define __stub macros and hopefully few prototypes,
6879     which can conflict with char $ac_func(); below.  */
6880 #include <assert.h>
6881 /* Override any gcc2 internal prototype to avoid an error.  */
6882 /* We use char because int might match the return type of a gcc2
6883     builtin and then its argument prototype would still apply.  */
6884 char $ac_func();
6885
6886 int main() {
6887
6888 /* The GNU C library defines this for functions which it implements
6889     to always fail with ENOSYS.  Some functions are actually named
6890     something starting with __ and the normal name is an alias.  */
6891 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6892 choke me
6893 #else
6894 $ac_func();
6895 #endif
6896
6897 ; return 0; }
6898 EOF
6899 if { (eval echo configure:6900: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6900   rm -rf conftest*
6901   eval "ac_cv_func_$ac_func=yes"
6902 else
6903   echo "configure: failed program was:" >&5
6904   cat conftest.$ac_ext >&5
6905   rm -rf conftest*
6906   eval "ac_cv_func_$ac_func=no"
6907 fi
6908 rm -f conftest*
6909 fi
6910
6911 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6912   echo "$ac_t""yes" 1>&6
6913     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6914   cat >> confdefs.h <<EOF
6915 #define $ac_tr_func 1
6916 EOF
6917
6918 else
6919   echo "$ac_t""no" 1>&6
6920 fi
6921 done
6922
6923   fi
6924
6925
6926
6927   ac_ext=C
6928 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6929 ac_cpp='$CXXCPP $CPPFLAGS'
6930 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6931 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6932 cross_compiling=$ac_cv_prog_cxx_cross
6933
6934   echo $ac_n "checking for tanhf declaration""... $ac_c" 1>&6
6935 echo "configure:6936: checking for tanhf declaration" >&5
6936   cat > conftest.$ac_ext <<EOF
6937 #line 6938 "configure"
6938 #include "confdefs.h"
6939 #include <math.h>
6940 int main() {
6941  tanhf(0);
6942 ; return 0; }
6943 EOF
6944 if { (eval echo configure:6945: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6945   rm -rf conftest*
6946   use_tanhf=yes
6947 else
6948   echo "configure: failed program was:" >&5
6949   cat conftest.$ac_ext >&5
6950   rm -rf conftest*
6951   use_tanhf=no
6952 fi
6953 rm -f conftest*
6954   echo "$ac_t""$use_tanhf" 1>&6
6955   ac_ext=c
6956 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6957 ac_cpp='$CPP $CPPFLAGS'
6958 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6959 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6960 cross_compiling=$ac_cv_prog_cc_cross
6961
6962   if test x$use_tanhf = x"yes"; then
6963     for ac_func in tanhf
6964 do
6965 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6966 echo "configure:6967: checking for $ac_func" >&5
6967 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6968   echo $ac_n "(cached) $ac_c" 1>&6
6969 else
6970   cat > conftest.$ac_ext <<EOF
6971 #line 6972 "configure"
6972 #include "confdefs.h"
6973 /* System header to define __stub macros and hopefully few prototypes,
6974     which can conflict with char $ac_func(); below.  */
6975 #include <assert.h>
6976 /* Override any gcc2 internal prototype to avoid an error.  */
6977 /* We use char because int might match the return type of a gcc2
6978     builtin and then its argument prototype would still apply.  */
6979 char $ac_func();
6980
6981 int main() {
6982
6983 /* The GNU C library defines this for functions which it implements
6984     to always fail with ENOSYS.  Some functions are actually named
6985     something starting with __ and the normal name is an alias.  */
6986 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6987 choke me
6988 #else
6989 $ac_func();
6990 #endif
6991
6992 ; return 0; }
6993 EOF
6994 if { (eval echo configure:6995: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6995   rm -rf conftest*
6996   eval "ac_cv_func_$ac_func=yes"
6997 else
6998   echo "configure: failed program was:" >&5
6999   cat conftest.$ac_ext >&5
7000   rm -rf conftest*
7001   eval "ac_cv_func_$ac_func=no"
7002 fi
7003 rm -f conftest*
7004 fi
7005
7006 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7007   echo "$ac_t""yes" 1>&6
7008     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7009   cat >> confdefs.h <<EOF
7010 #define $ac_tr_func 1
7011 EOF
7012
7013 else
7014   echo "$ac_t""no" 1>&6
7015 fi
7016 done
7017
7018   fi
7019
7020
7021
7022   ac_ext=C
7023 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7024 ac_cpp='$CXXCPP $CPPFLAGS'
7025 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7026 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7027 cross_compiling=$ac_cv_prog_cxx_cross
7028
7029   echo $ac_n "checking for sincosf declaration""... $ac_c" 1>&6
7030 echo "configure:7031: checking for sincosf declaration" >&5
7031   cat > conftest.$ac_ext <<EOF
7032 #line 7033 "configure"
7033 #include "confdefs.h"
7034 #include <math.h>
7035 int main() {
7036  sincosf(0, 0, 0);
7037 ; return 0; }
7038 EOF
7039 if { (eval echo configure:7040: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7040   rm -rf conftest*
7041   use_sincosf=yes
7042 else
7043   echo "configure: failed program was:" >&5
7044   cat conftest.$ac_ext >&5
7045   rm -rf conftest*
7046   use_sincosf=no
7047 fi
7048 rm -f conftest*
7049   echo "$ac_t""$use_sincosf" 1>&6
7050   ac_ext=c
7051 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7052 ac_cpp='$CPP $CPPFLAGS'
7053 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7054 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7055 cross_compiling=$ac_cv_prog_cc_cross
7056
7057   if test x$use_sincosf = x"yes"; then
7058     for ac_func in sincosf
7059 do
7060 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7061 echo "configure:7062: checking for $ac_func" >&5
7062 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7063   echo $ac_n "(cached) $ac_c" 1>&6
7064 else
7065   cat > conftest.$ac_ext <<EOF
7066 #line 7067 "configure"
7067 #include "confdefs.h"
7068 /* System header to define __stub macros and hopefully few prototypes,
7069     which can conflict with char $ac_func(); below.  */
7070 #include <assert.h>
7071 /* Override any gcc2 internal prototype to avoid an error.  */
7072 /* We use char because int might match the return type of a gcc2
7073     builtin and then its argument prototype would still apply.  */
7074 char $ac_func();
7075
7076 int main() {
7077
7078 /* The GNU C library defines this for functions which it implements
7079     to always fail with ENOSYS.  Some functions are actually named
7080     something starting with __ and the normal name is an alias.  */
7081 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7082 choke me
7083 #else
7084 $ac_func();
7085 #endif
7086
7087 ; return 0; }
7088 EOF
7089 if { (eval echo configure:7090: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7090   rm -rf conftest*
7091   eval "ac_cv_func_$ac_func=yes"
7092 else
7093   echo "configure: failed program was:" >&5
7094   cat conftest.$ac_ext >&5
7095   rm -rf conftest*
7096   eval "ac_cv_func_$ac_func=no"
7097 fi
7098 rm -f conftest*
7099 fi
7100
7101 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7102   echo "$ac_t""yes" 1>&6
7103     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7104   cat >> confdefs.h <<EOF
7105 #define $ac_tr_func 1
7106 EOF
7107
7108 else
7109   echo "$ac_t""no" 1>&6
7110 fi
7111 done
7112
7113   fi
7114
7115
7116
7117   ac_ext=C
7118 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7119 ac_cpp='$CXXCPP $CPPFLAGS'
7120 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7121 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7122 cross_compiling=$ac_cv_prog_cxx_cross
7123
7124   echo $ac_n "checking for finitef declaration""... $ac_c" 1>&6
7125 echo "configure:7126: checking for finitef declaration" >&5
7126   cat > conftest.$ac_ext <<EOF
7127 #line 7128 "configure"
7128 #include "confdefs.h"
7129 #include <math.h>
7130 int main() {
7131  finitef(0);
7132 ; return 0; }
7133 EOF
7134 if { (eval echo configure:7135: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7135   rm -rf conftest*
7136   use_finitef=yes
7137 else
7138   echo "configure: failed program was:" >&5
7139   cat conftest.$ac_ext >&5
7140   rm -rf conftest*
7141   use_finitef=no
7142 fi
7143 rm -f conftest*
7144   echo "$ac_t""$use_finitef" 1>&6
7145   ac_ext=c
7146 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7147 ac_cpp='$CPP $CPPFLAGS'
7148 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7149 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7150 cross_compiling=$ac_cv_prog_cc_cross
7151
7152   if test x$use_finitef = x"yes"; then
7153     for ac_func in finitef
7154 do
7155 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7156 echo "configure:7157: checking for $ac_func" >&5
7157 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7158   echo $ac_n "(cached) $ac_c" 1>&6
7159 else
7160   cat > conftest.$ac_ext <<EOF
7161 #line 7162 "configure"
7162 #include "confdefs.h"
7163 /* System header to define __stub macros and hopefully few prototypes,
7164     which can conflict with char $ac_func(); below.  */
7165 #include <assert.h>
7166 /* Override any gcc2 internal prototype to avoid an error.  */
7167 /* We use char because int might match the return type of a gcc2
7168     builtin and then its argument prototype would still apply.  */
7169 char $ac_func();
7170
7171 int main() {
7172
7173 /* The GNU C library defines this for functions which it implements
7174     to always fail with ENOSYS.  Some functions are actually named
7175     something starting with __ and the normal name is an alias.  */
7176 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7177 choke me
7178 #else
7179 $ac_func();
7180 #endif
7181
7182 ; return 0; }
7183 EOF
7184 if { (eval echo configure:7185: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7185   rm -rf conftest*
7186   eval "ac_cv_func_$ac_func=yes"
7187 else
7188   echo "configure: failed program was:" >&5
7189   cat conftest.$ac_ext >&5
7190   rm -rf conftest*
7191   eval "ac_cv_func_$ac_func=no"
7192 fi
7193 rm -f conftest*
7194 fi
7195
7196 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7197   echo "$ac_t""yes" 1>&6
7198     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7199   cat >> confdefs.h <<EOF
7200 #define $ac_tr_func 1
7201 EOF
7202
7203 else
7204   echo "$ac_t""no" 1>&6
7205 fi
7206 done
7207
7208   fi
7209
7210
7211
7212
7213   ac_ext=C
7214 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7215 ac_cpp='$CXXCPP $CPPFLAGS'
7216 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7217 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7218 cross_compiling=$ac_cv_prog_cxx_cross
7219
7220   echo $ac_n "checking for isnanl declaration""... $ac_c" 1>&6
7221 echo "configure:7222: checking for isnanl declaration" >&5
7222   cat > conftest.$ac_ext <<EOF
7223 #line 7224 "configure"
7224 #include "confdefs.h"
7225 #include <math.h>
7226 int main() {
7227  isnanl(0);
7228 ; return 0; }
7229 EOF
7230 if { (eval echo configure:7231: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7231   rm -rf conftest*
7232   use_isnanl=yes
7233 else
7234   echo "configure: failed program was:" >&5
7235   cat conftest.$ac_ext >&5
7236   rm -rf conftest*
7237   use_isnanl=no
7238 fi
7239 rm -f conftest*
7240   echo "$ac_t""$use_isnanl" 1>&6
7241   ac_ext=c
7242 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7243 ac_cpp='$CPP $CPPFLAGS'
7244 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7245 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7246 cross_compiling=$ac_cv_prog_cc_cross
7247
7248   if test x$use_isnanl = x"yes"; then
7249     for ac_func in isnanl
7250 do
7251 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7252 echo "configure:7253: checking for $ac_func" >&5
7253 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7254   echo $ac_n "(cached) $ac_c" 1>&6
7255 else
7256   cat > conftest.$ac_ext <<EOF
7257 #line 7258 "configure"
7258 #include "confdefs.h"
7259 /* System header to define __stub macros and hopefully few prototypes,
7260     which can conflict with char $ac_func(); below.  */
7261 #include <assert.h>
7262 /* Override any gcc2 internal prototype to avoid an error.  */
7263 /* We use char because int might match the return type of a gcc2
7264     builtin and then its argument prototype would still apply.  */
7265 char $ac_func();
7266
7267 int main() {
7268
7269 /* The GNU C library defines this for functions which it implements
7270     to always fail with ENOSYS.  Some functions are actually named
7271     something starting with __ and the normal name is an alias.  */
7272 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7273 choke me
7274 #else
7275 $ac_func();
7276 #endif
7277
7278 ; return 0; }
7279 EOF
7280 if { (eval echo configure:7281: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7281   rm -rf conftest*
7282   eval "ac_cv_func_$ac_func=yes"
7283 else
7284   echo "configure: failed program was:" >&5
7285   cat conftest.$ac_ext >&5
7286   rm -rf conftest*
7287   eval "ac_cv_func_$ac_func=no"
7288 fi
7289 rm -f conftest*
7290 fi
7291
7292 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7293   echo "$ac_t""yes" 1>&6
7294     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7295   cat >> confdefs.h <<EOF
7296 #define $ac_tr_func 1
7297 EOF
7298
7299 else
7300   echo "$ac_t""no" 1>&6
7301 fi
7302 done
7303
7304   fi
7305
7306
7307
7308   ac_ext=C
7309 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7310 ac_cpp='$CXXCPP $CPPFLAGS'
7311 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7312 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7313 cross_compiling=$ac_cv_prog_cxx_cross
7314
7315   echo $ac_n "checking for isinfl declaration""... $ac_c" 1>&6
7316 echo "configure:7317: checking for isinfl declaration" >&5
7317   cat > conftest.$ac_ext <<EOF
7318 #line 7319 "configure"
7319 #include "confdefs.h"
7320 #include <math.h>
7321 int main() {
7322  isinfl(0);
7323 ; return 0; }
7324 EOF
7325 if { (eval echo configure:7326: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7326   rm -rf conftest*
7327   use_isinfl=yes
7328 else
7329   echo "configure: failed program was:" >&5
7330   cat conftest.$ac_ext >&5
7331   rm -rf conftest*
7332   use_isinfl=no
7333 fi
7334 rm -f conftest*
7335   echo "$ac_t""$use_isinfl" 1>&6
7336   ac_ext=c
7337 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7338 ac_cpp='$CPP $CPPFLAGS'
7339 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7340 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7341 cross_compiling=$ac_cv_prog_cc_cross
7342
7343   if test x$use_isinfl = x"yes"; then
7344     for ac_func in isinfl
7345 do
7346 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7347 echo "configure:7348: checking for $ac_func" >&5
7348 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7349   echo $ac_n "(cached) $ac_c" 1>&6
7350 else
7351   cat > conftest.$ac_ext <<EOF
7352 #line 7353 "configure"
7353 #include "confdefs.h"
7354 /* System header to define __stub macros and hopefully few prototypes,
7355     which can conflict with char $ac_func(); below.  */
7356 #include <assert.h>
7357 /* Override any gcc2 internal prototype to avoid an error.  */
7358 /* We use char because int might match the return type of a gcc2
7359     builtin and then its argument prototype would still apply.  */
7360 char $ac_func();
7361
7362 int main() {
7363
7364 /* The GNU C library defines this for functions which it implements
7365     to always fail with ENOSYS.  Some functions are actually named
7366     something starting with __ and the normal name is an alias.  */
7367 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7368 choke me
7369 #else
7370 $ac_func();
7371 #endif
7372
7373 ; return 0; }
7374 EOF
7375 if { (eval echo configure:7376: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7376   rm -rf conftest*
7377   eval "ac_cv_func_$ac_func=yes"
7378 else
7379   echo "configure: failed program was:" >&5
7380   cat conftest.$ac_ext >&5
7381   rm -rf conftest*
7382   eval "ac_cv_func_$ac_func=no"
7383 fi
7384 rm -f conftest*
7385 fi
7386
7387 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7388   echo "$ac_t""yes" 1>&6
7389     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7390   cat >> confdefs.h <<EOF
7391 #define $ac_tr_func 1
7392 EOF
7393
7394 else
7395   echo "$ac_t""no" 1>&6
7396 fi
7397 done
7398
7399   fi
7400
7401
7402
7403   ac_ext=C
7404 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7405 ac_cpp='$CXXCPP $CPPFLAGS'
7406 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7407 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7408 cross_compiling=$ac_cv_prog_cxx_cross
7409
7410   echo $ac_n "checking for copysignl declaration""... $ac_c" 1>&6
7411 echo "configure:7412: checking for copysignl declaration" >&5
7412   cat > conftest.$ac_ext <<EOF
7413 #line 7414 "configure"
7414 #include "confdefs.h"
7415 #include <math.h>
7416 int main() {
7417  copysignl(0, 0);
7418 ; return 0; }
7419 EOF
7420 if { (eval echo configure:7421: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7421   rm -rf conftest*
7422   use_copysignl=yes
7423 else
7424   echo "configure: failed program was:" >&5
7425   cat conftest.$ac_ext >&5
7426   rm -rf conftest*
7427   use_copysignl=no
7428 fi
7429 rm -f conftest*
7430   echo "$ac_t""$use_copysignl" 1>&6
7431   ac_ext=c
7432 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7433 ac_cpp='$CPP $CPPFLAGS'
7434 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7435 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7436 cross_compiling=$ac_cv_prog_cc_cross
7437
7438   if test x$use_copysignl = x"yes"; then
7439     for ac_func in copysignl
7440 do
7441 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7442 echo "configure:7443: checking for $ac_func" >&5
7443 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7444   echo $ac_n "(cached) $ac_c" 1>&6
7445 else
7446   cat > conftest.$ac_ext <<EOF
7447 #line 7448 "configure"
7448 #include "confdefs.h"
7449 /* System header to define __stub macros and hopefully few prototypes,
7450     which can conflict with char $ac_func(); below.  */
7451 #include <assert.h>
7452 /* Override any gcc2 internal prototype to avoid an error.  */
7453 /* We use char because int might match the return type of a gcc2
7454     builtin and then its argument prototype would still apply.  */
7455 char $ac_func();
7456
7457 int main() {
7458
7459 /* The GNU C library defines this for functions which it implements
7460     to always fail with ENOSYS.  Some functions are actually named
7461     something starting with __ and the normal name is an alias.  */
7462 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7463 choke me
7464 #else
7465 $ac_func();
7466 #endif
7467
7468 ; return 0; }
7469 EOF
7470 if { (eval echo configure:7471: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7471   rm -rf conftest*
7472   eval "ac_cv_func_$ac_func=yes"
7473 else
7474   echo "configure: failed program was:" >&5
7475   cat conftest.$ac_ext >&5
7476   rm -rf conftest*
7477   eval "ac_cv_func_$ac_func=no"
7478 fi
7479 rm -f conftest*
7480 fi
7481
7482 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7483   echo "$ac_t""yes" 1>&6
7484     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7485   cat >> confdefs.h <<EOF
7486 #define $ac_tr_func 1
7487 EOF
7488
7489 else
7490   echo "$ac_t""no" 1>&6
7491 fi
7492 done
7493
7494   fi
7495
7496
7497
7498   ac_ext=C
7499 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7500 ac_cpp='$CXXCPP $CPPFLAGS'
7501 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7502 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7503 cross_compiling=$ac_cv_prog_cxx_cross
7504
7505   echo $ac_n "checking for acosl declaration""... $ac_c" 1>&6
7506 echo "configure:7507: checking for acosl declaration" >&5
7507   cat > conftest.$ac_ext <<EOF
7508 #line 7509 "configure"
7509 #include "confdefs.h"
7510 #include <math.h>
7511 int main() {
7512  acosl(0);
7513 ; return 0; }
7514 EOF
7515 if { (eval echo configure:7516: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7516   rm -rf conftest*
7517   use_acosl=yes
7518 else
7519   echo "configure: failed program was:" >&5
7520   cat conftest.$ac_ext >&5
7521   rm -rf conftest*
7522   use_acosl=no
7523 fi
7524 rm -f conftest*
7525   echo "$ac_t""$use_acosl" 1>&6
7526   ac_ext=c
7527 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7528 ac_cpp='$CPP $CPPFLAGS'
7529 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7530 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7531 cross_compiling=$ac_cv_prog_cc_cross
7532
7533   if test x$use_acosl = x"yes"; then
7534     for ac_func in acosl
7535 do
7536 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7537 echo "configure:7538: checking for $ac_func" >&5
7538 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7539   echo $ac_n "(cached) $ac_c" 1>&6
7540 else
7541   cat > conftest.$ac_ext <<EOF
7542 #line 7543 "configure"
7543 #include "confdefs.h"
7544 /* System header to define __stub macros and hopefully few prototypes,
7545     which can conflict with char $ac_func(); below.  */
7546 #include <assert.h>
7547 /* Override any gcc2 internal prototype to avoid an error.  */
7548 /* We use char because int might match the return type of a gcc2
7549     builtin and then its argument prototype would still apply.  */
7550 char $ac_func();
7551
7552 int main() {
7553
7554 /* The GNU C library defines this for functions which it implements
7555     to always fail with ENOSYS.  Some functions are actually named
7556     something starting with __ and the normal name is an alias.  */
7557 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7558 choke me
7559 #else
7560 $ac_func();
7561 #endif
7562
7563 ; return 0; }
7564 EOF
7565 if { (eval echo configure:7566: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7566   rm -rf conftest*
7567   eval "ac_cv_func_$ac_func=yes"
7568 else
7569   echo "configure: failed program was:" >&5
7570   cat conftest.$ac_ext >&5
7571   rm -rf conftest*
7572   eval "ac_cv_func_$ac_func=no"
7573 fi
7574 rm -f conftest*
7575 fi
7576
7577 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7578   echo "$ac_t""yes" 1>&6
7579     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7580   cat >> confdefs.h <<EOF
7581 #define $ac_tr_func 1
7582 EOF
7583
7584 else
7585   echo "$ac_t""no" 1>&6
7586 fi
7587 done
7588
7589   fi
7590
7591
7592
7593   ac_ext=C
7594 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7595 ac_cpp='$CXXCPP $CPPFLAGS'
7596 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7597 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7598 cross_compiling=$ac_cv_prog_cxx_cross
7599
7600   echo $ac_n "checking for asinl declaration""... $ac_c" 1>&6
7601 echo "configure:7602: checking for asinl declaration" >&5
7602   cat > conftest.$ac_ext <<EOF
7603 #line 7604 "configure"
7604 #include "confdefs.h"
7605 #include <math.h>
7606 int main() {
7607  asinl(0);
7608 ; return 0; }
7609 EOF
7610 if { (eval echo configure:7611: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7611   rm -rf conftest*
7612   use_asinl=yes
7613 else
7614   echo "configure: failed program was:" >&5
7615   cat conftest.$ac_ext >&5
7616   rm -rf conftest*
7617   use_asinl=no
7618 fi
7619 rm -f conftest*
7620   echo "$ac_t""$use_asinl" 1>&6
7621   ac_ext=c
7622 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7623 ac_cpp='$CPP $CPPFLAGS'
7624 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7625 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7626 cross_compiling=$ac_cv_prog_cc_cross
7627
7628   if test x$use_asinl = x"yes"; then
7629     for ac_func in asinl
7630 do
7631 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7632 echo "configure:7633: checking for $ac_func" >&5
7633 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7634   echo $ac_n "(cached) $ac_c" 1>&6
7635 else
7636   cat > conftest.$ac_ext <<EOF
7637 #line 7638 "configure"
7638 #include "confdefs.h"
7639 /* System header to define __stub macros and hopefully few prototypes,
7640     which can conflict with char $ac_func(); below.  */
7641 #include <assert.h>
7642 /* Override any gcc2 internal prototype to avoid an error.  */
7643 /* We use char because int might match the return type of a gcc2
7644     builtin and then its argument prototype would still apply.  */
7645 char $ac_func();
7646
7647 int main() {
7648
7649 /* The GNU C library defines this for functions which it implements
7650     to always fail with ENOSYS.  Some functions are actually named
7651     something starting with __ and the normal name is an alias.  */
7652 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7653 choke me
7654 #else
7655 $ac_func();
7656 #endif
7657
7658 ; return 0; }
7659 EOF
7660 if { (eval echo configure:7661: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7661   rm -rf conftest*
7662   eval "ac_cv_func_$ac_func=yes"
7663 else
7664   echo "configure: failed program was:" >&5
7665   cat conftest.$ac_ext >&5
7666   rm -rf conftest*
7667   eval "ac_cv_func_$ac_func=no"
7668 fi
7669 rm -f conftest*
7670 fi
7671
7672 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7673   echo "$ac_t""yes" 1>&6
7674     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7675   cat >> confdefs.h <<EOF
7676 #define $ac_tr_func 1
7677 EOF
7678
7679 else
7680   echo "$ac_t""no" 1>&6
7681 fi
7682 done
7683
7684   fi
7685
7686
7687
7688   ac_ext=C
7689 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7690 ac_cpp='$CXXCPP $CPPFLAGS'
7691 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7692 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7693 cross_compiling=$ac_cv_prog_cxx_cross
7694
7695   echo $ac_n "checking for atanl declaration""... $ac_c" 1>&6
7696 echo "configure:7697: checking for atanl declaration" >&5
7697   cat > conftest.$ac_ext <<EOF
7698 #line 7699 "configure"
7699 #include "confdefs.h"
7700 #include <math.h>
7701 int main() {
7702  atanl(0);
7703 ; return 0; }
7704 EOF
7705 if { (eval echo configure:7706: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7706   rm -rf conftest*
7707   use_atanl=yes
7708 else
7709   echo "configure: failed program was:" >&5
7710   cat conftest.$ac_ext >&5
7711   rm -rf conftest*
7712   use_atanl=no
7713 fi
7714 rm -f conftest*
7715   echo "$ac_t""$use_atanl" 1>&6
7716   ac_ext=c
7717 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7718 ac_cpp='$CPP $CPPFLAGS'
7719 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7720 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7721 cross_compiling=$ac_cv_prog_cc_cross
7722
7723   if test x$use_atanl = x"yes"; then
7724     for ac_func in atanl
7725 do
7726 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7727 echo "configure:7728: checking for $ac_func" >&5
7728 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7729   echo $ac_n "(cached) $ac_c" 1>&6
7730 else
7731   cat > conftest.$ac_ext <<EOF
7732 #line 7733 "configure"
7733 #include "confdefs.h"
7734 /* System header to define __stub macros and hopefully few prototypes,
7735     which can conflict with char $ac_func(); below.  */
7736 #include <assert.h>
7737 /* Override any gcc2 internal prototype to avoid an error.  */
7738 /* We use char because int might match the return type of a gcc2
7739     builtin and then its argument prototype would still apply.  */
7740 char $ac_func();
7741
7742 int main() {
7743
7744 /* The GNU C library defines this for functions which it implements
7745     to always fail with ENOSYS.  Some functions are actually named
7746     something starting with __ and the normal name is an alias.  */
7747 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7748 choke me
7749 #else
7750 $ac_func();
7751 #endif
7752
7753 ; return 0; }
7754 EOF
7755 if { (eval echo configure:7756: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7756   rm -rf conftest*
7757   eval "ac_cv_func_$ac_func=yes"
7758 else
7759   echo "configure: failed program was:" >&5
7760   cat conftest.$ac_ext >&5
7761   rm -rf conftest*
7762   eval "ac_cv_func_$ac_func=no"
7763 fi
7764 rm -f conftest*
7765 fi
7766
7767 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7768   echo "$ac_t""yes" 1>&6
7769     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7770   cat >> confdefs.h <<EOF
7771 #define $ac_tr_func 1
7772 EOF
7773
7774 else
7775   echo "$ac_t""no" 1>&6
7776 fi
7777 done
7778
7779   fi
7780
7781
7782
7783   ac_ext=C
7784 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7785 ac_cpp='$CXXCPP $CPPFLAGS'
7786 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7787 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7788 cross_compiling=$ac_cv_prog_cxx_cross
7789
7790   echo $ac_n "checking for atan2l declaration""... $ac_c" 1>&6
7791 echo "configure:7792: checking for atan2l declaration" >&5
7792   cat > conftest.$ac_ext <<EOF
7793 #line 7794 "configure"
7794 #include "confdefs.h"
7795 #include <math.h>
7796 int main() {
7797  atan2l(0, 0);
7798 ; return 0; }
7799 EOF
7800 if { (eval echo configure:7801: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7801   rm -rf conftest*
7802   use_atan2l=yes
7803 else
7804   echo "configure: failed program was:" >&5
7805   cat conftest.$ac_ext >&5
7806   rm -rf conftest*
7807   use_atan2l=no
7808 fi
7809 rm -f conftest*
7810   echo "$ac_t""$use_atan2l" 1>&6
7811   ac_ext=c
7812 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7813 ac_cpp='$CPP $CPPFLAGS'
7814 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7815 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7816 cross_compiling=$ac_cv_prog_cc_cross
7817
7818   if test x$use_atan2l = x"yes"; then
7819     for ac_func in atan2l
7820 do
7821 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7822 echo "configure:7823: checking for $ac_func" >&5
7823 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7824   echo $ac_n "(cached) $ac_c" 1>&6
7825 else
7826   cat > conftest.$ac_ext <<EOF
7827 #line 7828 "configure"
7828 #include "confdefs.h"
7829 /* System header to define __stub macros and hopefully few prototypes,
7830     which can conflict with char $ac_func(); below.  */
7831 #include <assert.h>
7832 /* Override any gcc2 internal prototype to avoid an error.  */
7833 /* We use char because int might match the return type of a gcc2
7834     builtin and then its argument prototype would still apply.  */
7835 char $ac_func();
7836
7837 int main() {
7838
7839 /* The GNU C library defines this for functions which it implements
7840     to always fail with ENOSYS.  Some functions are actually named
7841     something starting with __ and the normal name is an alias.  */
7842 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7843 choke me
7844 #else
7845 $ac_func();
7846 #endif
7847
7848 ; return 0; }
7849 EOF
7850 if { (eval echo configure:7851: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7851   rm -rf conftest*
7852   eval "ac_cv_func_$ac_func=yes"
7853 else
7854   echo "configure: failed program was:" >&5
7855   cat conftest.$ac_ext >&5
7856   rm -rf conftest*
7857   eval "ac_cv_func_$ac_func=no"
7858 fi
7859 rm -f conftest*
7860 fi
7861
7862 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7863   echo "$ac_t""yes" 1>&6
7864     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7865   cat >> confdefs.h <<EOF
7866 #define $ac_tr_func 1
7867 EOF
7868
7869 else
7870   echo "$ac_t""no" 1>&6
7871 fi
7872 done
7873
7874   fi
7875
7876
7877
7878   ac_ext=C
7879 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7880 ac_cpp='$CXXCPP $CPPFLAGS'
7881 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7882 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7883 cross_compiling=$ac_cv_prog_cxx_cross
7884
7885   echo $ac_n "checking for ceill declaration""... $ac_c" 1>&6
7886 echo "configure:7887: checking for ceill declaration" >&5
7887   cat > conftest.$ac_ext <<EOF
7888 #line 7889 "configure"
7889 #include "confdefs.h"
7890 #include <math.h>
7891 int main() {
7892  ceill(0);
7893 ; return 0; }
7894 EOF
7895 if { (eval echo configure:7896: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7896   rm -rf conftest*
7897   use_ceill=yes
7898 else
7899   echo "configure: failed program was:" >&5
7900   cat conftest.$ac_ext >&5
7901   rm -rf conftest*
7902   use_ceill=no
7903 fi
7904 rm -f conftest*
7905   echo "$ac_t""$use_ceill" 1>&6
7906   ac_ext=c
7907 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7908 ac_cpp='$CPP $CPPFLAGS'
7909 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7910 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7911 cross_compiling=$ac_cv_prog_cc_cross
7912
7913   if test x$use_ceill = x"yes"; then
7914     for ac_func in ceill
7915 do
7916 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7917 echo "configure:7918: checking for $ac_func" >&5
7918 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7919   echo $ac_n "(cached) $ac_c" 1>&6
7920 else
7921   cat > conftest.$ac_ext <<EOF
7922 #line 7923 "configure"
7923 #include "confdefs.h"
7924 /* System header to define __stub macros and hopefully few prototypes,
7925     which can conflict with char $ac_func(); below.  */
7926 #include <assert.h>
7927 /* Override any gcc2 internal prototype to avoid an error.  */
7928 /* We use char because int might match the return type of a gcc2
7929     builtin and then its argument prototype would still apply.  */
7930 char $ac_func();
7931
7932 int main() {
7933
7934 /* The GNU C library defines this for functions which it implements
7935     to always fail with ENOSYS.  Some functions are actually named
7936     something starting with __ and the normal name is an alias.  */
7937 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7938 choke me
7939 #else
7940 $ac_func();
7941 #endif
7942
7943 ; return 0; }
7944 EOF
7945 if { (eval echo configure:7946: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7946   rm -rf conftest*
7947   eval "ac_cv_func_$ac_func=yes"
7948 else
7949   echo "configure: failed program was:" >&5
7950   cat conftest.$ac_ext >&5
7951   rm -rf conftest*
7952   eval "ac_cv_func_$ac_func=no"
7953 fi
7954 rm -f conftest*
7955 fi
7956
7957 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7958   echo "$ac_t""yes" 1>&6
7959     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7960   cat >> confdefs.h <<EOF
7961 #define $ac_tr_func 1
7962 EOF
7963
7964 else
7965   echo "$ac_t""no" 1>&6
7966 fi
7967 done
7968
7969   fi
7970
7971
7972
7973   ac_ext=C
7974 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7975 ac_cpp='$CXXCPP $CPPFLAGS'
7976 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7977 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7978 cross_compiling=$ac_cv_prog_cxx_cross
7979
7980   echo $ac_n "checking for cosl declaration""... $ac_c" 1>&6
7981 echo "configure:7982: checking for cosl declaration" >&5
7982   cat > conftest.$ac_ext <<EOF
7983 #line 7984 "configure"
7984 #include "confdefs.h"
7985 #include <math.h>
7986 int main() {
7987  cosl(0);
7988 ; return 0; }
7989 EOF
7990 if { (eval echo configure:7991: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7991   rm -rf conftest*
7992   use_cosl=yes
7993 else
7994   echo "configure: failed program was:" >&5
7995   cat conftest.$ac_ext >&5
7996   rm -rf conftest*
7997   use_cosl=no
7998 fi
7999 rm -f conftest*
8000   echo "$ac_t""$use_cosl" 1>&6
8001   ac_ext=c
8002 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8003 ac_cpp='$CPP $CPPFLAGS'
8004 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8005 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8006 cross_compiling=$ac_cv_prog_cc_cross
8007
8008   if test x$use_cosl = x"yes"; then
8009     for ac_func in cosl
8010 do
8011 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8012 echo "configure:8013: checking for $ac_func" >&5
8013 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8014   echo $ac_n "(cached) $ac_c" 1>&6
8015 else
8016   cat > conftest.$ac_ext <<EOF
8017 #line 8018 "configure"
8018 #include "confdefs.h"
8019 /* System header to define __stub macros and hopefully few prototypes,
8020     which can conflict with char $ac_func(); below.  */
8021 #include <assert.h>
8022 /* Override any gcc2 internal prototype to avoid an error.  */
8023 /* We use char because int might match the return type of a gcc2
8024     builtin and then its argument prototype would still apply.  */
8025 char $ac_func();
8026
8027 int main() {
8028
8029 /* The GNU C library defines this for functions which it implements
8030     to always fail with ENOSYS.  Some functions are actually named
8031     something starting with __ and the normal name is an alias.  */
8032 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8033 choke me
8034 #else
8035 $ac_func();
8036 #endif
8037
8038 ; return 0; }
8039 EOF
8040 if { (eval echo configure:8041: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8041   rm -rf conftest*
8042   eval "ac_cv_func_$ac_func=yes"
8043 else
8044   echo "configure: failed program was:" >&5
8045   cat conftest.$ac_ext >&5
8046   rm -rf conftest*
8047   eval "ac_cv_func_$ac_func=no"
8048 fi
8049 rm -f conftest*
8050 fi
8051
8052 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8053   echo "$ac_t""yes" 1>&6
8054     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8055   cat >> confdefs.h <<EOF
8056 #define $ac_tr_func 1
8057 EOF
8058
8059 else
8060   echo "$ac_t""no" 1>&6
8061 fi
8062 done
8063
8064   fi
8065
8066
8067
8068   ac_ext=C
8069 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8070 ac_cpp='$CXXCPP $CPPFLAGS'
8071 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8072 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8073 cross_compiling=$ac_cv_prog_cxx_cross
8074
8075   echo $ac_n "checking for coshl declaration""... $ac_c" 1>&6
8076 echo "configure:8077: checking for coshl declaration" >&5
8077   cat > conftest.$ac_ext <<EOF
8078 #line 8079 "configure"
8079 #include "confdefs.h"
8080 #include <math.h>
8081 int main() {
8082  coshl(0);
8083 ; return 0; }
8084 EOF
8085 if { (eval echo configure:8086: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8086   rm -rf conftest*
8087   use_coshl=yes
8088 else
8089   echo "configure: failed program was:" >&5
8090   cat conftest.$ac_ext >&5
8091   rm -rf conftest*
8092   use_coshl=no
8093 fi
8094 rm -f conftest*
8095   echo "$ac_t""$use_coshl" 1>&6
8096   ac_ext=c
8097 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8098 ac_cpp='$CPP $CPPFLAGS'
8099 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8100 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8101 cross_compiling=$ac_cv_prog_cc_cross
8102
8103   if test x$use_coshl = x"yes"; then
8104     for ac_func in coshl
8105 do
8106 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8107 echo "configure:8108: checking for $ac_func" >&5
8108 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8109   echo $ac_n "(cached) $ac_c" 1>&6
8110 else
8111   cat > conftest.$ac_ext <<EOF
8112 #line 8113 "configure"
8113 #include "confdefs.h"
8114 /* System header to define __stub macros and hopefully few prototypes,
8115     which can conflict with char $ac_func(); below.  */
8116 #include <assert.h>
8117 /* Override any gcc2 internal prototype to avoid an error.  */
8118 /* We use char because int might match the return type of a gcc2
8119     builtin and then its argument prototype would still apply.  */
8120 char $ac_func();
8121
8122 int main() {
8123
8124 /* The GNU C library defines this for functions which it implements
8125     to always fail with ENOSYS.  Some functions are actually named
8126     something starting with __ and the normal name is an alias.  */
8127 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8128 choke me
8129 #else
8130 $ac_func();
8131 #endif
8132
8133 ; return 0; }
8134 EOF
8135 if { (eval echo configure:8136: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8136   rm -rf conftest*
8137   eval "ac_cv_func_$ac_func=yes"
8138 else
8139   echo "configure: failed program was:" >&5
8140   cat conftest.$ac_ext >&5
8141   rm -rf conftest*
8142   eval "ac_cv_func_$ac_func=no"
8143 fi
8144 rm -f conftest*
8145 fi
8146
8147 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8148   echo "$ac_t""yes" 1>&6
8149     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8150   cat >> confdefs.h <<EOF
8151 #define $ac_tr_func 1
8152 EOF
8153
8154 else
8155   echo "$ac_t""no" 1>&6
8156 fi
8157 done
8158
8159   fi
8160
8161
8162
8163   ac_ext=C
8164 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8165 ac_cpp='$CXXCPP $CPPFLAGS'
8166 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8167 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8168 cross_compiling=$ac_cv_prog_cxx_cross
8169
8170   echo $ac_n "checking for expl declaration""... $ac_c" 1>&6
8171 echo "configure:8172: checking for expl declaration" >&5
8172   cat > conftest.$ac_ext <<EOF
8173 #line 8174 "configure"
8174 #include "confdefs.h"
8175 #include <math.h>
8176 int main() {
8177  expl(0);
8178 ; return 0; }
8179 EOF
8180 if { (eval echo configure:8181: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8181   rm -rf conftest*
8182   use_expl=yes
8183 else
8184   echo "configure: failed program was:" >&5
8185   cat conftest.$ac_ext >&5
8186   rm -rf conftest*
8187   use_expl=no
8188 fi
8189 rm -f conftest*
8190   echo "$ac_t""$use_expl" 1>&6
8191   ac_ext=c
8192 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8193 ac_cpp='$CPP $CPPFLAGS'
8194 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8195 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8196 cross_compiling=$ac_cv_prog_cc_cross
8197
8198   if test x$use_expl = x"yes"; then
8199     for ac_func in expl
8200 do
8201 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8202 echo "configure:8203: checking for $ac_func" >&5
8203 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8204   echo $ac_n "(cached) $ac_c" 1>&6
8205 else
8206   cat > conftest.$ac_ext <<EOF
8207 #line 8208 "configure"
8208 #include "confdefs.h"
8209 /* System header to define __stub macros and hopefully few prototypes,
8210     which can conflict with char $ac_func(); below.  */
8211 #include <assert.h>
8212 /* Override any gcc2 internal prototype to avoid an error.  */
8213 /* We use char because int might match the return type of a gcc2
8214     builtin and then its argument prototype would still apply.  */
8215 char $ac_func();
8216
8217 int main() {
8218
8219 /* The GNU C library defines this for functions which it implements
8220     to always fail with ENOSYS.  Some functions are actually named
8221     something starting with __ and the normal name is an alias.  */
8222 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8223 choke me
8224 #else
8225 $ac_func();
8226 #endif
8227
8228 ; return 0; }
8229 EOF
8230 if { (eval echo configure:8231: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8231   rm -rf conftest*
8232   eval "ac_cv_func_$ac_func=yes"
8233 else
8234   echo "configure: failed program was:" >&5
8235   cat conftest.$ac_ext >&5
8236   rm -rf conftest*
8237   eval "ac_cv_func_$ac_func=no"
8238 fi
8239 rm -f conftest*
8240 fi
8241
8242 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8243   echo "$ac_t""yes" 1>&6
8244     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8245   cat >> confdefs.h <<EOF
8246 #define $ac_tr_func 1
8247 EOF
8248
8249 else
8250   echo "$ac_t""no" 1>&6
8251 fi
8252 done
8253
8254   fi
8255
8256
8257
8258   ac_ext=C
8259 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8260 ac_cpp='$CXXCPP $CPPFLAGS'
8261 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8262 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8263 cross_compiling=$ac_cv_prog_cxx_cross
8264
8265   echo $ac_n "checking for fabsl declaration""... $ac_c" 1>&6
8266 echo "configure:8267: checking for fabsl declaration" >&5
8267   cat > conftest.$ac_ext <<EOF
8268 #line 8269 "configure"
8269 #include "confdefs.h"
8270 #include <math.h>
8271 int main() {
8272  fabsl(0);
8273 ; return 0; }
8274 EOF
8275 if { (eval echo configure:8276: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8276   rm -rf conftest*
8277   use_fabsl=yes
8278 else
8279   echo "configure: failed program was:" >&5
8280   cat conftest.$ac_ext >&5
8281   rm -rf conftest*
8282   use_fabsl=no
8283 fi
8284 rm -f conftest*
8285   echo "$ac_t""$use_fabsl" 1>&6
8286   ac_ext=c
8287 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8288 ac_cpp='$CPP $CPPFLAGS'
8289 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8290 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8291 cross_compiling=$ac_cv_prog_cc_cross
8292
8293   if test x$use_fabsl = x"yes"; then
8294     for ac_func in fabsl
8295 do
8296 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8297 echo "configure:8298: checking for $ac_func" >&5
8298 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8299   echo $ac_n "(cached) $ac_c" 1>&6
8300 else
8301   cat > conftest.$ac_ext <<EOF
8302 #line 8303 "configure"
8303 #include "confdefs.h"
8304 /* System header to define __stub macros and hopefully few prototypes,
8305     which can conflict with char $ac_func(); below.  */
8306 #include <assert.h>
8307 /* Override any gcc2 internal prototype to avoid an error.  */
8308 /* We use char because int might match the return type of a gcc2
8309     builtin and then its argument prototype would still apply.  */
8310 char $ac_func();
8311
8312 int main() {
8313
8314 /* The GNU C library defines this for functions which it implements
8315     to always fail with ENOSYS.  Some functions are actually named
8316     something starting with __ and the normal name is an alias.  */
8317 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8318 choke me
8319 #else
8320 $ac_func();
8321 #endif
8322
8323 ; return 0; }
8324 EOF
8325 if { (eval echo configure:8326: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8326   rm -rf conftest*
8327   eval "ac_cv_func_$ac_func=yes"
8328 else
8329   echo "configure: failed program was:" >&5
8330   cat conftest.$ac_ext >&5
8331   rm -rf conftest*
8332   eval "ac_cv_func_$ac_func=no"
8333 fi
8334 rm -f conftest*
8335 fi
8336
8337 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8338   echo "$ac_t""yes" 1>&6
8339     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8340   cat >> confdefs.h <<EOF
8341 #define $ac_tr_func 1
8342 EOF
8343
8344 else
8345   echo "$ac_t""no" 1>&6
8346 fi
8347 done
8348
8349   fi
8350
8351
8352
8353   ac_ext=C
8354 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8355 ac_cpp='$CXXCPP $CPPFLAGS'
8356 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8357 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8358 cross_compiling=$ac_cv_prog_cxx_cross
8359
8360   echo $ac_n "checking for floorl declaration""... $ac_c" 1>&6
8361 echo "configure:8362: checking for floorl declaration" >&5
8362   cat > conftest.$ac_ext <<EOF
8363 #line 8364 "configure"
8364 #include "confdefs.h"
8365 #include <math.h>
8366 int main() {
8367  floorl(0);
8368 ; return 0; }
8369 EOF
8370 if { (eval echo configure:8371: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8371   rm -rf conftest*
8372   use_floorl=yes
8373 else
8374   echo "configure: failed program was:" >&5
8375   cat conftest.$ac_ext >&5
8376   rm -rf conftest*
8377   use_floorl=no
8378 fi
8379 rm -f conftest*
8380   echo "$ac_t""$use_floorl" 1>&6
8381   ac_ext=c
8382 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8383 ac_cpp='$CPP $CPPFLAGS'
8384 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8385 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8386 cross_compiling=$ac_cv_prog_cc_cross
8387
8388   if test x$use_floorl = x"yes"; then
8389     for ac_func in floorl
8390 do
8391 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8392 echo "configure:8393: checking for $ac_func" >&5
8393 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8394   echo $ac_n "(cached) $ac_c" 1>&6
8395 else
8396   cat > conftest.$ac_ext <<EOF
8397 #line 8398 "configure"
8398 #include "confdefs.h"
8399 /* System header to define __stub macros and hopefully few prototypes,
8400     which can conflict with char $ac_func(); below.  */
8401 #include <assert.h>
8402 /* Override any gcc2 internal prototype to avoid an error.  */
8403 /* We use char because int might match the return type of a gcc2
8404     builtin and then its argument prototype would still apply.  */
8405 char $ac_func();
8406
8407 int main() {
8408
8409 /* The GNU C library defines this for functions which it implements
8410     to always fail with ENOSYS.  Some functions are actually named
8411     something starting with __ and the normal name is an alias.  */
8412 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8413 choke me
8414 #else
8415 $ac_func();
8416 #endif
8417
8418 ; return 0; }
8419 EOF
8420 if { (eval echo configure:8421: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8421   rm -rf conftest*
8422   eval "ac_cv_func_$ac_func=yes"
8423 else
8424   echo "configure: failed program was:" >&5
8425   cat conftest.$ac_ext >&5
8426   rm -rf conftest*
8427   eval "ac_cv_func_$ac_func=no"
8428 fi
8429 rm -f conftest*
8430 fi
8431
8432 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8433   echo "$ac_t""yes" 1>&6
8434     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8435   cat >> confdefs.h <<EOF
8436 #define $ac_tr_func 1
8437 EOF
8438
8439 else
8440   echo "$ac_t""no" 1>&6
8441 fi
8442 done
8443
8444   fi
8445
8446
8447
8448   ac_ext=C
8449 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8450 ac_cpp='$CXXCPP $CPPFLAGS'
8451 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8452 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8453 cross_compiling=$ac_cv_prog_cxx_cross
8454
8455   echo $ac_n "checking for fmodl declaration""... $ac_c" 1>&6
8456 echo "configure:8457: checking for fmodl declaration" >&5
8457   cat > conftest.$ac_ext <<EOF
8458 #line 8459 "configure"
8459 #include "confdefs.h"
8460 #include <math.h>
8461 int main() {
8462  fmodl(0, 0);
8463 ; return 0; }
8464 EOF
8465 if { (eval echo configure:8466: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8466   rm -rf conftest*
8467   use_fmodl=yes
8468 else
8469   echo "configure: failed program was:" >&5
8470   cat conftest.$ac_ext >&5
8471   rm -rf conftest*
8472   use_fmodl=no
8473 fi
8474 rm -f conftest*
8475   echo "$ac_t""$use_fmodl" 1>&6
8476   ac_ext=c
8477 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8478 ac_cpp='$CPP $CPPFLAGS'
8479 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8480 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8481 cross_compiling=$ac_cv_prog_cc_cross
8482
8483   if test x$use_fmodl = x"yes"; then
8484     for ac_func in fmodl
8485 do
8486 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8487 echo "configure:8488: checking for $ac_func" >&5
8488 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8489   echo $ac_n "(cached) $ac_c" 1>&6
8490 else
8491   cat > conftest.$ac_ext <<EOF
8492 #line 8493 "configure"
8493 #include "confdefs.h"
8494 /* System header to define __stub macros and hopefully few prototypes,
8495     which can conflict with char $ac_func(); below.  */
8496 #include <assert.h>
8497 /* Override any gcc2 internal prototype to avoid an error.  */
8498 /* We use char because int might match the return type of a gcc2
8499     builtin and then its argument prototype would still apply.  */
8500 char $ac_func();
8501
8502 int main() {
8503
8504 /* The GNU C library defines this for functions which it implements
8505     to always fail with ENOSYS.  Some functions are actually named
8506     something starting with __ and the normal name is an alias.  */
8507 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8508 choke me
8509 #else
8510 $ac_func();
8511 #endif
8512
8513 ; return 0; }
8514 EOF
8515 if { (eval echo configure:8516: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8516   rm -rf conftest*
8517   eval "ac_cv_func_$ac_func=yes"
8518 else
8519   echo "configure: failed program was:" >&5
8520   cat conftest.$ac_ext >&5
8521   rm -rf conftest*
8522   eval "ac_cv_func_$ac_func=no"
8523 fi
8524 rm -f conftest*
8525 fi
8526
8527 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8528   echo "$ac_t""yes" 1>&6
8529     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8530   cat >> confdefs.h <<EOF
8531 #define $ac_tr_func 1
8532 EOF
8533
8534 else
8535   echo "$ac_t""no" 1>&6
8536 fi
8537 done
8538
8539   fi
8540
8541
8542
8543   ac_ext=C
8544 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8545 ac_cpp='$CXXCPP $CPPFLAGS'
8546 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8547 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8548 cross_compiling=$ac_cv_prog_cxx_cross
8549
8550   echo $ac_n "checking for frexpl declaration""... $ac_c" 1>&6
8551 echo "configure:8552: checking for frexpl declaration" >&5
8552   cat > conftest.$ac_ext <<EOF
8553 #line 8554 "configure"
8554 #include "confdefs.h"
8555 #include <math.h>
8556 int main() {
8557  frexpl(0, 0);
8558 ; return 0; }
8559 EOF
8560 if { (eval echo configure:8561: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8561   rm -rf conftest*
8562   use_frexpl=yes
8563 else
8564   echo "configure: failed program was:" >&5
8565   cat conftest.$ac_ext >&5
8566   rm -rf conftest*
8567   use_frexpl=no
8568 fi
8569 rm -f conftest*
8570   echo "$ac_t""$use_frexpl" 1>&6
8571   ac_ext=c
8572 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8573 ac_cpp='$CPP $CPPFLAGS'
8574 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8575 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8576 cross_compiling=$ac_cv_prog_cc_cross
8577
8578   if test x$use_frexpl = x"yes"; then
8579     for ac_func in frexpl
8580 do
8581 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8582 echo "configure:8583: checking for $ac_func" >&5
8583 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8584   echo $ac_n "(cached) $ac_c" 1>&6
8585 else
8586   cat > conftest.$ac_ext <<EOF
8587 #line 8588 "configure"
8588 #include "confdefs.h"
8589 /* System header to define __stub macros and hopefully few prototypes,
8590     which can conflict with char $ac_func(); below.  */
8591 #include <assert.h>
8592 /* Override any gcc2 internal prototype to avoid an error.  */
8593 /* We use char because int might match the return type of a gcc2
8594     builtin and then its argument prototype would still apply.  */
8595 char $ac_func();
8596
8597 int main() {
8598
8599 /* The GNU C library defines this for functions which it implements
8600     to always fail with ENOSYS.  Some functions are actually named
8601     something starting with __ and the normal name is an alias.  */
8602 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8603 choke me
8604 #else
8605 $ac_func();
8606 #endif
8607
8608 ; return 0; }
8609 EOF
8610 if { (eval echo configure:8611: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8611   rm -rf conftest*
8612   eval "ac_cv_func_$ac_func=yes"
8613 else
8614   echo "configure: failed program was:" >&5
8615   cat conftest.$ac_ext >&5
8616   rm -rf conftest*
8617   eval "ac_cv_func_$ac_func=no"
8618 fi
8619 rm -f conftest*
8620 fi
8621
8622 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8623   echo "$ac_t""yes" 1>&6
8624     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8625   cat >> confdefs.h <<EOF
8626 #define $ac_tr_func 1
8627 EOF
8628
8629 else
8630   echo "$ac_t""no" 1>&6
8631 fi
8632 done
8633
8634   fi
8635
8636
8637
8638   ac_ext=C
8639 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8640 ac_cpp='$CXXCPP $CPPFLAGS'
8641 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8642 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8643 cross_compiling=$ac_cv_prog_cxx_cross
8644
8645   echo $ac_n "checking for ldexpl declaration""... $ac_c" 1>&6
8646 echo "configure:8647: checking for ldexpl declaration" >&5
8647   cat > conftest.$ac_ext <<EOF
8648 #line 8649 "configure"
8649 #include "confdefs.h"
8650 #include <math.h>
8651 int main() {
8652  ldexpl(0, 0);
8653 ; return 0; }
8654 EOF
8655 if { (eval echo configure:8656: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8656   rm -rf conftest*
8657   use_ldexpl=yes
8658 else
8659   echo "configure: failed program was:" >&5
8660   cat conftest.$ac_ext >&5
8661   rm -rf conftest*
8662   use_ldexpl=no
8663 fi
8664 rm -f conftest*
8665   echo "$ac_t""$use_ldexpl" 1>&6
8666   ac_ext=c
8667 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8668 ac_cpp='$CPP $CPPFLAGS'
8669 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8670 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8671 cross_compiling=$ac_cv_prog_cc_cross
8672
8673   if test x$use_ldexpl = x"yes"; then
8674     for ac_func in ldexpl
8675 do
8676 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8677 echo "configure:8678: checking for $ac_func" >&5
8678 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8679   echo $ac_n "(cached) $ac_c" 1>&6
8680 else
8681   cat > conftest.$ac_ext <<EOF
8682 #line 8683 "configure"
8683 #include "confdefs.h"
8684 /* System header to define __stub macros and hopefully few prototypes,
8685     which can conflict with char $ac_func(); below.  */
8686 #include <assert.h>
8687 /* Override any gcc2 internal prototype to avoid an error.  */
8688 /* We use char because int might match the return type of a gcc2
8689     builtin and then its argument prototype would still apply.  */
8690 char $ac_func();
8691
8692 int main() {
8693
8694 /* The GNU C library defines this for functions which it implements
8695     to always fail with ENOSYS.  Some functions are actually named
8696     something starting with __ and the normal name is an alias.  */
8697 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8698 choke me
8699 #else
8700 $ac_func();
8701 #endif
8702
8703 ; return 0; }
8704 EOF
8705 if { (eval echo configure:8706: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8706   rm -rf conftest*
8707   eval "ac_cv_func_$ac_func=yes"
8708 else
8709   echo "configure: failed program was:" >&5
8710   cat conftest.$ac_ext >&5
8711   rm -rf conftest*
8712   eval "ac_cv_func_$ac_func=no"
8713 fi
8714 rm -f conftest*
8715 fi
8716
8717 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8718   echo "$ac_t""yes" 1>&6
8719     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8720   cat >> confdefs.h <<EOF
8721 #define $ac_tr_func 1
8722 EOF
8723
8724 else
8725   echo "$ac_t""no" 1>&6
8726 fi
8727 done
8728
8729   fi
8730
8731
8732
8733   ac_ext=C
8734 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8735 ac_cpp='$CXXCPP $CPPFLAGS'
8736 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8737 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8738 cross_compiling=$ac_cv_prog_cxx_cross
8739
8740   echo $ac_n "checking for logl declaration""... $ac_c" 1>&6
8741 echo "configure:8742: checking for logl declaration" >&5
8742   cat > conftest.$ac_ext <<EOF
8743 #line 8744 "configure"
8744 #include "confdefs.h"
8745 #include <math.h>
8746 int main() {
8747  logl(0);
8748 ; return 0; }
8749 EOF
8750 if { (eval echo configure:8751: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8751   rm -rf conftest*
8752   use_logl=yes
8753 else
8754   echo "configure: failed program was:" >&5
8755   cat conftest.$ac_ext >&5
8756   rm -rf conftest*
8757   use_logl=no
8758 fi
8759 rm -f conftest*
8760   echo "$ac_t""$use_logl" 1>&6
8761   ac_ext=c
8762 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8763 ac_cpp='$CPP $CPPFLAGS'
8764 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8765 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8766 cross_compiling=$ac_cv_prog_cc_cross
8767
8768   if test x$use_logl = x"yes"; then
8769     for ac_func in logl
8770 do
8771 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8772 echo "configure:8773: checking for $ac_func" >&5
8773 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8774   echo $ac_n "(cached) $ac_c" 1>&6
8775 else
8776   cat > conftest.$ac_ext <<EOF
8777 #line 8778 "configure"
8778 #include "confdefs.h"
8779 /* System header to define __stub macros and hopefully few prototypes,
8780     which can conflict with char $ac_func(); below.  */
8781 #include <assert.h>
8782 /* Override any gcc2 internal prototype to avoid an error.  */
8783 /* We use char because int might match the return type of a gcc2
8784     builtin and then its argument prototype would still apply.  */
8785 char $ac_func();
8786
8787 int main() {
8788
8789 /* The GNU C library defines this for functions which it implements
8790     to always fail with ENOSYS.  Some functions are actually named
8791     something starting with __ and the normal name is an alias.  */
8792 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8793 choke me
8794 #else
8795 $ac_func();
8796 #endif
8797
8798 ; return 0; }
8799 EOF
8800 if { (eval echo configure:8801: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8801   rm -rf conftest*
8802   eval "ac_cv_func_$ac_func=yes"
8803 else
8804   echo "configure: failed program was:" >&5
8805   cat conftest.$ac_ext >&5
8806   rm -rf conftest*
8807   eval "ac_cv_func_$ac_func=no"
8808 fi
8809 rm -f conftest*
8810 fi
8811
8812 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8813   echo "$ac_t""yes" 1>&6
8814     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8815   cat >> confdefs.h <<EOF
8816 #define $ac_tr_func 1
8817 EOF
8818
8819 else
8820   echo "$ac_t""no" 1>&6
8821 fi
8822 done
8823
8824   fi
8825
8826
8827
8828   ac_ext=C
8829 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8830 ac_cpp='$CXXCPP $CPPFLAGS'
8831 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8832 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8833 cross_compiling=$ac_cv_prog_cxx_cross
8834
8835   echo $ac_n "checking for log10l declaration""... $ac_c" 1>&6
8836 echo "configure:8837: checking for log10l declaration" >&5
8837   cat > conftest.$ac_ext <<EOF
8838 #line 8839 "configure"
8839 #include "confdefs.h"
8840 #include <math.h>
8841 int main() {
8842  log10l(0);
8843 ; return 0; }
8844 EOF
8845 if { (eval echo configure:8846: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8846   rm -rf conftest*
8847   use_log10l=yes
8848 else
8849   echo "configure: failed program was:" >&5
8850   cat conftest.$ac_ext >&5
8851   rm -rf conftest*
8852   use_log10l=no
8853 fi
8854 rm -f conftest*
8855   echo "$ac_t""$use_log10l" 1>&6
8856   ac_ext=c
8857 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8858 ac_cpp='$CPP $CPPFLAGS'
8859 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8860 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8861 cross_compiling=$ac_cv_prog_cc_cross
8862
8863   if test x$use_log10l = x"yes"; then
8864     for ac_func in log10l
8865 do
8866 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8867 echo "configure:8868: checking for $ac_func" >&5
8868 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8869   echo $ac_n "(cached) $ac_c" 1>&6
8870 else
8871   cat > conftest.$ac_ext <<EOF
8872 #line 8873 "configure"
8873 #include "confdefs.h"
8874 /* System header to define __stub macros and hopefully few prototypes,
8875     which can conflict with char $ac_func(); below.  */
8876 #include <assert.h>
8877 /* Override any gcc2 internal prototype to avoid an error.  */
8878 /* We use char because int might match the return type of a gcc2
8879     builtin and then its argument prototype would still apply.  */
8880 char $ac_func();
8881
8882 int main() {
8883
8884 /* The GNU C library defines this for functions which it implements
8885     to always fail with ENOSYS.  Some functions are actually named
8886     something starting with __ and the normal name is an alias.  */
8887 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8888 choke me
8889 #else
8890 $ac_func();
8891 #endif
8892
8893 ; return 0; }
8894 EOF
8895 if { (eval echo configure:8896: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8896   rm -rf conftest*
8897   eval "ac_cv_func_$ac_func=yes"
8898 else
8899   echo "configure: failed program was:" >&5
8900   cat conftest.$ac_ext >&5
8901   rm -rf conftest*
8902   eval "ac_cv_func_$ac_func=no"
8903 fi
8904 rm -f conftest*
8905 fi
8906
8907 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8908   echo "$ac_t""yes" 1>&6
8909     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8910   cat >> confdefs.h <<EOF
8911 #define $ac_tr_func 1
8912 EOF
8913
8914 else
8915   echo "$ac_t""no" 1>&6
8916 fi
8917 done
8918
8919   fi
8920
8921
8922
8923   ac_ext=C
8924 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8925 ac_cpp='$CXXCPP $CPPFLAGS'
8926 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8927 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8928 cross_compiling=$ac_cv_prog_cxx_cross
8929
8930   echo $ac_n "checking for modfl declaration""... $ac_c" 1>&6
8931 echo "configure:8932: checking for modfl declaration" >&5
8932   cat > conftest.$ac_ext <<EOF
8933 #line 8934 "configure"
8934 #include "confdefs.h"
8935 #include <math.h>
8936 int main() {
8937  modfl(0, 0);
8938 ; return 0; }
8939 EOF
8940 if { (eval echo configure:8941: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8941   rm -rf conftest*
8942   use_modfl=yes
8943 else
8944   echo "configure: failed program was:" >&5
8945   cat conftest.$ac_ext >&5
8946   rm -rf conftest*
8947   use_modfl=no
8948 fi
8949 rm -f conftest*
8950   echo "$ac_t""$use_modfl" 1>&6
8951   ac_ext=c
8952 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8953 ac_cpp='$CPP $CPPFLAGS'
8954 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8955 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8956 cross_compiling=$ac_cv_prog_cc_cross
8957
8958   if test x$use_modfl = x"yes"; then
8959     for ac_func in modfl
8960 do
8961 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8962 echo "configure:8963: checking for $ac_func" >&5
8963 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8964   echo $ac_n "(cached) $ac_c" 1>&6
8965 else
8966   cat > conftest.$ac_ext <<EOF
8967 #line 8968 "configure"
8968 #include "confdefs.h"
8969 /* System header to define __stub macros and hopefully few prototypes,
8970     which can conflict with char $ac_func(); below.  */
8971 #include <assert.h>
8972 /* Override any gcc2 internal prototype to avoid an error.  */
8973 /* We use char because int might match the return type of a gcc2
8974     builtin and then its argument prototype would still apply.  */
8975 char $ac_func();
8976
8977 int main() {
8978
8979 /* The GNU C library defines this for functions which it implements
8980     to always fail with ENOSYS.  Some functions are actually named
8981     something starting with __ and the normal name is an alias.  */
8982 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8983 choke me
8984 #else
8985 $ac_func();
8986 #endif
8987
8988 ; return 0; }
8989 EOF
8990 if { (eval echo configure:8991: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8991   rm -rf conftest*
8992   eval "ac_cv_func_$ac_func=yes"
8993 else
8994   echo "configure: failed program was:" >&5
8995   cat conftest.$ac_ext >&5
8996   rm -rf conftest*
8997   eval "ac_cv_func_$ac_func=no"
8998 fi
8999 rm -f conftest*
9000 fi
9001
9002 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9003   echo "$ac_t""yes" 1>&6
9004     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9005   cat >> confdefs.h <<EOF
9006 #define $ac_tr_func 1
9007 EOF
9008
9009 else
9010   echo "$ac_t""no" 1>&6
9011 fi
9012 done
9013
9014   fi
9015
9016
9017
9018   ac_ext=C
9019 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9020 ac_cpp='$CXXCPP $CPPFLAGS'
9021 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9022 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9023 cross_compiling=$ac_cv_prog_cxx_cross
9024
9025   echo $ac_n "checking for powl declaration""... $ac_c" 1>&6
9026 echo "configure:9027: checking for powl declaration" >&5
9027   cat > conftest.$ac_ext <<EOF
9028 #line 9029 "configure"
9029 #include "confdefs.h"
9030 #include <math.h>
9031 int main() {
9032  powl(0, 0);
9033 ; return 0; }
9034 EOF
9035 if { (eval echo configure:9036: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9036   rm -rf conftest*
9037   use_powl=yes
9038 else
9039   echo "configure: failed program was:" >&5
9040   cat conftest.$ac_ext >&5
9041   rm -rf conftest*
9042   use_powl=no
9043 fi
9044 rm -f conftest*
9045   echo "$ac_t""$use_powl" 1>&6
9046   ac_ext=c
9047 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9048 ac_cpp='$CPP $CPPFLAGS'
9049 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9050 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9051 cross_compiling=$ac_cv_prog_cc_cross
9052
9053   if test x$use_powl = x"yes"; then
9054     for ac_func in powl
9055 do
9056 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9057 echo "configure:9058: checking for $ac_func" >&5
9058 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9059   echo $ac_n "(cached) $ac_c" 1>&6
9060 else
9061   cat > conftest.$ac_ext <<EOF
9062 #line 9063 "configure"
9063 #include "confdefs.h"
9064 /* System header to define __stub macros and hopefully few prototypes,
9065     which can conflict with char $ac_func(); below.  */
9066 #include <assert.h>
9067 /* Override any gcc2 internal prototype to avoid an error.  */
9068 /* We use char because int might match the return type of a gcc2
9069     builtin and then its argument prototype would still apply.  */
9070 char $ac_func();
9071
9072 int main() {
9073
9074 /* The GNU C library defines this for functions which it implements
9075     to always fail with ENOSYS.  Some functions are actually named
9076     something starting with __ and the normal name is an alias.  */
9077 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9078 choke me
9079 #else
9080 $ac_func();
9081 #endif
9082
9083 ; return 0; }
9084 EOF
9085 if { (eval echo configure:9086: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9086   rm -rf conftest*
9087   eval "ac_cv_func_$ac_func=yes"
9088 else
9089   echo "configure: failed program was:" >&5
9090   cat conftest.$ac_ext >&5
9091   rm -rf conftest*
9092   eval "ac_cv_func_$ac_func=no"
9093 fi
9094 rm -f conftest*
9095 fi
9096
9097 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9098   echo "$ac_t""yes" 1>&6
9099     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9100   cat >> confdefs.h <<EOF
9101 #define $ac_tr_func 1
9102 EOF
9103
9104 else
9105   echo "$ac_t""no" 1>&6
9106 fi
9107 done
9108
9109   fi
9110
9111
9112
9113   ac_ext=C
9114 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9115 ac_cpp='$CXXCPP $CPPFLAGS'
9116 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9117 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9118 cross_compiling=$ac_cv_prog_cxx_cross
9119
9120   echo $ac_n "checking for sinl declaration""... $ac_c" 1>&6
9121 echo "configure:9122: checking for sinl declaration" >&5
9122   cat > conftest.$ac_ext <<EOF
9123 #line 9124 "configure"
9124 #include "confdefs.h"
9125 #include <math.h>
9126 int main() {
9127  sinl(0);
9128 ; return 0; }
9129 EOF
9130 if { (eval echo configure:9131: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9131   rm -rf conftest*
9132   use_sinl=yes
9133 else
9134   echo "configure: failed program was:" >&5
9135   cat conftest.$ac_ext >&5
9136   rm -rf conftest*
9137   use_sinl=no
9138 fi
9139 rm -f conftest*
9140   echo "$ac_t""$use_sinl" 1>&6
9141   ac_ext=c
9142 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9143 ac_cpp='$CPP $CPPFLAGS'
9144 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9145 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9146 cross_compiling=$ac_cv_prog_cc_cross
9147
9148   if test x$use_sinl = x"yes"; then
9149     for ac_func in sinl
9150 do
9151 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9152 echo "configure:9153: checking for $ac_func" >&5
9153 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9154   echo $ac_n "(cached) $ac_c" 1>&6
9155 else
9156   cat > conftest.$ac_ext <<EOF
9157 #line 9158 "configure"
9158 #include "confdefs.h"
9159 /* System header to define __stub macros and hopefully few prototypes,
9160     which can conflict with char $ac_func(); below.  */
9161 #include <assert.h>
9162 /* Override any gcc2 internal prototype to avoid an error.  */
9163 /* We use char because int might match the return type of a gcc2
9164     builtin and then its argument prototype would still apply.  */
9165 char $ac_func();
9166
9167 int main() {
9168
9169 /* The GNU C library defines this for functions which it implements
9170     to always fail with ENOSYS.  Some functions are actually named
9171     something starting with __ and the normal name is an alias.  */
9172 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9173 choke me
9174 #else
9175 $ac_func();
9176 #endif
9177
9178 ; return 0; }
9179 EOF
9180 if { (eval echo configure:9181: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9181   rm -rf conftest*
9182   eval "ac_cv_func_$ac_func=yes"
9183 else
9184   echo "configure: failed program was:" >&5
9185   cat conftest.$ac_ext >&5
9186   rm -rf conftest*
9187   eval "ac_cv_func_$ac_func=no"
9188 fi
9189 rm -f conftest*
9190 fi
9191
9192 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9193   echo "$ac_t""yes" 1>&6
9194     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9195   cat >> confdefs.h <<EOF
9196 #define $ac_tr_func 1
9197 EOF
9198
9199 else
9200   echo "$ac_t""no" 1>&6
9201 fi
9202 done
9203
9204   fi
9205
9206
9207
9208   ac_ext=C
9209 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9210 ac_cpp='$CXXCPP $CPPFLAGS'
9211 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9212 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9213 cross_compiling=$ac_cv_prog_cxx_cross
9214
9215   echo $ac_n "checking for sinhl declaration""... $ac_c" 1>&6
9216 echo "configure:9217: checking for sinhl declaration" >&5
9217   cat > conftest.$ac_ext <<EOF
9218 #line 9219 "configure"
9219 #include "confdefs.h"
9220 #include <math.h>
9221 int main() {
9222  sinhl(0);
9223 ; return 0; }
9224 EOF
9225 if { (eval echo configure:9226: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9226   rm -rf conftest*
9227   use_sinhl=yes
9228 else
9229   echo "configure: failed program was:" >&5
9230   cat conftest.$ac_ext >&5
9231   rm -rf conftest*
9232   use_sinhl=no
9233 fi
9234 rm -f conftest*
9235   echo "$ac_t""$use_sinhl" 1>&6
9236   ac_ext=c
9237 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9238 ac_cpp='$CPP $CPPFLAGS'
9239 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9240 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9241 cross_compiling=$ac_cv_prog_cc_cross
9242
9243   if test x$use_sinhl = x"yes"; then
9244     for ac_func in sinhl
9245 do
9246 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9247 echo "configure:9248: checking for $ac_func" >&5
9248 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9249   echo $ac_n "(cached) $ac_c" 1>&6
9250 else
9251   cat > conftest.$ac_ext <<EOF
9252 #line 9253 "configure"
9253 #include "confdefs.h"
9254 /* System header to define __stub macros and hopefully few prototypes,
9255     which can conflict with char $ac_func(); below.  */
9256 #include <assert.h>
9257 /* Override any gcc2 internal prototype to avoid an error.  */
9258 /* We use char because int might match the return type of a gcc2
9259     builtin and then its argument prototype would still apply.  */
9260 char $ac_func();
9261
9262 int main() {
9263
9264 /* The GNU C library defines this for functions which it implements
9265     to always fail with ENOSYS.  Some functions are actually named
9266     something starting with __ and the normal name is an alias.  */
9267 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9268 choke me
9269 #else
9270 $ac_func();
9271 #endif
9272
9273 ; return 0; }
9274 EOF
9275 if { (eval echo configure:9276: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9276   rm -rf conftest*
9277   eval "ac_cv_func_$ac_func=yes"
9278 else
9279   echo "configure: failed program was:" >&5
9280   cat conftest.$ac_ext >&5
9281   rm -rf conftest*
9282   eval "ac_cv_func_$ac_func=no"
9283 fi
9284 rm -f conftest*
9285 fi
9286
9287 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9288   echo "$ac_t""yes" 1>&6
9289     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9290   cat >> confdefs.h <<EOF
9291 #define $ac_tr_func 1
9292 EOF
9293
9294 else
9295   echo "$ac_t""no" 1>&6
9296 fi
9297 done
9298
9299   fi
9300
9301
9302
9303   ac_ext=C
9304 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9305 ac_cpp='$CXXCPP $CPPFLAGS'
9306 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9307 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9308 cross_compiling=$ac_cv_prog_cxx_cross
9309
9310   echo $ac_n "checking for sqrtl declaration""... $ac_c" 1>&6
9311 echo "configure:9312: checking for sqrtl declaration" >&5
9312   cat > conftest.$ac_ext <<EOF
9313 #line 9314 "configure"
9314 #include "confdefs.h"
9315 #include <math.h>
9316 int main() {
9317  sqrtl(0);
9318 ; return 0; }
9319 EOF
9320 if { (eval echo configure:9321: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9321   rm -rf conftest*
9322   use_sqrtl=yes
9323 else
9324   echo "configure: failed program was:" >&5
9325   cat conftest.$ac_ext >&5
9326   rm -rf conftest*
9327   use_sqrtl=no
9328 fi
9329 rm -f conftest*
9330   echo "$ac_t""$use_sqrtl" 1>&6
9331   ac_ext=c
9332 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9333 ac_cpp='$CPP $CPPFLAGS'
9334 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9335 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9336 cross_compiling=$ac_cv_prog_cc_cross
9337
9338   if test x$use_sqrtl = x"yes"; then
9339     for ac_func in sqrtl
9340 do
9341 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9342 echo "configure:9343: checking for $ac_func" >&5
9343 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9344   echo $ac_n "(cached) $ac_c" 1>&6
9345 else
9346   cat > conftest.$ac_ext <<EOF
9347 #line 9348 "configure"
9348 #include "confdefs.h"
9349 /* System header to define __stub macros and hopefully few prototypes,
9350     which can conflict with char $ac_func(); below.  */
9351 #include <assert.h>
9352 /* Override any gcc2 internal prototype to avoid an error.  */
9353 /* We use char because int might match the return type of a gcc2
9354     builtin and then its argument prototype would still apply.  */
9355 char $ac_func();
9356
9357 int main() {
9358
9359 /* The GNU C library defines this for functions which it implements
9360     to always fail with ENOSYS.  Some functions are actually named
9361     something starting with __ and the normal name is an alias.  */
9362 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9363 choke me
9364 #else
9365 $ac_func();
9366 #endif
9367
9368 ; return 0; }
9369 EOF
9370 if { (eval echo configure:9371: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9371   rm -rf conftest*
9372   eval "ac_cv_func_$ac_func=yes"
9373 else
9374   echo "configure: failed program was:" >&5
9375   cat conftest.$ac_ext >&5
9376   rm -rf conftest*
9377   eval "ac_cv_func_$ac_func=no"
9378 fi
9379 rm -f conftest*
9380 fi
9381
9382 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9383   echo "$ac_t""yes" 1>&6
9384     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9385   cat >> confdefs.h <<EOF
9386 #define $ac_tr_func 1
9387 EOF
9388
9389 else
9390   echo "$ac_t""no" 1>&6
9391 fi
9392 done
9393
9394   fi
9395
9396
9397
9398   ac_ext=C
9399 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9400 ac_cpp='$CXXCPP $CPPFLAGS'
9401 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9402 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9403 cross_compiling=$ac_cv_prog_cxx_cross
9404
9405   echo $ac_n "checking for tanl declaration""... $ac_c" 1>&6
9406 echo "configure:9407: checking for tanl declaration" >&5
9407   cat > conftest.$ac_ext <<EOF
9408 #line 9409 "configure"
9409 #include "confdefs.h"
9410 #include <math.h>
9411 int main() {
9412  tanl(0);
9413 ; return 0; }
9414 EOF
9415 if { (eval echo configure:9416: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9416   rm -rf conftest*
9417   use_tanl=yes
9418 else
9419   echo "configure: failed program was:" >&5
9420   cat conftest.$ac_ext >&5
9421   rm -rf conftest*
9422   use_tanl=no
9423 fi
9424 rm -f conftest*
9425   echo "$ac_t""$use_tanl" 1>&6
9426   ac_ext=c
9427 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9428 ac_cpp='$CPP $CPPFLAGS'
9429 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9430 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9431 cross_compiling=$ac_cv_prog_cc_cross
9432
9433   if test x$use_tanl = x"yes"; then
9434     for ac_func in tanl
9435 do
9436 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9437 echo "configure:9438: checking for $ac_func" >&5
9438 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9439   echo $ac_n "(cached) $ac_c" 1>&6
9440 else
9441   cat > conftest.$ac_ext <<EOF
9442 #line 9443 "configure"
9443 #include "confdefs.h"
9444 /* System header to define __stub macros and hopefully few prototypes,
9445     which can conflict with char $ac_func(); below.  */
9446 #include <assert.h>
9447 /* Override any gcc2 internal prototype to avoid an error.  */
9448 /* We use char because int might match the return type of a gcc2
9449     builtin and then its argument prototype would still apply.  */
9450 char $ac_func();
9451
9452 int main() {
9453
9454 /* The GNU C library defines this for functions which it implements
9455     to always fail with ENOSYS.  Some functions are actually named
9456     something starting with __ and the normal name is an alias.  */
9457 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9458 choke me
9459 #else
9460 $ac_func();
9461 #endif
9462
9463 ; return 0; }
9464 EOF
9465 if { (eval echo configure:9466: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9466   rm -rf conftest*
9467   eval "ac_cv_func_$ac_func=yes"
9468 else
9469   echo "configure: failed program was:" >&5
9470   cat conftest.$ac_ext >&5
9471   rm -rf conftest*
9472   eval "ac_cv_func_$ac_func=no"
9473 fi
9474 rm -f conftest*
9475 fi
9476
9477 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9478   echo "$ac_t""yes" 1>&6
9479     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9480   cat >> confdefs.h <<EOF
9481 #define $ac_tr_func 1
9482 EOF
9483
9484 else
9485   echo "$ac_t""no" 1>&6
9486 fi
9487 done
9488
9489   fi
9490
9491
9492
9493   ac_ext=C
9494 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9495 ac_cpp='$CXXCPP $CPPFLAGS'
9496 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9497 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9498 cross_compiling=$ac_cv_prog_cxx_cross
9499
9500   echo $ac_n "checking for tanhl declaration""... $ac_c" 1>&6
9501 echo "configure:9502: checking for tanhl declaration" >&5
9502   cat > conftest.$ac_ext <<EOF
9503 #line 9504 "configure"
9504 #include "confdefs.h"
9505 #include <math.h>
9506 int main() {
9507  tanhl(0);
9508 ; return 0; }
9509 EOF
9510 if { (eval echo configure:9511: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9511   rm -rf conftest*
9512   use_tanhl=yes
9513 else
9514   echo "configure: failed program was:" >&5
9515   cat conftest.$ac_ext >&5
9516   rm -rf conftest*
9517   use_tanhl=no
9518 fi
9519 rm -f conftest*
9520   echo "$ac_t""$use_tanhl" 1>&6
9521   ac_ext=c
9522 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9523 ac_cpp='$CPP $CPPFLAGS'
9524 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9525 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9526 cross_compiling=$ac_cv_prog_cc_cross
9527
9528   if test x$use_tanhl = x"yes"; then
9529     for ac_func in tanhl
9530 do
9531 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9532 echo "configure:9533: checking for $ac_func" >&5
9533 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9534   echo $ac_n "(cached) $ac_c" 1>&6
9535 else
9536   cat > conftest.$ac_ext <<EOF
9537 #line 9538 "configure"
9538 #include "confdefs.h"
9539 /* System header to define __stub macros and hopefully few prototypes,
9540     which can conflict with char $ac_func(); below.  */
9541 #include <assert.h>
9542 /* Override any gcc2 internal prototype to avoid an error.  */
9543 /* We use char because int might match the return type of a gcc2
9544     builtin and then its argument prototype would still apply.  */
9545 char $ac_func();
9546
9547 int main() {
9548
9549 /* The GNU C library defines this for functions which it implements
9550     to always fail with ENOSYS.  Some functions are actually named
9551     something starting with __ and the normal name is an alias.  */
9552 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9553 choke me
9554 #else
9555 $ac_func();
9556 #endif
9557
9558 ; return 0; }
9559 EOF
9560 if { (eval echo configure:9561: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9561   rm -rf conftest*
9562   eval "ac_cv_func_$ac_func=yes"
9563 else
9564   echo "configure: failed program was:" >&5
9565   cat conftest.$ac_ext >&5
9566   rm -rf conftest*
9567   eval "ac_cv_func_$ac_func=no"
9568 fi
9569 rm -f conftest*
9570 fi
9571
9572 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9573   echo "$ac_t""yes" 1>&6
9574     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9575   cat >> confdefs.h <<EOF
9576 #define $ac_tr_func 1
9577 EOF
9578
9579 else
9580   echo "$ac_t""no" 1>&6
9581 fi
9582 done
9583
9584   fi
9585
9586
9587
9588   ac_ext=C
9589 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9590 ac_cpp='$CXXCPP $CPPFLAGS'
9591 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9592 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9593 cross_compiling=$ac_cv_prog_cxx_cross
9594
9595   echo $ac_n "checking for sincosl declaration""... $ac_c" 1>&6
9596 echo "configure:9597: checking for sincosl declaration" >&5
9597   cat > conftest.$ac_ext <<EOF
9598 #line 9599 "configure"
9599 #include "confdefs.h"
9600 #include <math.h>
9601 int main() {
9602  sincosl(0, 0, 0);
9603 ; return 0; }
9604 EOF
9605 if { (eval echo configure:9606: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9606   rm -rf conftest*
9607   use_sincosl=yes
9608 else
9609   echo "configure: failed program was:" >&5
9610   cat conftest.$ac_ext >&5
9611   rm -rf conftest*
9612   use_sincosl=no
9613 fi
9614 rm -f conftest*
9615   echo "$ac_t""$use_sincosl" 1>&6
9616   ac_ext=c
9617 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9618 ac_cpp='$CPP $CPPFLAGS'
9619 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9620 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9621 cross_compiling=$ac_cv_prog_cc_cross
9622
9623   if test x$use_sincosl = x"yes"; then
9624     for ac_func in sincosl
9625 do
9626 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9627 echo "configure:9628: checking for $ac_func" >&5
9628 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9629   echo $ac_n "(cached) $ac_c" 1>&6
9630 else
9631   cat > conftest.$ac_ext <<EOF
9632 #line 9633 "configure"
9633 #include "confdefs.h"
9634 /* System header to define __stub macros and hopefully few prototypes,
9635     which can conflict with char $ac_func(); below.  */
9636 #include <assert.h>
9637 /* Override any gcc2 internal prototype to avoid an error.  */
9638 /* We use char because int might match the return type of a gcc2
9639     builtin and then its argument prototype would still apply.  */
9640 char $ac_func();
9641
9642 int main() {
9643
9644 /* The GNU C library defines this for functions which it implements
9645     to always fail with ENOSYS.  Some functions are actually named
9646     something starting with __ and the normal name is an alias.  */
9647 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9648 choke me
9649 #else
9650 $ac_func();
9651 #endif
9652
9653 ; return 0; }
9654 EOF
9655 if { (eval echo configure:9656: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9656   rm -rf conftest*
9657   eval "ac_cv_func_$ac_func=yes"
9658 else
9659   echo "configure: failed program was:" >&5
9660   cat conftest.$ac_ext >&5
9661   rm -rf conftest*
9662   eval "ac_cv_func_$ac_func=no"
9663 fi
9664 rm -f conftest*
9665 fi
9666
9667 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9668   echo "$ac_t""yes" 1>&6
9669     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9670   cat >> confdefs.h <<EOF
9671 #define $ac_tr_func 1
9672 EOF
9673
9674 else
9675   echo "$ac_t""no" 1>&6
9676 fi
9677 done
9678
9679   fi
9680
9681
9682
9683   ac_ext=C
9684 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9685 ac_cpp='$CXXCPP $CPPFLAGS'
9686 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9687 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9688 cross_compiling=$ac_cv_prog_cxx_cross
9689
9690   echo $ac_n "checking for finitel declaration""... $ac_c" 1>&6
9691 echo "configure:9692: checking for finitel declaration" >&5
9692   cat > conftest.$ac_ext <<EOF
9693 #line 9694 "configure"
9694 #include "confdefs.h"
9695 #include <math.h>
9696 int main() {
9697  finitel(0);
9698 ; return 0; }
9699 EOF
9700 if { (eval echo configure:9701: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9701   rm -rf conftest*
9702   use_finitel=yes
9703 else
9704   echo "configure: failed program was:" >&5
9705   cat conftest.$ac_ext >&5
9706   rm -rf conftest*
9707   use_finitel=no
9708 fi
9709 rm -f conftest*
9710   echo "$ac_t""$use_finitel" 1>&6
9711   ac_ext=c
9712 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9713 ac_cpp='$CPP $CPPFLAGS'
9714 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9715 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9716 cross_compiling=$ac_cv_prog_cc_cross
9717
9718   if test x$use_finitel = x"yes"; then
9719     for ac_func in finitel
9720 do
9721 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9722 echo "configure:9723: checking for $ac_func" >&5
9723 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9724   echo $ac_n "(cached) $ac_c" 1>&6
9725 else
9726   cat > conftest.$ac_ext <<EOF
9727 #line 9728 "configure"
9728 #include "confdefs.h"
9729 /* System header to define __stub macros and hopefully few prototypes,
9730     which can conflict with char $ac_func(); below.  */
9731 #include <assert.h>
9732 /* Override any gcc2 internal prototype to avoid an error.  */
9733 /* We use char because int might match the return type of a gcc2
9734     builtin and then its argument prototype would still apply.  */
9735 char $ac_func();
9736
9737 int main() {
9738
9739 /* The GNU C library defines this for functions which it implements
9740     to always fail with ENOSYS.  Some functions are actually named
9741     something starting with __ and the normal name is an alias.  */
9742 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9743 choke me
9744 #else
9745 $ac_func();
9746 #endif
9747
9748 ; return 0; }
9749 EOF
9750 if { (eval echo configure:9751: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9751   rm -rf conftest*
9752   eval "ac_cv_func_$ac_func=yes"
9753 else
9754   echo "configure: failed program was:" >&5
9755   cat conftest.$ac_ext >&5
9756   rm -rf conftest*
9757   eval "ac_cv_func_$ac_func=no"
9758 fi
9759 rm -f conftest*
9760 fi
9761
9762 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9763   echo "$ac_t""yes" 1>&6
9764     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9765   cat >> confdefs.h <<EOF
9766 #define $ac_tr_func 1
9767 EOF
9768
9769 else
9770   echo "$ac_t""no" 1>&6
9771 fi
9772 done
9773
9774   fi
9775
9776
9777
9778
9779   ac_ext=C
9780 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9781 ac_cpp='$CXXCPP $CPPFLAGS'
9782 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9783 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9784 cross_compiling=$ac_cv_prog_cxx_cross
9785
9786   echo $ac_n "checking for _isinf declaration""... $ac_c" 1>&6
9787 echo "configure:9788: checking for _isinf declaration" >&5
9788   cat > conftest.$ac_ext <<EOF
9789 #line 9790 "configure"
9790 #include "confdefs.h"
9791 #include <math.h>
9792 int main() {
9793  _isinf(0);
9794 ; return 0; }
9795 EOF
9796 if { (eval echo configure:9797: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9797   rm -rf conftest*
9798   use__isinf=yes
9799 else
9800   echo "configure: failed program was:" >&5
9801   cat conftest.$ac_ext >&5
9802   rm -rf conftest*
9803   use__isinf=no
9804 fi
9805 rm -f conftest*
9806   echo "$ac_t""$use__isinf" 1>&6
9807   ac_ext=c
9808 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9809 ac_cpp='$CPP $CPPFLAGS'
9810 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9811 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9812 cross_compiling=$ac_cv_prog_cc_cross
9813
9814   if test x$use__isinf = x"yes"; then
9815     for ac_func in _isinf
9816 do
9817 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9818 echo "configure:9819: checking for $ac_func" >&5
9819 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9820   echo $ac_n "(cached) $ac_c" 1>&6
9821 else
9822   cat > conftest.$ac_ext <<EOF
9823 #line 9824 "configure"
9824 #include "confdefs.h"
9825 /* System header to define __stub macros and hopefully few prototypes,
9826     which can conflict with char $ac_func(); below.  */
9827 #include <assert.h>
9828 /* Override any gcc2 internal prototype to avoid an error.  */
9829 /* We use char because int might match the return type of a gcc2
9830     builtin and then its argument prototype would still apply.  */
9831 char $ac_func();
9832
9833 int main() {
9834
9835 /* The GNU C library defines this for functions which it implements
9836     to always fail with ENOSYS.  Some functions are actually named
9837     something starting with __ and the normal name is an alias.  */
9838 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9839 choke me
9840 #else
9841 $ac_func();
9842 #endif
9843
9844 ; return 0; }
9845 EOF
9846 if { (eval echo configure:9847: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9847   rm -rf conftest*
9848   eval "ac_cv_func_$ac_func=yes"
9849 else
9850   echo "configure: failed program was:" >&5
9851   cat conftest.$ac_ext >&5
9852   rm -rf conftest*
9853   eval "ac_cv_func_$ac_func=no"
9854 fi
9855 rm -f conftest*
9856 fi
9857
9858 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9859   echo "$ac_t""yes" 1>&6
9860     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9861   cat >> confdefs.h <<EOF
9862 #define $ac_tr_func 1
9863 EOF
9864
9865 else
9866   echo "$ac_t""no" 1>&6
9867 fi
9868 done
9869
9870   fi
9871
9872
9873
9874   ac_ext=C
9875 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9876 ac_cpp='$CXXCPP $CPPFLAGS'
9877 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9878 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9879 cross_compiling=$ac_cv_prog_cxx_cross
9880
9881   echo $ac_n "checking for _isnan declaration""... $ac_c" 1>&6
9882 echo "configure:9883: checking for _isnan declaration" >&5
9883   cat > conftest.$ac_ext <<EOF
9884 #line 9885 "configure"
9885 #include "confdefs.h"
9886 #include <math.h>
9887 int main() {
9888  _isnan(0);
9889 ; return 0; }
9890 EOF
9891 if { (eval echo configure:9892: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9892   rm -rf conftest*
9893   use__isnan=yes
9894 else
9895   echo "configure: failed program was:" >&5
9896   cat conftest.$ac_ext >&5
9897   rm -rf conftest*
9898   use__isnan=no
9899 fi
9900 rm -f conftest*
9901   echo "$ac_t""$use__isnan" 1>&6
9902   ac_ext=c
9903 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9904 ac_cpp='$CPP $CPPFLAGS'
9905 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9906 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9907 cross_compiling=$ac_cv_prog_cc_cross
9908
9909   if test x$use__isnan = x"yes"; then
9910     for ac_func in _isnan
9911 do
9912 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9913 echo "configure:9914: checking for $ac_func" >&5
9914 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9915   echo $ac_n "(cached) $ac_c" 1>&6
9916 else
9917   cat > conftest.$ac_ext <<EOF
9918 #line 9919 "configure"
9919 #include "confdefs.h"
9920 /* System header to define __stub macros and hopefully few prototypes,
9921     which can conflict with char $ac_func(); below.  */
9922 #include <assert.h>
9923 /* Override any gcc2 internal prototype to avoid an error.  */
9924 /* We use char because int might match the return type of a gcc2
9925     builtin and then its argument prototype would still apply.  */
9926 char $ac_func();
9927
9928 int main() {
9929
9930 /* The GNU C library defines this for functions which it implements
9931     to always fail with ENOSYS.  Some functions are actually named
9932     something starting with __ and the normal name is an alias.  */
9933 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9934 choke me
9935 #else
9936 $ac_func();
9937 #endif
9938
9939 ; return 0; }
9940 EOF
9941 if { (eval echo configure:9942: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9942   rm -rf conftest*
9943   eval "ac_cv_func_$ac_func=yes"
9944 else
9945   echo "configure: failed program was:" >&5
9946   cat conftest.$ac_ext >&5
9947   rm -rf conftest*
9948   eval "ac_cv_func_$ac_func=no"
9949 fi
9950 rm -f conftest*
9951 fi
9952
9953 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9954   echo "$ac_t""yes" 1>&6
9955     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9956   cat >> confdefs.h <<EOF
9957 #define $ac_tr_func 1
9958 EOF
9959
9960 else
9961   echo "$ac_t""no" 1>&6
9962 fi
9963 done
9964
9965   fi
9966
9967
9968
9969   ac_ext=C
9970 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9971 ac_cpp='$CXXCPP $CPPFLAGS'
9972 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9973 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9974 cross_compiling=$ac_cv_prog_cxx_cross
9975
9976   echo $ac_n "checking for _finite declaration""... $ac_c" 1>&6
9977 echo "configure:9978: checking for _finite declaration" >&5
9978   cat > conftest.$ac_ext <<EOF
9979 #line 9980 "configure"
9980 #include "confdefs.h"
9981 #include <math.h>
9982 int main() {
9983  _finite(0);
9984 ; return 0; }
9985 EOF
9986 if { (eval echo configure:9987: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9987   rm -rf conftest*
9988   use__finite=yes
9989 else
9990   echo "configure: failed program was:" >&5
9991   cat conftest.$ac_ext >&5
9992   rm -rf conftest*
9993   use__finite=no
9994 fi
9995 rm -f conftest*
9996   echo "$ac_t""$use__finite" 1>&6
9997   ac_ext=c
9998 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9999 ac_cpp='$CPP $CPPFLAGS'
10000 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10001 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10002 cross_compiling=$ac_cv_prog_cc_cross
10003
10004   if test x$use__finite = x"yes"; then
10005     for ac_func in _finite
10006 do
10007 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10008 echo "configure:10009: checking for $ac_func" >&5
10009 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10010   echo $ac_n "(cached) $ac_c" 1>&6
10011 else
10012   cat > conftest.$ac_ext <<EOF
10013 #line 10014 "configure"
10014 #include "confdefs.h"
10015 /* System header to define __stub macros and hopefully few prototypes,
10016     which can conflict with char $ac_func(); below.  */
10017 #include <assert.h>
10018 /* Override any gcc2 internal prototype to avoid an error.  */
10019 /* We use char because int might match the return type of a gcc2
10020     builtin and then its argument prototype would still apply.  */
10021 char $ac_func();
10022
10023 int main() {
10024
10025 /* The GNU C library defines this for functions which it implements
10026     to always fail with ENOSYS.  Some functions are actually named
10027     something starting with __ and the normal name is an alias.  */
10028 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10029 choke me
10030 #else
10031 $ac_func();
10032 #endif
10033
10034 ; return 0; }
10035 EOF
10036 if { (eval echo configure:10037: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10037   rm -rf conftest*
10038   eval "ac_cv_func_$ac_func=yes"
10039 else
10040   echo "configure: failed program was:" >&5
10041   cat conftest.$ac_ext >&5
10042   rm -rf conftest*
10043   eval "ac_cv_func_$ac_func=no"
10044 fi
10045 rm -f conftest*
10046 fi
10047
10048 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10049   echo "$ac_t""yes" 1>&6
10050     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10051   cat >> confdefs.h <<EOF
10052 #define $ac_tr_func 1
10053 EOF
10054
10055 else
10056   echo "$ac_t""no" 1>&6
10057 fi
10058 done
10059
10060   fi
10061
10062
10063
10064   ac_ext=C
10065 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10066 ac_cpp='$CXXCPP $CPPFLAGS'
10067 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10068 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10069 cross_compiling=$ac_cv_prog_cxx_cross
10070
10071   echo $ac_n "checking for _copysign declaration""... $ac_c" 1>&6
10072 echo "configure:10073: checking for _copysign declaration" >&5
10073   cat > conftest.$ac_ext <<EOF
10074 #line 10075 "configure"
10075 #include "confdefs.h"
10076 #include <math.h>
10077 int main() {
10078  _copysign(0, 0);
10079 ; return 0; }
10080 EOF
10081 if { (eval echo configure:10082: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10082   rm -rf conftest*
10083   use__copysign=yes
10084 else
10085   echo "configure: failed program was:" >&5
10086   cat conftest.$ac_ext >&5
10087   rm -rf conftest*
10088   use__copysign=no
10089 fi
10090 rm -f conftest*
10091   echo "$ac_t""$use__copysign" 1>&6
10092   ac_ext=c
10093 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10094 ac_cpp='$CPP $CPPFLAGS'
10095 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10096 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10097 cross_compiling=$ac_cv_prog_cc_cross
10098
10099   if test x$use__copysign = x"yes"; then
10100     for ac_func in _copysign
10101 do
10102 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10103 echo "configure:10104: checking for $ac_func" >&5
10104 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10105   echo $ac_n "(cached) $ac_c" 1>&6
10106 else
10107   cat > conftest.$ac_ext <<EOF
10108 #line 10109 "configure"
10109 #include "confdefs.h"
10110 /* System header to define __stub macros and hopefully few prototypes,
10111     which can conflict with char $ac_func(); below.  */
10112 #include <assert.h>
10113 /* Override any gcc2 internal prototype to avoid an error.  */
10114 /* We use char because int might match the return type of a gcc2
10115     builtin and then its argument prototype would still apply.  */
10116 char $ac_func();
10117
10118 int main() {
10119
10120 /* The GNU C library defines this for functions which it implements
10121     to always fail with ENOSYS.  Some functions are actually named
10122     something starting with __ and the normal name is an alias.  */
10123 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10124 choke me
10125 #else
10126 $ac_func();
10127 #endif
10128
10129 ; return 0; }
10130 EOF
10131 if { (eval echo configure:10132: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10132   rm -rf conftest*
10133   eval "ac_cv_func_$ac_func=yes"
10134 else
10135   echo "configure: failed program was:" >&5
10136   cat conftest.$ac_ext >&5
10137   rm -rf conftest*
10138   eval "ac_cv_func_$ac_func=no"
10139 fi
10140 rm -f conftest*
10141 fi
10142
10143 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10144   echo "$ac_t""yes" 1>&6
10145     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10146   cat >> confdefs.h <<EOF
10147 #define $ac_tr_func 1
10148 EOF
10149
10150 else
10151   echo "$ac_t""no" 1>&6
10152 fi
10153 done
10154
10155   fi
10156
10157
10158
10159   ac_ext=C
10160 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10161 ac_cpp='$CXXCPP $CPPFLAGS'
10162 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10163 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10164 cross_compiling=$ac_cv_prog_cxx_cross
10165
10166   echo $ac_n "checking for _sincos declaration""... $ac_c" 1>&6
10167 echo "configure:10168: checking for _sincos declaration" >&5
10168   cat > conftest.$ac_ext <<EOF
10169 #line 10170 "configure"
10170 #include "confdefs.h"
10171 #include <math.h>
10172 int main() {
10173  _sincos(0, 0, 0);
10174 ; return 0; }
10175 EOF
10176 if { (eval echo configure:10177: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10177   rm -rf conftest*
10178   use__sincos=yes
10179 else
10180   echo "configure: failed program was:" >&5
10181   cat conftest.$ac_ext >&5
10182   rm -rf conftest*
10183   use__sincos=no
10184 fi
10185 rm -f conftest*
10186   echo "$ac_t""$use__sincos" 1>&6
10187   ac_ext=c
10188 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10189 ac_cpp='$CPP $CPPFLAGS'
10190 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10191 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10192 cross_compiling=$ac_cv_prog_cc_cross
10193
10194   if test x$use__sincos = x"yes"; then
10195     for ac_func in _sincos
10196 do
10197 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10198 echo "configure:10199: checking for $ac_func" >&5
10199 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10200   echo $ac_n "(cached) $ac_c" 1>&6
10201 else
10202   cat > conftest.$ac_ext <<EOF
10203 #line 10204 "configure"
10204 #include "confdefs.h"
10205 /* System header to define __stub macros and hopefully few prototypes,
10206     which can conflict with char $ac_func(); below.  */
10207 #include <assert.h>
10208 /* Override any gcc2 internal prototype to avoid an error.  */
10209 /* We use char because int might match the return type of a gcc2
10210     builtin and then its argument prototype would still apply.  */
10211 char $ac_func();
10212
10213 int main() {
10214
10215 /* The GNU C library defines this for functions which it implements
10216     to always fail with ENOSYS.  Some functions are actually named
10217     something starting with __ and the normal name is an alias.  */
10218 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10219 choke me
10220 #else
10221 $ac_func();
10222 #endif
10223
10224 ; return 0; }
10225 EOF
10226 if { (eval echo configure:10227: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10227   rm -rf conftest*
10228   eval "ac_cv_func_$ac_func=yes"
10229 else
10230   echo "configure: failed program was:" >&5
10231   cat conftest.$ac_ext >&5
10232   rm -rf conftest*
10233   eval "ac_cv_func_$ac_func=no"
10234 fi
10235 rm -f conftest*
10236 fi
10237
10238 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10239   echo "$ac_t""yes" 1>&6
10240     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10241   cat >> confdefs.h <<EOF
10242 #define $ac_tr_func 1
10243 EOF
10244
10245 else
10246   echo "$ac_t""no" 1>&6
10247 fi
10248 done
10249
10250   fi
10251
10252
10253
10254   ac_ext=C
10255 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10256 ac_cpp='$CXXCPP $CPPFLAGS'
10257 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10258 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10259 cross_compiling=$ac_cv_prog_cxx_cross
10260
10261   echo $ac_n "checking for _fpclass declaration""... $ac_c" 1>&6
10262 echo "configure:10263: checking for _fpclass declaration" >&5
10263   cat > conftest.$ac_ext <<EOF
10264 #line 10265 "configure"
10265 #include "confdefs.h"
10266 #include <math.h>
10267 int main() {
10268  _fpclass(0);
10269 ; return 0; }
10270 EOF
10271 if { (eval echo configure:10272: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10272   rm -rf conftest*
10273   use__fpclass=yes
10274 else
10275   echo "configure: failed program was:" >&5
10276   cat conftest.$ac_ext >&5
10277   rm -rf conftest*
10278   use__fpclass=no
10279 fi
10280 rm -f conftest*
10281   echo "$ac_t""$use__fpclass" 1>&6
10282   ac_ext=c
10283 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10284 ac_cpp='$CPP $CPPFLAGS'
10285 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10286 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10287 cross_compiling=$ac_cv_prog_cc_cross
10288
10289   if test x$use__fpclass = x"yes"; then
10290     for ac_func in _fpclass
10291 do
10292 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10293 echo "configure:10294: checking for $ac_func" >&5
10294 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10295   echo $ac_n "(cached) $ac_c" 1>&6
10296 else
10297   cat > conftest.$ac_ext <<EOF
10298 #line 10299 "configure"
10299 #include "confdefs.h"
10300 /* System header to define __stub macros and hopefully few prototypes,
10301     which can conflict with char $ac_func(); below.  */
10302 #include <assert.h>
10303 /* Override any gcc2 internal prototype to avoid an error.  */
10304 /* We use char because int might match the return type of a gcc2
10305     builtin and then its argument prototype would still apply.  */
10306 char $ac_func();
10307
10308 int main() {
10309
10310 /* The GNU C library defines this for functions which it implements
10311     to always fail with ENOSYS.  Some functions are actually named
10312     something starting with __ and the normal name is an alias.  */
10313 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10314 choke me
10315 #else
10316 $ac_func();
10317 #endif
10318
10319 ; return 0; }
10320 EOF
10321 if { (eval echo configure:10322: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10322   rm -rf conftest*
10323   eval "ac_cv_func_$ac_func=yes"
10324 else
10325   echo "configure: failed program was:" >&5
10326   cat conftest.$ac_ext >&5
10327   rm -rf conftest*
10328   eval "ac_cv_func_$ac_func=no"
10329 fi
10330 rm -f conftest*
10331 fi
10332
10333 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10334   echo "$ac_t""yes" 1>&6
10335     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10336   cat >> confdefs.h <<EOF
10337 #define $ac_tr_func 1
10338 EOF
10339
10340 else
10341   echo "$ac_t""no" 1>&6
10342 fi
10343 done
10344
10345   fi
10346
10347
10348
10349   ac_ext=C
10350 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10351 ac_cpp='$CXXCPP $CPPFLAGS'
10352 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10353 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10354 cross_compiling=$ac_cv_prog_cxx_cross
10355
10356   echo $ac_n "checking for _qfpclass declaration""... $ac_c" 1>&6
10357 echo "configure:10358: checking for _qfpclass declaration" >&5
10358   cat > conftest.$ac_ext <<EOF
10359 #line 10360 "configure"
10360 #include "confdefs.h"
10361 #include <math.h>
10362 int main() {
10363  _qfpclass(0);
10364 ; return 0; }
10365 EOF
10366 if { (eval echo configure:10367: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10367   rm -rf conftest*
10368   use__qfpclass=yes
10369 else
10370   echo "configure: failed program was:" >&5
10371   cat conftest.$ac_ext >&5
10372   rm -rf conftest*
10373   use__qfpclass=no
10374 fi
10375 rm -f conftest*
10376   echo "$ac_t""$use__qfpclass" 1>&6
10377   ac_ext=c
10378 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10379 ac_cpp='$CPP $CPPFLAGS'
10380 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10381 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10382 cross_compiling=$ac_cv_prog_cc_cross
10383
10384   if test x$use__qfpclass = x"yes"; then
10385     for ac_func in _qfpclass
10386 do
10387 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10388 echo "configure:10389: checking for $ac_func" >&5
10389 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10390   echo $ac_n "(cached) $ac_c" 1>&6
10391 else
10392   cat > conftest.$ac_ext <<EOF
10393 #line 10394 "configure"
10394 #include "confdefs.h"
10395 /* System header to define __stub macros and hopefully few prototypes,
10396     which can conflict with char $ac_func(); below.  */
10397 #include <assert.h>
10398 /* Override any gcc2 internal prototype to avoid an error.  */
10399 /* We use char because int might match the return type of a gcc2
10400     builtin and then its argument prototype would still apply.  */
10401 char $ac_func();
10402
10403 int main() {
10404
10405 /* The GNU C library defines this for functions which it implements
10406     to always fail with ENOSYS.  Some functions are actually named
10407     something starting with __ and the normal name is an alias.  */
10408 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10409 choke me
10410 #else
10411 $ac_func();
10412 #endif
10413
10414 ; return 0; }
10415 EOF
10416 if { (eval echo configure:10417: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10417   rm -rf conftest*
10418   eval "ac_cv_func_$ac_func=yes"
10419 else
10420   echo "configure: failed program was:" >&5
10421   cat conftest.$ac_ext >&5
10422   rm -rf conftest*
10423   eval "ac_cv_func_$ac_func=no"
10424 fi
10425 rm -f conftest*
10426 fi
10427
10428 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10429   echo "$ac_t""yes" 1>&6
10430     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10431   cat >> confdefs.h <<EOF
10432 #define $ac_tr_func 1
10433 EOF
10434
10435 else
10436   echo "$ac_t""no" 1>&6
10437 fi
10438 done
10439
10440   fi
10441
10442
10443
10444
10445   ac_ext=C
10446 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10447 ac_cpp='$CXXCPP $CPPFLAGS'
10448 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10449 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10450 cross_compiling=$ac_cv_prog_cxx_cross
10451
10452   echo $ac_n "checking for _isnanf declaration""... $ac_c" 1>&6
10453 echo "configure:10454: checking for _isnanf declaration" >&5
10454   cat > conftest.$ac_ext <<EOF
10455 #line 10456 "configure"
10456 #include "confdefs.h"
10457 #include <math.h>
10458 int main() {
10459  _isnanf(0);
10460 ; return 0; }
10461 EOF
10462 if { (eval echo configure:10463: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10463   rm -rf conftest*
10464   use__isnanf=yes
10465 else
10466   echo "configure: failed program was:" >&5
10467   cat conftest.$ac_ext >&5
10468   rm -rf conftest*
10469   use__isnanf=no
10470 fi
10471 rm -f conftest*
10472   echo "$ac_t""$use__isnanf" 1>&6
10473   ac_ext=c
10474 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10475 ac_cpp='$CPP $CPPFLAGS'
10476 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10477 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10478 cross_compiling=$ac_cv_prog_cc_cross
10479
10480   if test x$use__isnanf = x"yes"; then
10481     for ac_func in _isnanf
10482 do
10483 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10484 echo "configure:10485: checking for $ac_func" >&5
10485 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10486   echo $ac_n "(cached) $ac_c" 1>&6
10487 else
10488   cat > conftest.$ac_ext <<EOF
10489 #line 10490 "configure"
10490 #include "confdefs.h"
10491 /* System header to define __stub macros and hopefully few prototypes,
10492     which can conflict with char $ac_func(); below.  */
10493 #include <assert.h>
10494 /* Override any gcc2 internal prototype to avoid an error.  */
10495 /* We use char because int might match the return type of a gcc2
10496     builtin and then its argument prototype would still apply.  */
10497 char $ac_func();
10498
10499 int main() {
10500
10501 /* The GNU C library defines this for functions which it implements
10502     to always fail with ENOSYS.  Some functions are actually named
10503     something starting with __ and the normal name is an alias.  */
10504 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10505 choke me
10506 #else
10507 $ac_func();
10508 #endif
10509
10510 ; return 0; }
10511 EOF
10512 if { (eval echo configure:10513: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10513   rm -rf conftest*
10514   eval "ac_cv_func_$ac_func=yes"
10515 else
10516   echo "configure: failed program was:" >&5
10517   cat conftest.$ac_ext >&5
10518   rm -rf conftest*
10519   eval "ac_cv_func_$ac_func=no"
10520 fi
10521 rm -f conftest*
10522 fi
10523
10524 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10525   echo "$ac_t""yes" 1>&6
10526     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10527   cat >> confdefs.h <<EOF
10528 #define $ac_tr_func 1
10529 EOF
10530
10531 else
10532   echo "$ac_t""no" 1>&6
10533 fi
10534 done
10535
10536   fi
10537
10538
10539
10540   ac_ext=C
10541 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10542 ac_cpp='$CXXCPP $CPPFLAGS'
10543 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10544 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10545 cross_compiling=$ac_cv_prog_cxx_cross
10546
10547   echo $ac_n "checking for _isinff declaration""... $ac_c" 1>&6
10548 echo "configure:10549: checking for _isinff declaration" >&5
10549   cat > conftest.$ac_ext <<EOF
10550 #line 10551 "configure"
10551 #include "confdefs.h"
10552 #include <math.h>
10553 int main() {
10554  _isinff(0);
10555 ; return 0; }
10556 EOF
10557 if { (eval echo configure:10558: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10558   rm -rf conftest*
10559   use__isinff=yes
10560 else
10561   echo "configure: failed program was:" >&5
10562   cat conftest.$ac_ext >&5
10563   rm -rf conftest*
10564   use__isinff=no
10565 fi
10566 rm -f conftest*
10567   echo "$ac_t""$use__isinff" 1>&6
10568   ac_ext=c
10569 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10570 ac_cpp='$CPP $CPPFLAGS'
10571 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10572 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10573 cross_compiling=$ac_cv_prog_cc_cross
10574
10575   if test x$use__isinff = x"yes"; then
10576     for ac_func in _isinff
10577 do
10578 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10579 echo "configure:10580: checking for $ac_func" >&5
10580 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10581   echo $ac_n "(cached) $ac_c" 1>&6
10582 else
10583   cat > conftest.$ac_ext <<EOF
10584 #line 10585 "configure"
10585 #include "confdefs.h"
10586 /* System header to define __stub macros and hopefully few prototypes,
10587     which can conflict with char $ac_func(); below.  */
10588 #include <assert.h>
10589 /* Override any gcc2 internal prototype to avoid an error.  */
10590 /* We use char because int might match the return type of a gcc2
10591     builtin and then its argument prototype would still apply.  */
10592 char $ac_func();
10593
10594 int main() {
10595
10596 /* The GNU C library defines this for functions which it implements
10597     to always fail with ENOSYS.  Some functions are actually named
10598     something starting with __ and the normal name is an alias.  */
10599 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10600 choke me
10601 #else
10602 $ac_func();
10603 #endif
10604
10605 ; return 0; }
10606 EOF
10607 if { (eval echo configure:10608: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10608   rm -rf conftest*
10609   eval "ac_cv_func_$ac_func=yes"
10610 else
10611   echo "configure: failed program was:" >&5
10612   cat conftest.$ac_ext >&5
10613   rm -rf conftest*
10614   eval "ac_cv_func_$ac_func=no"
10615 fi
10616 rm -f conftest*
10617 fi
10618
10619 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10620   echo "$ac_t""yes" 1>&6
10621     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10622   cat >> confdefs.h <<EOF
10623 #define $ac_tr_func 1
10624 EOF
10625
10626 else
10627   echo "$ac_t""no" 1>&6
10628 fi
10629 done
10630
10631   fi
10632
10633
10634
10635   ac_ext=C
10636 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10637 ac_cpp='$CXXCPP $CPPFLAGS'
10638 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10639 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10640 cross_compiling=$ac_cv_prog_cxx_cross
10641
10642   echo $ac_n "checking for _acosf declaration""... $ac_c" 1>&6
10643 echo "configure:10644: checking for _acosf declaration" >&5
10644   cat > conftest.$ac_ext <<EOF
10645 #line 10646 "configure"
10646 #include "confdefs.h"
10647 #include <math.h>
10648 int main() {
10649  _acosf(0);
10650 ; return 0; }
10651 EOF
10652 if { (eval echo configure:10653: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10653   rm -rf conftest*
10654   use__acosf=yes
10655 else
10656   echo "configure: failed program was:" >&5
10657   cat conftest.$ac_ext >&5
10658   rm -rf conftest*
10659   use__acosf=no
10660 fi
10661 rm -f conftest*
10662   echo "$ac_t""$use__acosf" 1>&6
10663   ac_ext=c
10664 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10665 ac_cpp='$CPP $CPPFLAGS'
10666 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10667 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10668 cross_compiling=$ac_cv_prog_cc_cross
10669
10670   if test x$use__acosf = x"yes"; then
10671     for ac_func in _acosf
10672 do
10673 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10674 echo "configure:10675: checking for $ac_func" >&5
10675 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10676   echo $ac_n "(cached) $ac_c" 1>&6
10677 else
10678   cat > conftest.$ac_ext <<EOF
10679 #line 10680 "configure"
10680 #include "confdefs.h"
10681 /* System header to define __stub macros and hopefully few prototypes,
10682     which can conflict with char $ac_func(); below.  */
10683 #include <assert.h>
10684 /* Override any gcc2 internal prototype to avoid an error.  */
10685 /* We use char because int might match the return type of a gcc2
10686     builtin and then its argument prototype would still apply.  */
10687 char $ac_func();
10688
10689 int main() {
10690
10691 /* The GNU C library defines this for functions which it implements
10692     to always fail with ENOSYS.  Some functions are actually named
10693     something starting with __ and the normal name is an alias.  */
10694 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10695 choke me
10696 #else
10697 $ac_func();
10698 #endif
10699
10700 ; return 0; }
10701 EOF
10702 if { (eval echo configure:10703: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10703   rm -rf conftest*
10704   eval "ac_cv_func_$ac_func=yes"
10705 else
10706   echo "configure: failed program was:" >&5
10707   cat conftest.$ac_ext >&5
10708   rm -rf conftest*
10709   eval "ac_cv_func_$ac_func=no"
10710 fi
10711 rm -f conftest*
10712 fi
10713
10714 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10715   echo "$ac_t""yes" 1>&6
10716     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10717   cat >> confdefs.h <<EOF
10718 #define $ac_tr_func 1
10719 EOF
10720
10721 else
10722   echo "$ac_t""no" 1>&6
10723 fi
10724 done
10725
10726   fi
10727
10728
10729
10730   ac_ext=C
10731 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10732 ac_cpp='$CXXCPP $CPPFLAGS'
10733 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10734 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10735 cross_compiling=$ac_cv_prog_cxx_cross
10736
10737   echo $ac_n "checking for _asinf declaration""... $ac_c" 1>&6
10738 echo "configure:10739: checking for _asinf declaration" >&5
10739   cat > conftest.$ac_ext <<EOF
10740 #line 10741 "configure"
10741 #include "confdefs.h"
10742 #include <math.h>
10743 int main() {
10744  _asinf(0);
10745 ; return 0; }
10746 EOF
10747 if { (eval echo configure:10748: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10748   rm -rf conftest*
10749   use__asinf=yes
10750 else
10751   echo "configure: failed program was:" >&5
10752   cat conftest.$ac_ext >&5
10753   rm -rf conftest*
10754   use__asinf=no
10755 fi
10756 rm -f conftest*
10757   echo "$ac_t""$use__asinf" 1>&6
10758   ac_ext=c
10759 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10760 ac_cpp='$CPP $CPPFLAGS'
10761 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10762 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10763 cross_compiling=$ac_cv_prog_cc_cross
10764
10765   if test x$use__asinf = x"yes"; then
10766     for ac_func in _asinf
10767 do
10768 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10769 echo "configure:10770: checking for $ac_func" >&5
10770 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10771   echo $ac_n "(cached) $ac_c" 1>&6
10772 else
10773   cat > conftest.$ac_ext <<EOF
10774 #line 10775 "configure"
10775 #include "confdefs.h"
10776 /* System header to define __stub macros and hopefully few prototypes,
10777     which can conflict with char $ac_func(); below.  */
10778 #include <assert.h>
10779 /* Override any gcc2 internal prototype to avoid an error.  */
10780 /* We use char because int might match the return type of a gcc2
10781     builtin and then its argument prototype would still apply.  */
10782 char $ac_func();
10783
10784 int main() {
10785
10786 /* The GNU C library defines this for functions which it implements
10787     to always fail with ENOSYS.  Some functions are actually named
10788     something starting with __ and the normal name is an alias.  */
10789 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10790 choke me
10791 #else
10792 $ac_func();
10793 #endif
10794
10795 ; return 0; }
10796 EOF
10797 if { (eval echo configure:10798: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10798   rm -rf conftest*
10799   eval "ac_cv_func_$ac_func=yes"
10800 else
10801   echo "configure: failed program was:" >&5
10802   cat conftest.$ac_ext >&5
10803   rm -rf conftest*
10804   eval "ac_cv_func_$ac_func=no"
10805 fi
10806 rm -f conftest*
10807 fi
10808
10809 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10810   echo "$ac_t""yes" 1>&6
10811     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10812   cat >> confdefs.h <<EOF
10813 #define $ac_tr_func 1
10814 EOF
10815
10816 else
10817   echo "$ac_t""no" 1>&6
10818 fi
10819 done
10820
10821   fi
10822
10823
10824
10825   ac_ext=C
10826 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10827 ac_cpp='$CXXCPP $CPPFLAGS'
10828 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10829 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10830 cross_compiling=$ac_cv_prog_cxx_cross
10831
10832   echo $ac_n "checking for _atanf declaration""... $ac_c" 1>&6
10833 echo "configure:10834: checking for _atanf declaration" >&5
10834   cat > conftest.$ac_ext <<EOF
10835 #line 10836 "configure"
10836 #include "confdefs.h"
10837 #include <math.h>
10838 int main() {
10839  _atanf(0);
10840 ; return 0; }
10841 EOF
10842 if { (eval echo configure:10843: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10843   rm -rf conftest*
10844   use__atanf=yes
10845 else
10846   echo "configure: failed program was:" >&5
10847   cat conftest.$ac_ext >&5
10848   rm -rf conftest*
10849   use__atanf=no
10850 fi
10851 rm -f conftest*
10852   echo "$ac_t""$use__atanf" 1>&6
10853   ac_ext=c
10854 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10855 ac_cpp='$CPP $CPPFLAGS'
10856 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10857 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10858 cross_compiling=$ac_cv_prog_cc_cross
10859
10860   if test x$use__atanf = x"yes"; then
10861     for ac_func in _atanf
10862 do
10863 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10864 echo "configure:10865: checking for $ac_func" >&5
10865 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10866   echo $ac_n "(cached) $ac_c" 1>&6
10867 else
10868   cat > conftest.$ac_ext <<EOF
10869 #line 10870 "configure"
10870 #include "confdefs.h"
10871 /* System header to define __stub macros and hopefully few prototypes,
10872     which can conflict with char $ac_func(); below.  */
10873 #include <assert.h>
10874 /* Override any gcc2 internal prototype to avoid an error.  */
10875 /* We use char because int might match the return type of a gcc2
10876     builtin and then its argument prototype would still apply.  */
10877 char $ac_func();
10878
10879 int main() {
10880
10881 /* The GNU C library defines this for functions which it implements
10882     to always fail with ENOSYS.  Some functions are actually named
10883     something starting with __ and the normal name is an alias.  */
10884 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10885 choke me
10886 #else
10887 $ac_func();
10888 #endif
10889
10890 ; return 0; }
10891 EOF
10892 if { (eval echo configure:10893: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10893   rm -rf conftest*
10894   eval "ac_cv_func_$ac_func=yes"
10895 else
10896   echo "configure: failed program was:" >&5
10897   cat conftest.$ac_ext >&5
10898   rm -rf conftest*
10899   eval "ac_cv_func_$ac_func=no"
10900 fi
10901 rm -f conftest*
10902 fi
10903
10904 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10905   echo "$ac_t""yes" 1>&6
10906     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10907   cat >> confdefs.h <<EOF
10908 #define $ac_tr_func 1
10909 EOF
10910
10911 else
10912   echo "$ac_t""no" 1>&6
10913 fi
10914 done
10915
10916   fi
10917
10918
10919
10920   ac_ext=C
10921 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10922 ac_cpp='$CXXCPP $CPPFLAGS'
10923 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10924 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10925 cross_compiling=$ac_cv_prog_cxx_cross
10926
10927   echo $ac_n "checking for _atan2f declaration""... $ac_c" 1>&6
10928 echo "configure:10929: checking for _atan2f declaration" >&5
10929   cat > conftest.$ac_ext <<EOF
10930 #line 10931 "configure"
10931 #include "confdefs.h"
10932 #include <math.h>
10933 int main() {
10934  _atan2f(0, 0);
10935 ; return 0; }
10936 EOF
10937 if { (eval echo configure:10938: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10938   rm -rf conftest*
10939   use__atan2f=yes
10940 else
10941   echo "configure: failed program was:" >&5
10942   cat conftest.$ac_ext >&5
10943   rm -rf conftest*
10944   use__atan2f=no
10945 fi
10946 rm -f conftest*
10947   echo "$ac_t""$use__atan2f" 1>&6
10948   ac_ext=c
10949 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10950 ac_cpp='$CPP $CPPFLAGS'
10951 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10952 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10953 cross_compiling=$ac_cv_prog_cc_cross
10954
10955   if test x$use__atan2f = x"yes"; then
10956     for ac_func in _atan2f
10957 do
10958 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10959 echo "configure:10960: checking for $ac_func" >&5
10960 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10961   echo $ac_n "(cached) $ac_c" 1>&6
10962 else
10963   cat > conftest.$ac_ext <<EOF
10964 #line 10965 "configure"
10965 #include "confdefs.h"
10966 /* System header to define __stub macros and hopefully few prototypes,
10967     which can conflict with char $ac_func(); below.  */
10968 #include <assert.h>
10969 /* Override any gcc2 internal prototype to avoid an error.  */
10970 /* We use char because int might match the return type of a gcc2
10971     builtin and then its argument prototype would still apply.  */
10972 char $ac_func();
10973
10974 int main() {
10975
10976 /* The GNU C library defines this for functions which it implements
10977     to always fail with ENOSYS.  Some functions are actually named
10978     something starting with __ and the normal name is an alias.  */
10979 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10980 choke me
10981 #else
10982 $ac_func();
10983 #endif
10984
10985 ; return 0; }
10986 EOF
10987 if { (eval echo configure:10988: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10988   rm -rf conftest*
10989   eval "ac_cv_func_$ac_func=yes"
10990 else
10991   echo "configure: failed program was:" >&5
10992   cat conftest.$ac_ext >&5
10993   rm -rf conftest*
10994   eval "ac_cv_func_$ac_func=no"
10995 fi
10996 rm -f conftest*
10997 fi
10998
10999 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11000   echo "$ac_t""yes" 1>&6
11001     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11002   cat >> confdefs.h <<EOF
11003 #define $ac_tr_func 1
11004 EOF
11005
11006 else
11007   echo "$ac_t""no" 1>&6
11008 fi
11009 done
11010
11011   fi
11012
11013
11014
11015   ac_ext=C
11016 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11017 ac_cpp='$CXXCPP $CPPFLAGS'
11018 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11019 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11020 cross_compiling=$ac_cv_prog_cxx_cross
11021
11022   echo $ac_n "checking for _ceilf declaration""... $ac_c" 1>&6
11023 echo "configure:11024: checking for _ceilf declaration" >&5
11024   cat > conftest.$ac_ext <<EOF
11025 #line 11026 "configure"
11026 #include "confdefs.h"
11027 #include <math.h>
11028 int main() {
11029  _ceilf(0);
11030 ; return 0; }
11031 EOF
11032 if { (eval echo configure:11033: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11033   rm -rf conftest*
11034   use__ceilf=yes
11035 else
11036   echo "configure: failed program was:" >&5
11037   cat conftest.$ac_ext >&5
11038   rm -rf conftest*
11039   use__ceilf=no
11040 fi
11041 rm -f conftest*
11042   echo "$ac_t""$use__ceilf" 1>&6
11043   ac_ext=c
11044 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11045 ac_cpp='$CPP $CPPFLAGS'
11046 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11047 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11048 cross_compiling=$ac_cv_prog_cc_cross
11049
11050   if test x$use__ceilf = x"yes"; then
11051     for ac_func in _ceilf
11052 do
11053 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11054 echo "configure:11055: checking for $ac_func" >&5
11055 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11056   echo $ac_n "(cached) $ac_c" 1>&6
11057 else
11058   cat > conftest.$ac_ext <<EOF
11059 #line 11060 "configure"
11060 #include "confdefs.h"
11061 /* System header to define __stub macros and hopefully few prototypes,
11062     which can conflict with char $ac_func(); below.  */
11063 #include <assert.h>
11064 /* Override any gcc2 internal prototype to avoid an error.  */
11065 /* We use char because int might match the return type of a gcc2
11066     builtin and then its argument prototype would still apply.  */
11067 char $ac_func();
11068
11069 int main() {
11070
11071 /* The GNU C library defines this for functions which it implements
11072     to always fail with ENOSYS.  Some functions are actually named
11073     something starting with __ and the normal name is an alias.  */
11074 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11075 choke me
11076 #else
11077 $ac_func();
11078 #endif
11079
11080 ; return 0; }
11081 EOF
11082 if { (eval echo configure:11083: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11083   rm -rf conftest*
11084   eval "ac_cv_func_$ac_func=yes"
11085 else
11086   echo "configure: failed program was:" >&5
11087   cat conftest.$ac_ext >&5
11088   rm -rf conftest*
11089   eval "ac_cv_func_$ac_func=no"
11090 fi
11091 rm -f conftest*
11092 fi
11093
11094 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11095   echo "$ac_t""yes" 1>&6
11096     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11097   cat >> confdefs.h <<EOF
11098 #define $ac_tr_func 1
11099 EOF
11100
11101 else
11102   echo "$ac_t""no" 1>&6
11103 fi
11104 done
11105
11106   fi
11107
11108
11109
11110   ac_ext=C
11111 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11112 ac_cpp='$CXXCPP $CPPFLAGS'
11113 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11114 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11115 cross_compiling=$ac_cv_prog_cxx_cross
11116
11117   echo $ac_n "checking for _cosf declaration""... $ac_c" 1>&6
11118 echo "configure:11119: checking for _cosf declaration" >&5
11119   cat > conftest.$ac_ext <<EOF
11120 #line 11121 "configure"
11121 #include "confdefs.h"
11122 #include <math.h>
11123 int main() {
11124  _cosf(0);
11125 ; return 0; }
11126 EOF
11127 if { (eval echo configure:11128: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11128   rm -rf conftest*
11129   use__cosf=yes
11130 else
11131   echo "configure: failed program was:" >&5
11132   cat conftest.$ac_ext >&5
11133   rm -rf conftest*
11134   use__cosf=no
11135 fi
11136 rm -f conftest*
11137   echo "$ac_t""$use__cosf" 1>&6
11138   ac_ext=c
11139 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11140 ac_cpp='$CPP $CPPFLAGS'
11141 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11142 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11143 cross_compiling=$ac_cv_prog_cc_cross
11144
11145   if test x$use__cosf = x"yes"; then
11146     for ac_func in _cosf
11147 do
11148 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11149 echo "configure:11150: checking for $ac_func" >&5
11150 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11151   echo $ac_n "(cached) $ac_c" 1>&6
11152 else
11153   cat > conftest.$ac_ext <<EOF
11154 #line 11155 "configure"
11155 #include "confdefs.h"
11156 /* System header to define __stub macros and hopefully few prototypes,
11157     which can conflict with char $ac_func(); below.  */
11158 #include <assert.h>
11159 /* Override any gcc2 internal prototype to avoid an error.  */
11160 /* We use char because int might match the return type of a gcc2
11161     builtin and then its argument prototype would still apply.  */
11162 char $ac_func();
11163
11164 int main() {
11165
11166 /* The GNU C library defines this for functions which it implements
11167     to always fail with ENOSYS.  Some functions are actually named
11168     something starting with __ and the normal name is an alias.  */
11169 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11170 choke me
11171 #else
11172 $ac_func();
11173 #endif
11174
11175 ; return 0; }
11176 EOF
11177 if { (eval echo configure:11178: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11178   rm -rf conftest*
11179   eval "ac_cv_func_$ac_func=yes"
11180 else
11181   echo "configure: failed program was:" >&5
11182   cat conftest.$ac_ext >&5
11183   rm -rf conftest*
11184   eval "ac_cv_func_$ac_func=no"
11185 fi
11186 rm -f conftest*
11187 fi
11188
11189 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11190   echo "$ac_t""yes" 1>&6
11191     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11192   cat >> confdefs.h <<EOF
11193 #define $ac_tr_func 1
11194 EOF
11195
11196 else
11197   echo "$ac_t""no" 1>&6
11198 fi
11199 done
11200
11201   fi
11202
11203
11204
11205   ac_ext=C
11206 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11207 ac_cpp='$CXXCPP $CPPFLAGS'
11208 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11209 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11210 cross_compiling=$ac_cv_prog_cxx_cross
11211
11212   echo $ac_n "checking for _coshf declaration""... $ac_c" 1>&6
11213 echo "configure:11214: checking for _coshf declaration" >&5
11214   cat > conftest.$ac_ext <<EOF
11215 #line 11216 "configure"
11216 #include "confdefs.h"
11217 #include <math.h>
11218 int main() {
11219  _coshf(0);
11220 ; return 0; }
11221 EOF
11222 if { (eval echo configure:11223: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11223   rm -rf conftest*
11224   use__coshf=yes
11225 else
11226   echo "configure: failed program was:" >&5
11227   cat conftest.$ac_ext >&5
11228   rm -rf conftest*
11229   use__coshf=no
11230 fi
11231 rm -f conftest*
11232   echo "$ac_t""$use__coshf" 1>&6
11233   ac_ext=c
11234 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11235 ac_cpp='$CPP $CPPFLAGS'
11236 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11237 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11238 cross_compiling=$ac_cv_prog_cc_cross
11239
11240   if test x$use__coshf = x"yes"; then
11241     for ac_func in _coshf
11242 do
11243 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11244 echo "configure:11245: checking for $ac_func" >&5
11245 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11246   echo $ac_n "(cached) $ac_c" 1>&6
11247 else
11248   cat > conftest.$ac_ext <<EOF
11249 #line 11250 "configure"
11250 #include "confdefs.h"
11251 /* System header to define __stub macros and hopefully few prototypes,
11252     which can conflict with char $ac_func(); below.  */
11253 #include <assert.h>
11254 /* Override any gcc2 internal prototype to avoid an error.  */
11255 /* We use char because int might match the return type of a gcc2
11256     builtin and then its argument prototype would still apply.  */
11257 char $ac_func();
11258
11259 int main() {
11260
11261 /* The GNU C library defines this for functions which it implements
11262     to always fail with ENOSYS.  Some functions are actually named
11263     something starting with __ and the normal name is an alias.  */
11264 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11265 choke me
11266 #else
11267 $ac_func();
11268 #endif
11269
11270 ; return 0; }
11271 EOF
11272 if { (eval echo configure:11273: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11273   rm -rf conftest*
11274   eval "ac_cv_func_$ac_func=yes"
11275 else
11276   echo "configure: failed program was:" >&5
11277   cat conftest.$ac_ext >&5
11278   rm -rf conftest*
11279   eval "ac_cv_func_$ac_func=no"
11280 fi
11281 rm -f conftest*
11282 fi
11283
11284 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11285   echo "$ac_t""yes" 1>&6
11286     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11287   cat >> confdefs.h <<EOF
11288 #define $ac_tr_func 1
11289 EOF
11290
11291 else
11292   echo "$ac_t""no" 1>&6
11293 fi
11294 done
11295
11296   fi
11297
11298
11299
11300   ac_ext=C
11301 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11302 ac_cpp='$CXXCPP $CPPFLAGS'
11303 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11304 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11305 cross_compiling=$ac_cv_prog_cxx_cross
11306
11307   echo $ac_n "checking for _expf declaration""... $ac_c" 1>&6
11308 echo "configure:11309: checking for _expf declaration" >&5
11309   cat > conftest.$ac_ext <<EOF
11310 #line 11311 "configure"
11311 #include "confdefs.h"
11312 #include <math.h>
11313 int main() {
11314  _expf(0);
11315 ; return 0; }
11316 EOF
11317 if { (eval echo configure:11318: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11318   rm -rf conftest*
11319   use__expf=yes
11320 else
11321   echo "configure: failed program was:" >&5
11322   cat conftest.$ac_ext >&5
11323   rm -rf conftest*
11324   use__expf=no
11325 fi
11326 rm -f conftest*
11327   echo "$ac_t""$use__expf" 1>&6
11328   ac_ext=c
11329 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11330 ac_cpp='$CPP $CPPFLAGS'
11331 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11332 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11333 cross_compiling=$ac_cv_prog_cc_cross
11334
11335   if test x$use__expf = x"yes"; then
11336     for ac_func in _expf
11337 do
11338 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11339 echo "configure:11340: checking for $ac_func" >&5
11340 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11341   echo $ac_n "(cached) $ac_c" 1>&6
11342 else
11343   cat > conftest.$ac_ext <<EOF
11344 #line 11345 "configure"
11345 #include "confdefs.h"
11346 /* System header to define __stub macros and hopefully few prototypes,
11347     which can conflict with char $ac_func(); below.  */
11348 #include <assert.h>
11349 /* Override any gcc2 internal prototype to avoid an error.  */
11350 /* We use char because int might match the return type of a gcc2
11351     builtin and then its argument prototype would still apply.  */
11352 char $ac_func();
11353
11354 int main() {
11355
11356 /* The GNU C library defines this for functions which it implements
11357     to always fail with ENOSYS.  Some functions are actually named
11358     something starting with __ and the normal name is an alias.  */
11359 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11360 choke me
11361 #else
11362 $ac_func();
11363 #endif
11364
11365 ; return 0; }
11366 EOF
11367 if { (eval echo configure:11368: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11368   rm -rf conftest*
11369   eval "ac_cv_func_$ac_func=yes"
11370 else
11371   echo "configure: failed program was:" >&5
11372   cat conftest.$ac_ext >&5
11373   rm -rf conftest*
11374   eval "ac_cv_func_$ac_func=no"
11375 fi
11376 rm -f conftest*
11377 fi
11378
11379 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11380   echo "$ac_t""yes" 1>&6
11381     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11382   cat >> confdefs.h <<EOF
11383 #define $ac_tr_func 1
11384 EOF
11385
11386 else
11387   echo "$ac_t""no" 1>&6
11388 fi
11389 done
11390
11391   fi
11392
11393
11394
11395   ac_ext=C
11396 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11397 ac_cpp='$CXXCPP $CPPFLAGS'
11398 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11399 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11400 cross_compiling=$ac_cv_prog_cxx_cross
11401
11402   echo $ac_n "checking for _fabsf declaration""... $ac_c" 1>&6
11403 echo "configure:11404: checking for _fabsf declaration" >&5
11404   cat > conftest.$ac_ext <<EOF
11405 #line 11406 "configure"
11406 #include "confdefs.h"
11407 #include <math.h>
11408 int main() {
11409  _fabsf(0);
11410 ; return 0; }
11411 EOF
11412 if { (eval echo configure:11413: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11413   rm -rf conftest*
11414   use__fabsf=yes
11415 else
11416   echo "configure: failed program was:" >&5
11417   cat conftest.$ac_ext >&5
11418   rm -rf conftest*
11419   use__fabsf=no
11420 fi
11421 rm -f conftest*
11422   echo "$ac_t""$use__fabsf" 1>&6
11423   ac_ext=c
11424 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11425 ac_cpp='$CPP $CPPFLAGS'
11426 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11427 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11428 cross_compiling=$ac_cv_prog_cc_cross
11429
11430   if test x$use__fabsf = x"yes"; then
11431     for ac_func in _fabsf
11432 do
11433 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11434 echo "configure:11435: checking for $ac_func" >&5
11435 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11436   echo $ac_n "(cached) $ac_c" 1>&6
11437 else
11438   cat > conftest.$ac_ext <<EOF
11439 #line 11440 "configure"
11440 #include "confdefs.h"
11441 /* System header to define __stub macros and hopefully few prototypes,
11442     which can conflict with char $ac_func(); below.  */
11443 #include <assert.h>
11444 /* Override any gcc2 internal prototype to avoid an error.  */
11445 /* We use char because int might match the return type of a gcc2
11446     builtin and then its argument prototype would still apply.  */
11447 char $ac_func();
11448
11449 int main() {
11450
11451 /* The GNU C library defines this for functions which it implements
11452     to always fail with ENOSYS.  Some functions are actually named
11453     something starting with __ and the normal name is an alias.  */
11454 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11455 choke me
11456 #else
11457 $ac_func();
11458 #endif
11459
11460 ; return 0; }
11461 EOF
11462 if { (eval echo configure:11463: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11463   rm -rf conftest*
11464   eval "ac_cv_func_$ac_func=yes"
11465 else
11466   echo "configure: failed program was:" >&5
11467   cat conftest.$ac_ext >&5
11468   rm -rf conftest*
11469   eval "ac_cv_func_$ac_func=no"
11470 fi
11471 rm -f conftest*
11472 fi
11473
11474 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11475   echo "$ac_t""yes" 1>&6
11476     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11477   cat >> confdefs.h <<EOF
11478 #define $ac_tr_func 1
11479 EOF
11480
11481 else
11482   echo "$ac_t""no" 1>&6
11483 fi
11484 done
11485
11486   fi
11487
11488
11489
11490   ac_ext=C
11491 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11492 ac_cpp='$CXXCPP $CPPFLAGS'
11493 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11494 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11495 cross_compiling=$ac_cv_prog_cxx_cross
11496
11497   echo $ac_n "checking for _floorf declaration""... $ac_c" 1>&6
11498 echo "configure:11499: checking for _floorf declaration" >&5
11499   cat > conftest.$ac_ext <<EOF
11500 #line 11501 "configure"
11501 #include "confdefs.h"
11502 #include <math.h>
11503 int main() {
11504  _floorf(0);
11505 ; return 0; }
11506 EOF
11507 if { (eval echo configure:11508: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11508   rm -rf conftest*
11509   use__floorf=yes
11510 else
11511   echo "configure: failed program was:" >&5
11512   cat conftest.$ac_ext >&5
11513   rm -rf conftest*
11514   use__floorf=no
11515 fi
11516 rm -f conftest*
11517   echo "$ac_t""$use__floorf" 1>&6
11518   ac_ext=c
11519 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11520 ac_cpp='$CPP $CPPFLAGS'
11521 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11522 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11523 cross_compiling=$ac_cv_prog_cc_cross
11524
11525   if test x$use__floorf = x"yes"; then
11526     for ac_func in _floorf
11527 do
11528 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11529 echo "configure:11530: checking for $ac_func" >&5
11530 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11531   echo $ac_n "(cached) $ac_c" 1>&6
11532 else
11533   cat > conftest.$ac_ext <<EOF
11534 #line 11535 "configure"
11535 #include "confdefs.h"
11536 /* System header to define __stub macros and hopefully few prototypes,
11537     which can conflict with char $ac_func(); below.  */
11538 #include <assert.h>
11539 /* Override any gcc2 internal prototype to avoid an error.  */
11540 /* We use char because int might match the return type of a gcc2
11541     builtin and then its argument prototype would still apply.  */
11542 char $ac_func();
11543
11544 int main() {
11545
11546 /* The GNU C library defines this for functions which it implements
11547     to always fail with ENOSYS.  Some functions are actually named
11548     something starting with __ and the normal name is an alias.  */
11549 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11550 choke me
11551 #else
11552 $ac_func();
11553 #endif
11554
11555 ; return 0; }
11556 EOF
11557 if { (eval echo configure:11558: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11558   rm -rf conftest*
11559   eval "ac_cv_func_$ac_func=yes"
11560 else
11561   echo "configure: failed program was:" >&5
11562   cat conftest.$ac_ext >&5
11563   rm -rf conftest*
11564   eval "ac_cv_func_$ac_func=no"
11565 fi
11566 rm -f conftest*
11567 fi
11568
11569 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11570   echo "$ac_t""yes" 1>&6
11571     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11572   cat >> confdefs.h <<EOF
11573 #define $ac_tr_func 1
11574 EOF
11575
11576 else
11577   echo "$ac_t""no" 1>&6
11578 fi
11579 done
11580
11581   fi
11582
11583
11584
11585   ac_ext=C
11586 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11587 ac_cpp='$CXXCPP $CPPFLAGS'
11588 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11589 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11590 cross_compiling=$ac_cv_prog_cxx_cross
11591
11592   echo $ac_n "checking for _fmodf declaration""... $ac_c" 1>&6
11593 echo "configure:11594: checking for _fmodf declaration" >&5
11594   cat > conftest.$ac_ext <<EOF
11595 #line 11596 "configure"
11596 #include "confdefs.h"
11597 #include <math.h>
11598 int main() {
11599  _fmodf(0, 0);
11600 ; return 0; }
11601 EOF
11602 if { (eval echo configure:11603: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11603   rm -rf conftest*
11604   use__fmodf=yes
11605 else
11606   echo "configure: failed program was:" >&5
11607   cat conftest.$ac_ext >&5
11608   rm -rf conftest*
11609   use__fmodf=no
11610 fi
11611 rm -f conftest*
11612   echo "$ac_t""$use__fmodf" 1>&6
11613   ac_ext=c
11614 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11615 ac_cpp='$CPP $CPPFLAGS'
11616 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11617 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11618 cross_compiling=$ac_cv_prog_cc_cross
11619
11620   if test x$use__fmodf = x"yes"; then
11621     for ac_func in _fmodf
11622 do
11623 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11624 echo "configure:11625: checking for $ac_func" >&5
11625 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11626   echo $ac_n "(cached) $ac_c" 1>&6
11627 else
11628   cat > conftest.$ac_ext <<EOF
11629 #line 11630 "configure"
11630 #include "confdefs.h"
11631 /* System header to define __stub macros and hopefully few prototypes,
11632     which can conflict with char $ac_func(); below.  */
11633 #include <assert.h>
11634 /* Override any gcc2 internal prototype to avoid an error.  */
11635 /* We use char because int might match the return type of a gcc2
11636     builtin and then its argument prototype would still apply.  */
11637 char $ac_func();
11638
11639 int main() {
11640
11641 /* The GNU C library defines this for functions which it implements
11642     to always fail with ENOSYS.  Some functions are actually named
11643     something starting with __ and the normal name is an alias.  */
11644 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11645 choke me
11646 #else
11647 $ac_func();
11648 #endif
11649
11650 ; return 0; }
11651 EOF
11652 if { (eval echo configure:11653: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11653   rm -rf conftest*
11654   eval "ac_cv_func_$ac_func=yes"
11655 else
11656   echo "configure: failed program was:" >&5
11657   cat conftest.$ac_ext >&5
11658   rm -rf conftest*
11659   eval "ac_cv_func_$ac_func=no"
11660 fi
11661 rm -f conftest*
11662 fi
11663
11664 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11665   echo "$ac_t""yes" 1>&6
11666     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11667   cat >> confdefs.h <<EOF
11668 #define $ac_tr_func 1
11669 EOF
11670
11671 else
11672   echo "$ac_t""no" 1>&6
11673 fi
11674 done
11675
11676   fi
11677
11678
11679
11680   ac_ext=C
11681 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11682 ac_cpp='$CXXCPP $CPPFLAGS'
11683 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11684 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11685 cross_compiling=$ac_cv_prog_cxx_cross
11686
11687   echo $ac_n "checking for _frexpf declaration""... $ac_c" 1>&6
11688 echo "configure:11689: checking for _frexpf declaration" >&5
11689   cat > conftest.$ac_ext <<EOF
11690 #line 11691 "configure"
11691 #include "confdefs.h"
11692 #include <math.h>
11693 int main() {
11694  _frexpf(0, 0);
11695 ; return 0; }
11696 EOF
11697 if { (eval echo configure:11698: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11698   rm -rf conftest*
11699   use__frexpf=yes
11700 else
11701   echo "configure: failed program was:" >&5
11702   cat conftest.$ac_ext >&5
11703   rm -rf conftest*
11704   use__frexpf=no
11705 fi
11706 rm -f conftest*
11707   echo "$ac_t""$use__frexpf" 1>&6
11708   ac_ext=c
11709 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11710 ac_cpp='$CPP $CPPFLAGS'
11711 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11712 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11713 cross_compiling=$ac_cv_prog_cc_cross
11714
11715   if test x$use__frexpf = x"yes"; then
11716     for ac_func in _frexpf
11717 do
11718 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11719 echo "configure:11720: checking for $ac_func" >&5
11720 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11721   echo $ac_n "(cached) $ac_c" 1>&6
11722 else
11723   cat > conftest.$ac_ext <<EOF
11724 #line 11725 "configure"
11725 #include "confdefs.h"
11726 /* System header to define __stub macros and hopefully few prototypes,
11727     which can conflict with char $ac_func(); below.  */
11728 #include <assert.h>
11729 /* Override any gcc2 internal prototype to avoid an error.  */
11730 /* We use char because int might match the return type of a gcc2
11731     builtin and then its argument prototype would still apply.  */
11732 char $ac_func();
11733
11734 int main() {
11735
11736 /* The GNU C library defines this for functions which it implements
11737     to always fail with ENOSYS.  Some functions are actually named
11738     something starting with __ and the normal name is an alias.  */
11739 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11740 choke me
11741 #else
11742 $ac_func();
11743 #endif
11744
11745 ; return 0; }
11746 EOF
11747 if { (eval echo configure:11748: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11748   rm -rf conftest*
11749   eval "ac_cv_func_$ac_func=yes"
11750 else
11751   echo "configure: failed program was:" >&5
11752   cat conftest.$ac_ext >&5
11753   rm -rf conftest*
11754   eval "ac_cv_func_$ac_func=no"
11755 fi
11756 rm -f conftest*
11757 fi
11758
11759 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11760   echo "$ac_t""yes" 1>&6
11761     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11762   cat >> confdefs.h <<EOF
11763 #define $ac_tr_func 1
11764 EOF
11765
11766 else
11767   echo "$ac_t""no" 1>&6
11768 fi
11769 done
11770
11771   fi
11772
11773
11774
11775   ac_ext=C
11776 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11777 ac_cpp='$CXXCPP $CPPFLAGS'
11778 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11779 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11780 cross_compiling=$ac_cv_prog_cxx_cross
11781
11782   echo $ac_n "checking for _ldexpf declaration""... $ac_c" 1>&6
11783 echo "configure:11784: checking for _ldexpf declaration" >&5
11784   cat > conftest.$ac_ext <<EOF
11785 #line 11786 "configure"
11786 #include "confdefs.h"
11787 #include <math.h>
11788 int main() {
11789  _ldexpf(0, 0);
11790 ; return 0; }
11791 EOF
11792 if { (eval echo configure:11793: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11793   rm -rf conftest*
11794   use__ldexpf=yes
11795 else
11796   echo "configure: failed program was:" >&5
11797   cat conftest.$ac_ext >&5
11798   rm -rf conftest*
11799   use__ldexpf=no
11800 fi
11801 rm -f conftest*
11802   echo "$ac_t""$use__ldexpf" 1>&6
11803   ac_ext=c
11804 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11805 ac_cpp='$CPP $CPPFLAGS'
11806 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11807 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11808 cross_compiling=$ac_cv_prog_cc_cross
11809
11810   if test x$use__ldexpf = x"yes"; then
11811     for ac_func in _ldexpf
11812 do
11813 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11814 echo "configure:11815: checking for $ac_func" >&5
11815 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11816   echo $ac_n "(cached) $ac_c" 1>&6
11817 else
11818   cat > conftest.$ac_ext <<EOF
11819 #line 11820 "configure"
11820 #include "confdefs.h"
11821 /* System header to define __stub macros and hopefully few prototypes,
11822     which can conflict with char $ac_func(); below.  */
11823 #include <assert.h>
11824 /* Override any gcc2 internal prototype to avoid an error.  */
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 $ac_func();
11828
11829 int main() {
11830
11831 /* The GNU C library defines this for functions which it implements
11832     to always fail with ENOSYS.  Some functions are actually named
11833     something starting with __ and the normal name is an alias.  */
11834 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11835 choke me
11836 #else
11837 $ac_func();
11838 #endif
11839
11840 ; return 0; }
11841 EOF
11842 if { (eval echo configure:11843: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11843   rm -rf conftest*
11844   eval "ac_cv_func_$ac_func=yes"
11845 else
11846   echo "configure: failed program was:" >&5
11847   cat conftest.$ac_ext >&5
11848   rm -rf conftest*
11849   eval "ac_cv_func_$ac_func=no"
11850 fi
11851 rm -f conftest*
11852 fi
11853
11854 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11855   echo "$ac_t""yes" 1>&6
11856     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11857   cat >> confdefs.h <<EOF
11858 #define $ac_tr_func 1
11859 EOF
11860
11861 else
11862   echo "$ac_t""no" 1>&6
11863 fi
11864 done
11865
11866   fi
11867
11868
11869
11870   ac_ext=C
11871 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11872 ac_cpp='$CXXCPP $CPPFLAGS'
11873 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11874 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11875 cross_compiling=$ac_cv_prog_cxx_cross
11876
11877   echo $ac_n "checking for _logf declaration""... $ac_c" 1>&6
11878 echo "configure:11879: checking for _logf declaration" >&5
11879   cat > conftest.$ac_ext <<EOF
11880 #line 11881 "configure"
11881 #include "confdefs.h"
11882 #include <math.h>
11883 int main() {
11884  _logf(0);
11885 ; return 0; }
11886 EOF
11887 if { (eval echo configure:11888: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11888   rm -rf conftest*
11889   use__logf=yes
11890 else
11891   echo "configure: failed program was:" >&5
11892   cat conftest.$ac_ext >&5
11893   rm -rf conftest*
11894   use__logf=no
11895 fi
11896 rm -f conftest*
11897   echo "$ac_t""$use__logf" 1>&6
11898   ac_ext=c
11899 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11900 ac_cpp='$CPP $CPPFLAGS'
11901 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11902 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11903 cross_compiling=$ac_cv_prog_cc_cross
11904
11905   if test x$use__logf = x"yes"; then
11906     for ac_func in _logf
11907 do
11908 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11909 echo "configure:11910: checking for $ac_func" >&5
11910 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11911   echo $ac_n "(cached) $ac_c" 1>&6
11912 else
11913   cat > conftest.$ac_ext <<EOF
11914 #line 11915 "configure"
11915 #include "confdefs.h"
11916 /* System header to define __stub macros and hopefully few prototypes,
11917     which can conflict with char $ac_func(); below.  */
11918 #include <assert.h>
11919 /* Override any gcc2 internal prototype to avoid an error.  */
11920 /* We use char because int might match the return type of a gcc2
11921     builtin and then its argument prototype would still apply.  */
11922 char $ac_func();
11923
11924 int main() {
11925
11926 /* The GNU C library defines this for functions which it implements
11927     to always fail with ENOSYS.  Some functions are actually named
11928     something starting with __ and the normal name is an alias.  */
11929 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11930 choke me
11931 #else
11932 $ac_func();
11933 #endif
11934
11935 ; return 0; }
11936 EOF
11937 if { (eval echo configure:11938: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11938   rm -rf conftest*
11939   eval "ac_cv_func_$ac_func=yes"
11940 else
11941   echo "configure: failed program was:" >&5
11942   cat conftest.$ac_ext >&5
11943   rm -rf conftest*
11944   eval "ac_cv_func_$ac_func=no"
11945 fi
11946 rm -f conftest*
11947 fi
11948
11949 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11950   echo "$ac_t""yes" 1>&6
11951     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11952   cat >> confdefs.h <<EOF
11953 #define $ac_tr_func 1
11954 EOF
11955
11956 else
11957   echo "$ac_t""no" 1>&6
11958 fi
11959 done
11960
11961   fi
11962
11963
11964
11965   ac_ext=C
11966 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11967 ac_cpp='$CXXCPP $CPPFLAGS'
11968 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11969 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11970 cross_compiling=$ac_cv_prog_cxx_cross
11971
11972   echo $ac_n "checking for _log10f declaration""... $ac_c" 1>&6
11973 echo "configure:11974: checking for _log10f declaration" >&5
11974   cat > conftest.$ac_ext <<EOF
11975 #line 11976 "configure"
11976 #include "confdefs.h"
11977 #include <math.h>
11978 int main() {
11979  _log10f(0);
11980 ; return 0; }
11981 EOF
11982 if { (eval echo configure:11983: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11983   rm -rf conftest*
11984   use__log10f=yes
11985 else
11986   echo "configure: failed program was:" >&5
11987   cat conftest.$ac_ext >&5
11988   rm -rf conftest*
11989   use__log10f=no
11990 fi
11991 rm -f conftest*
11992   echo "$ac_t""$use__log10f" 1>&6
11993   ac_ext=c
11994 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11995 ac_cpp='$CPP $CPPFLAGS'
11996 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11997 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11998 cross_compiling=$ac_cv_prog_cc_cross
11999
12000   if test x$use__log10f = x"yes"; then
12001     for ac_func in _log10f
12002 do
12003 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12004 echo "configure:12005: checking for $ac_func" >&5
12005 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12006   echo $ac_n "(cached) $ac_c" 1>&6
12007 else
12008   cat > conftest.$ac_ext <<EOF
12009 #line 12010 "configure"
12010 #include "confdefs.h"
12011 /* System header to define __stub macros and hopefully few prototypes,
12012     which can conflict with char $ac_func(); below.  */
12013 #include <assert.h>
12014 /* Override any gcc2 internal prototype to avoid an error.  */
12015 /* We use char because int might match the return type of a gcc2
12016     builtin and then its argument prototype would still apply.  */
12017 char $ac_func();
12018
12019 int main() {
12020
12021 /* The GNU C library defines this for functions which it implements
12022     to always fail with ENOSYS.  Some functions are actually named
12023     something starting with __ and the normal name is an alias.  */
12024 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12025 choke me
12026 #else
12027 $ac_func();
12028 #endif
12029
12030 ; return 0; }
12031 EOF
12032 if { (eval echo configure:12033: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12033   rm -rf conftest*
12034   eval "ac_cv_func_$ac_func=yes"
12035 else
12036   echo "configure: failed program was:" >&5
12037   cat conftest.$ac_ext >&5
12038   rm -rf conftest*
12039   eval "ac_cv_func_$ac_func=no"
12040 fi
12041 rm -f conftest*
12042 fi
12043
12044 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12045   echo "$ac_t""yes" 1>&6
12046     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12047   cat >> confdefs.h <<EOF
12048 #define $ac_tr_func 1
12049 EOF
12050
12051 else
12052   echo "$ac_t""no" 1>&6
12053 fi
12054 done
12055
12056   fi
12057
12058
12059
12060   ac_ext=C
12061 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12062 ac_cpp='$CXXCPP $CPPFLAGS'
12063 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12064 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12065 cross_compiling=$ac_cv_prog_cxx_cross
12066
12067   echo $ac_n "checking for _modff declaration""... $ac_c" 1>&6
12068 echo "configure:12069: checking for _modff declaration" >&5
12069   cat > conftest.$ac_ext <<EOF
12070 #line 12071 "configure"
12071 #include "confdefs.h"
12072 #include <math.h>
12073 int main() {
12074  _modff(0, 0);
12075 ; return 0; }
12076 EOF
12077 if { (eval echo configure:12078: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12078   rm -rf conftest*
12079   use__modff=yes
12080 else
12081   echo "configure: failed program was:" >&5
12082   cat conftest.$ac_ext >&5
12083   rm -rf conftest*
12084   use__modff=no
12085 fi
12086 rm -f conftest*
12087   echo "$ac_t""$use__modff" 1>&6
12088   ac_ext=c
12089 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12090 ac_cpp='$CPP $CPPFLAGS'
12091 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12092 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12093 cross_compiling=$ac_cv_prog_cc_cross
12094
12095   if test x$use__modff = x"yes"; then
12096     for ac_func in _modff
12097 do
12098 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12099 echo "configure:12100: checking for $ac_func" >&5
12100 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12101   echo $ac_n "(cached) $ac_c" 1>&6
12102 else
12103   cat > conftest.$ac_ext <<EOF
12104 #line 12105 "configure"
12105 #include "confdefs.h"
12106 /* System header to define __stub macros and hopefully few prototypes,
12107     which can conflict with char $ac_func(); below.  */
12108 #include <assert.h>
12109 /* Override any gcc2 internal prototype to avoid an error.  */
12110 /* We use char because int might match the return type of a gcc2
12111     builtin and then its argument prototype would still apply.  */
12112 char $ac_func();
12113
12114 int main() {
12115
12116 /* The GNU C library defines this for functions which it implements
12117     to always fail with ENOSYS.  Some functions are actually named
12118     something starting with __ and the normal name is an alias.  */
12119 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12120 choke me
12121 #else
12122 $ac_func();
12123 #endif
12124
12125 ; return 0; }
12126 EOF
12127 if { (eval echo configure:12128: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12128   rm -rf conftest*
12129   eval "ac_cv_func_$ac_func=yes"
12130 else
12131   echo "configure: failed program was:" >&5
12132   cat conftest.$ac_ext >&5
12133   rm -rf conftest*
12134   eval "ac_cv_func_$ac_func=no"
12135 fi
12136 rm -f conftest*
12137 fi
12138
12139 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12140   echo "$ac_t""yes" 1>&6
12141     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12142   cat >> confdefs.h <<EOF
12143 #define $ac_tr_func 1
12144 EOF
12145
12146 else
12147   echo "$ac_t""no" 1>&6
12148 fi
12149 done
12150
12151   fi
12152
12153
12154
12155   ac_ext=C
12156 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12157 ac_cpp='$CXXCPP $CPPFLAGS'
12158 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12159 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12160 cross_compiling=$ac_cv_prog_cxx_cross
12161
12162   echo $ac_n "checking for _powf declaration""... $ac_c" 1>&6
12163 echo "configure:12164: checking for _powf declaration" >&5
12164   cat > conftest.$ac_ext <<EOF
12165 #line 12166 "configure"
12166 #include "confdefs.h"
12167 #include <math.h>
12168 int main() {
12169  _powf(0, 0);
12170 ; return 0; }
12171 EOF
12172 if { (eval echo configure:12173: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12173   rm -rf conftest*
12174   use__powf=yes
12175 else
12176   echo "configure: failed program was:" >&5
12177   cat conftest.$ac_ext >&5
12178   rm -rf conftest*
12179   use__powf=no
12180 fi
12181 rm -f conftest*
12182   echo "$ac_t""$use__powf" 1>&6
12183   ac_ext=c
12184 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12185 ac_cpp='$CPP $CPPFLAGS'
12186 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12187 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12188 cross_compiling=$ac_cv_prog_cc_cross
12189
12190   if test x$use__powf = x"yes"; then
12191     for ac_func in _powf
12192 do
12193 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12194 echo "configure:12195: checking for $ac_func" >&5
12195 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12196   echo $ac_n "(cached) $ac_c" 1>&6
12197 else
12198   cat > conftest.$ac_ext <<EOF
12199 #line 12200 "configure"
12200 #include "confdefs.h"
12201 /* System header to define __stub macros and hopefully few prototypes,
12202     which can conflict with char $ac_func(); below.  */
12203 #include <assert.h>
12204 /* Override any gcc2 internal prototype to avoid an error.  */
12205 /* We use char because int might match the return type of a gcc2
12206     builtin and then its argument prototype would still apply.  */
12207 char $ac_func();
12208
12209 int main() {
12210
12211 /* The GNU C library defines this for functions which it implements
12212     to always fail with ENOSYS.  Some functions are actually named
12213     something starting with __ and the normal name is an alias.  */
12214 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12215 choke me
12216 #else
12217 $ac_func();
12218 #endif
12219
12220 ; return 0; }
12221 EOF
12222 if { (eval echo configure:12223: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12223   rm -rf conftest*
12224   eval "ac_cv_func_$ac_func=yes"
12225 else
12226   echo "configure: failed program was:" >&5
12227   cat conftest.$ac_ext >&5
12228   rm -rf conftest*
12229   eval "ac_cv_func_$ac_func=no"
12230 fi
12231 rm -f conftest*
12232 fi
12233
12234 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12235   echo "$ac_t""yes" 1>&6
12236     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12237   cat >> confdefs.h <<EOF
12238 #define $ac_tr_func 1
12239 EOF
12240
12241 else
12242   echo "$ac_t""no" 1>&6
12243 fi
12244 done
12245
12246   fi
12247
12248
12249
12250   ac_ext=C
12251 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12252 ac_cpp='$CXXCPP $CPPFLAGS'
12253 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12254 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12255 cross_compiling=$ac_cv_prog_cxx_cross
12256
12257   echo $ac_n "checking for _sinf declaration""... $ac_c" 1>&6
12258 echo "configure:12259: checking for _sinf declaration" >&5
12259   cat > conftest.$ac_ext <<EOF
12260 #line 12261 "configure"
12261 #include "confdefs.h"
12262 #include <math.h>
12263 int main() {
12264  _sinf(0);
12265 ; return 0; }
12266 EOF
12267 if { (eval echo configure:12268: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12268   rm -rf conftest*
12269   use__sinf=yes
12270 else
12271   echo "configure: failed program was:" >&5
12272   cat conftest.$ac_ext >&5
12273   rm -rf conftest*
12274   use__sinf=no
12275 fi
12276 rm -f conftest*
12277   echo "$ac_t""$use__sinf" 1>&6
12278   ac_ext=c
12279 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12280 ac_cpp='$CPP $CPPFLAGS'
12281 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12282 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12283 cross_compiling=$ac_cv_prog_cc_cross
12284
12285   if test x$use__sinf = x"yes"; then
12286     for ac_func in _sinf
12287 do
12288 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12289 echo "configure:12290: checking for $ac_func" >&5
12290 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12291   echo $ac_n "(cached) $ac_c" 1>&6
12292 else
12293   cat > conftest.$ac_ext <<EOF
12294 #line 12295 "configure"
12295 #include "confdefs.h"
12296 /* System header to define __stub macros and hopefully few prototypes,
12297     which can conflict with char $ac_func(); below.  */
12298 #include <assert.h>
12299 /* Override any gcc2 internal prototype to avoid an error.  */
12300 /* We use char because int might match the return type of a gcc2
12301     builtin and then its argument prototype would still apply.  */
12302 char $ac_func();
12303
12304 int main() {
12305
12306 /* The GNU C library defines this for functions which it implements
12307     to always fail with ENOSYS.  Some functions are actually named
12308     something starting with __ and the normal name is an alias.  */
12309 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12310 choke me
12311 #else
12312 $ac_func();
12313 #endif
12314
12315 ; return 0; }
12316 EOF
12317 if { (eval echo configure:12318: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12318   rm -rf conftest*
12319   eval "ac_cv_func_$ac_func=yes"
12320 else
12321   echo "configure: failed program was:" >&5
12322   cat conftest.$ac_ext >&5
12323   rm -rf conftest*
12324   eval "ac_cv_func_$ac_func=no"
12325 fi
12326 rm -f conftest*
12327 fi
12328
12329 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12330   echo "$ac_t""yes" 1>&6
12331     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12332   cat >> confdefs.h <<EOF
12333 #define $ac_tr_func 1
12334 EOF
12335
12336 else
12337   echo "$ac_t""no" 1>&6
12338 fi
12339 done
12340
12341   fi
12342
12343
12344
12345   ac_ext=C
12346 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12347 ac_cpp='$CXXCPP $CPPFLAGS'
12348 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12349 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12350 cross_compiling=$ac_cv_prog_cxx_cross
12351
12352   echo $ac_n "checking for _sinhf declaration""... $ac_c" 1>&6
12353 echo "configure:12354: checking for _sinhf declaration" >&5
12354   cat > conftest.$ac_ext <<EOF
12355 #line 12356 "configure"
12356 #include "confdefs.h"
12357 #include <math.h>
12358 int main() {
12359  _sinhf(0);
12360 ; return 0; }
12361 EOF
12362 if { (eval echo configure:12363: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12363   rm -rf conftest*
12364   use__sinhf=yes
12365 else
12366   echo "configure: failed program was:" >&5
12367   cat conftest.$ac_ext >&5
12368   rm -rf conftest*
12369   use__sinhf=no
12370 fi
12371 rm -f conftest*
12372   echo "$ac_t""$use__sinhf" 1>&6
12373   ac_ext=c
12374 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12375 ac_cpp='$CPP $CPPFLAGS'
12376 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12377 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12378 cross_compiling=$ac_cv_prog_cc_cross
12379
12380   if test x$use__sinhf = x"yes"; then
12381     for ac_func in _sinhf
12382 do
12383 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12384 echo "configure:12385: checking for $ac_func" >&5
12385 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12386   echo $ac_n "(cached) $ac_c" 1>&6
12387 else
12388   cat > conftest.$ac_ext <<EOF
12389 #line 12390 "configure"
12390 #include "confdefs.h"
12391 /* System header to define __stub macros and hopefully few prototypes,
12392     which can conflict with char $ac_func(); below.  */
12393 #include <assert.h>
12394 /* Override any gcc2 internal prototype to avoid an error.  */
12395 /* We use char because int might match the return type of a gcc2
12396     builtin and then its argument prototype would still apply.  */
12397 char $ac_func();
12398
12399 int main() {
12400
12401 /* The GNU C library defines this for functions which it implements
12402     to always fail with ENOSYS.  Some functions are actually named
12403     something starting with __ and the normal name is an alias.  */
12404 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12405 choke me
12406 #else
12407 $ac_func();
12408 #endif
12409
12410 ; return 0; }
12411 EOF
12412 if { (eval echo configure:12413: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12413   rm -rf conftest*
12414   eval "ac_cv_func_$ac_func=yes"
12415 else
12416   echo "configure: failed program was:" >&5
12417   cat conftest.$ac_ext >&5
12418   rm -rf conftest*
12419   eval "ac_cv_func_$ac_func=no"
12420 fi
12421 rm -f conftest*
12422 fi
12423
12424 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12425   echo "$ac_t""yes" 1>&6
12426     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12427   cat >> confdefs.h <<EOF
12428 #define $ac_tr_func 1
12429 EOF
12430
12431 else
12432   echo "$ac_t""no" 1>&6
12433 fi
12434 done
12435
12436   fi
12437
12438
12439
12440   ac_ext=C
12441 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12442 ac_cpp='$CXXCPP $CPPFLAGS'
12443 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12444 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12445 cross_compiling=$ac_cv_prog_cxx_cross
12446
12447   echo $ac_n "checking for _sqrtf declaration""... $ac_c" 1>&6
12448 echo "configure:12449: checking for _sqrtf declaration" >&5
12449   cat > conftest.$ac_ext <<EOF
12450 #line 12451 "configure"
12451 #include "confdefs.h"
12452 #include <math.h>
12453 int main() {
12454  _sqrtf(0);
12455 ; return 0; }
12456 EOF
12457 if { (eval echo configure:12458: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12458   rm -rf conftest*
12459   use__sqrtf=yes
12460 else
12461   echo "configure: failed program was:" >&5
12462   cat conftest.$ac_ext >&5
12463   rm -rf conftest*
12464   use__sqrtf=no
12465 fi
12466 rm -f conftest*
12467   echo "$ac_t""$use__sqrtf" 1>&6
12468   ac_ext=c
12469 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12470 ac_cpp='$CPP $CPPFLAGS'
12471 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12472 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12473 cross_compiling=$ac_cv_prog_cc_cross
12474
12475   if test x$use__sqrtf = x"yes"; then
12476     for ac_func in _sqrtf
12477 do
12478 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12479 echo "configure:12480: checking for $ac_func" >&5
12480 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12481   echo $ac_n "(cached) $ac_c" 1>&6
12482 else
12483   cat > conftest.$ac_ext <<EOF
12484 #line 12485 "configure"
12485 #include "confdefs.h"
12486 /* System header to define __stub macros and hopefully few prototypes,
12487     which can conflict with char $ac_func(); below.  */
12488 #include <assert.h>
12489 /* Override any gcc2 internal prototype to avoid an error.  */
12490 /* We use char because int might match the return type of a gcc2
12491     builtin and then its argument prototype would still apply.  */
12492 char $ac_func();
12493
12494 int main() {
12495
12496 /* The GNU C library defines this for functions which it implements
12497     to always fail with ENOSYS.  Some functions are actually named
12498     something starting with __ and the normal name is an alias.  */
12499 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12500 choke me
12501 #else
12502 $ac_func();
12503 #endif
12504
12505 ; return 0; }
12506 EOF
12507 if { (eval echo configure:12508: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12508   rm -rf conftest*
12509   eval "ac_cv_func_$ac_func=yes"
12510 else
12511   echo "configure: failed program was:" >&5
12512   cat conftest.$ac_ext >&5
12513   rm -rf conftest*
12514   eval "ac_cv_func_$ac_func=no"
12515 fi
12516 rm -f conftest*
12517 fi
12518
12519 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12520   echo "$ac_t""yes" 1>&6
12521     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12522   cat >> confdefs.h <<EOF
12523 #define $ac_tr_func 1
12524 EOF
12525
12526 else
12527   echo "$ac_t""no" 1>&6
12528 fi
12529 done
12530
12531   fi
12532
12533
12534
12535   ac_ext=C
12536 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12537 ac_cpp='$CXXCPP $CPPFLAGS'
12538 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12539 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12540 cross_compiling=$ac_cv_prog_cxx_cross
12541
12542   echo $ac_n "checking for _tanf declaration""... $ac_c" 1>&6
12543 echo "configure:12544: checking for _tanf declaration" >&5
12544   cat > conftest.$ac_ext <<EOF
12545 #line 12546 "configure"
12546 #include "confdefs.h"
12547 #include <math.h>
12548 int main() {
12549  _tanf(0);
12550 ; return 0; }
12551 EOF
12552 if { (eval echo configure:12553: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12553   rm -rf conftest*
12554   use__tanf=yes
12555 else
12556   echo "configure: failed program was:" >&5
12557   cat conftest.$ac_ext >&5
12558   rm -rf conftest*
12559   use__tanf=no
12560 fi
12561 rm -f conftest*
12562   echo "$ac_t""$use__tanf" 1>&6
12563   ac_ext=c
12564 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12565 ac_cpp='$CPP $CPPFLAGS'
12566 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12567 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12568 cross_compiling=$ac_cv_prog_cc_cross
12569
12570   if test x$use__tanf = x"yes"; then
12571     for ac_func in _tanf
12572 do
12573 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12574 echo "configure:12575: checking for $ac_func" >&5
12575 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12576   echo $ac_n "(cached) $ac_c" 1>&6
12577 else
12578   cat > conftest.$ac_ext <<EOF
12579 #line 12580 "configure"
12580 #include "confdefs.h"
12581 /* System header to define __stub macros and hopefully few prototypes,
12582     which can conflict with char $ac_func(); below.  */
12583 #include <assert.h>
12584 /* Override any gcc2 internal prototype to avoid an error.  */
12585 /* We use char because int might match the return type of a gcc2
12586     builtin and then its argument prototype would still apply.  */
12587 char $ac_func();
12588
12589 int main() {
12590
12591 /* The GNU C library defines this for functions which it implements
12592     to always fail with ENOSYS.  Some functions are actually named
12593     something starting with __ and the normal name is an alias.  */
12594 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12595 choke me
12596 #else
12597 $ac_func();
12598 #endif
12599
12600 ; return 0; }
12601 EOF
12602 if { (eval echo configure:12603: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12603   rm -rf conftest*
12604   eval "ac_cv_func_$ac_func=yes"
12605 else
12606   echo "configure: failed program was:" >&5
12607   cat conftest.$ac_ext >&5
12608   rm -rf conftest*
12609   eval "ac_cv_func_$ac_func=no"
12610 fi
12611 rm -f conftest*
12612 fi
12613
12614 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12615   echo "$ac_t""yes" 1>&6
12616     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12617   cat >> confdefs.h <<EOF
12618 #define $ac_tr_func 1
12619 EOF
12620
12621 else
12622   echo "$ac_t""no" 1>&6
12623 fi
12624 done
12625
12626   fi
12627
12628
12629
12630   ac_ext=C
12631 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12632 ac_cpp='$CXXCPP $CPPFLAGS'
12633 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12634 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12635 cross_compiling=$ac_cv_prog_cxx_cross
12636
12637   echo $ac_n "checking for _tanhf declaration""... $ac_c" 1>&6
12638 echo "configure:12639: checking for _tanhf declaration" >&5
12639   cat > conftest.$ac_ext <<EOF
12640 #line 12641 "configure"
12641 #include "confdefs.h"
12642 #include <math.h>
12643 int main() {
12644  _tanhf(0);
12645 ; return 0; }
12646 EOF
12647 if { (eval echo configure:12648: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12648   rm -rf conftest*
12649   use__tanhf=yes
12650 else
12651   echo "configure: failed program was:" >&5
12652   cat conftest.$ac_ext >&5
12653   rm -rf conftest*
12654   use__tanhf=no
12655 fi
12656 rm -f conftest*
12657   echo "$ac_t""$use__tanhf" 1>&6
12658   ac_ext=c
12659 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12660 ac_cpp='$CPP $CPPFLAGS'
12661 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12662 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12663 cross_compiling=$ac_cv_prog_cc_cross
12664
12665   if test x$use__tanhf = x"yes"; then
12666     for ac_func in _tanhf
12667 do
12668 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12669 echo "configure:12670: checking for $ac_func" >&5
12670 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12671   echo $ac_n "(cached) $ac_c" 1>&6
12672 else
12673   cat > conftest.$ac_ext <<EOF
12674 #line 12675 "configure"
12675 #include "confdefs.h"
12676 /* System header to define __stub macros and hopefully few prototypes,
12677     which can conflict with char $ac_func(); below.  */
12678 #include <assert.h>
12679 /* Override any gcc2 internal prototype to avoid an error.  */
12680 /* We use char because int might match the return type of a gcc2
12681     builtin and then its argument prototype would still apply.  */
12682 char $ac_func();
12683
12684 int main() {
12685
12686 /* The GNU C library defines this for functions which it implements
12687     to always fail with ENOSYS.  Some functions are actually named
12688     something starting with __ and the normal name is an alias.  */
12689 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12690 choke me
12691 #else
12692 $ac_func();
12693 #endif
12694
12695 ; return 0; }
12696 EOF
12697 if { (eval echo configure:12698: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12698   rm -rf conftest*
12699   eval "ac_cv_func_$ac_func=yes"
12700 else
12701   echo "configure: failed program was:" >&5
12702   cat conftest.$ac_ext >&5
12703   rm -rf conftest*
12704   eval "ac_cv_func_$ac_func=no"
12705 fi
12706 rm -f conftest*
12707 fi
12708
12709 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12710   echo "$ac_t""yes" 1>&6
12711     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12712   cat >> confdefs.h <<EOF
12713 #define $ac_tr_func 1
12714 EOF
12715
12716 else
12717   echo "$ac_t""no" 1>&6
12718 fi
12719 done
12720
12721   fi
12722
12723
12724
12725   ac_ext=C
12726 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12727 ac_cpp='$CXXCPP $CPPFLAGS'
12728 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12729 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12730 cross_compiling=$ac_cv_prog_cxx_cross
12731
12732   echo $ac_n "checking for _sincosf declaration""... $ac_c" 1>&6
12733 echo "configure:12734: checking for _sincosf declaration" >&5
12734   cat > conftest.$ac_ext <<EOF
12735 #line 12736 "configure"
12736 #include "confdefs.h"
12737 #include <math.h>
12738 int main() {
12739  _sincosf(0, 0, 0);
12740 ; return 0; }
12741 EOF
12742 if { (eval echo configure:12743: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12743   rm -rf conftest*
12744   use__sincosf=yes
12745 else
12746   echo "configure: failed program was:" >&5
12747   cat conftest.$ac_ext >&5
12748   rm -rf conftest*
12749   use__sincosf=no
12750 fi
12751 rm -f conftest*
12752   echo "$ac_t""$use__sincosf" 1>&6
12753   ac_ext=c
12754 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12755 ac_cpp='$CPP $CPPFLAGS'
12756 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12757 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12758 cross_compiling=$ac_cv_prog_cc_cross
12759
12760   if test x$use__sincosf = x"yes"; then
12761     for ac_func in _sincosf
12762 do
12763 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12764 echo "configure:12765: checking for $ac_func" >&5
12765 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12766   echo $ac_n "(cached) $ac_c" 1>&6
12767 else
12768   cat > conftest.$ac_ext <<EOF
12769 #line 12770 "configure"
12770 #include "confdefs.h"
12771 /* System header to define __stub macros and hopefully few prototypes,
12772     which can conflict with char $ac_func(); below.  */
12773 #include <assert.h>
12774 /* Override any gcc2 internal prototype to avoid an error.  */
12775 /* We use char because int might match the return type of a gcc2
12776     builtin and then its argument prototype would still apply.  */
12777 char $ac_func();
12778
12779 int main() {
12780
12781 /* The GNU C library defines this for functions which it implements
12782     to always fail with ENOSYS.  Some functions are actually named
12783     something starting with __ and the normal name is an alias.  */
12784 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12785 choke me
12786 #else
12787 $ac_func();
12788 #endif
12789
12790 ; return 0; }
12791 EOF
12792 if { (eval echo configure:12793: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12793   rm -rf conftest*
12794   eval "ac_cv_func_$ac_func=yes"
12795 else
12796   echo "configure: failed program was:" >&5
12797   cat conftest.$ac_ext >&5
12798   rm -rf conftest*
12799   eval "ac_cv_func_$ac_func=no"
12800 fi
12801 rm -f conftest*
12802 fi
12803
12804 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12805   echo "$ac_t""yes" 1>&6
12806     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12807   cat >> confdefs.h <<EOF
12808 #define $ac_tr_func 1
12809 EOF
12810
12811 else
12812   echo "$ac_t""no" 1>&6
12813 fi
12814 done
12815
12816   fi
12817
12818
12819
12820   ac_ext=C
12821 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12822 ac_cpp='$CXXCPP $CPPFLAGS'
12823 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12824 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12825 cross_compiling=$ac_cv_prog_cxx_cross
12826
12827   echo $ac_n "checking for _finitef declaration""... $ac_c" 1>&6
12828 echo "configure:12829: checking for _finitef declaration" >&5
12829   cat > conftest.$ac_ext <<EOF
12830 #line 12831 "configure"
12831 #include "confdefs.h"
12832 #include <math.h>
12833 int main() {
12834  _finitef(0);
12835 ; return 0; }
12836 EOF
12837 if { (eval echo configure:12838: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12838   rm -rf conftest*
12839   use__finitef=yes
12840 else
12841   echo "configure: failed program was:" >&5
12842   cat conftest.$ac_ext >&5
12843   rm -rf conftest*
12844   use__finitef=no
12845 fi
12846 rm -f conftest*
12847   echo "$ac_t""$use__finitef" 1>&6
12848   ac_ext=c
12849 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12850 ac_cpp='$CPP $CPPFLAGS'
12851 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12852 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12853 cross_compiling=$ac_cv_prog_cc_cross
12854
12855   if test x$use__finitef = x"yes"; then
12856     for ac_func in _finitef
12857 do
12858 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12859 echo "configure:12860: checking for $ac_func" >&5
12860 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12861   echo $ac_n "(cached) $ac_c" 1>&6
12862 else
12863   cat > conftest.$ac_ext <<EOF
12864 #line 12865 "configure"
12865 #include "confdefs.h"
12866 /* System header to define __stub macros and hopefully few prototypes,
12867     which can conflict with char $ac_func(); below.  */
12868 #include <assert.h>
12869 /* Override any gcc2 internal prototype to avoid an error.  */
12870 /* We use char because int might match the return type of a gcc2
12871     builtin and then its argument prototype would still apply.  */
12872 char $ac_func();
12873
12874 int main() {
12875
12876 /* The GNU C library defines this for functions which it implements
12877     to always fail with ENOSYS.  Some functions are actually named
12878     something starting with __ and the normal name is an alias.  */
12879 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12880 choke me
12881 #else
12882 $ac_func();
12883 #endif
12884
12885 ; return 0; }
12886 EOF
12887 if { (eval echo configure:12888: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12888   rm -rf conftest*
12889   eval "ac_cv_func_$ac_func=yes"
12890 else
12891   echo "configure: failed program was:" >&5
12892   cat conftest.$ac_ext >&5
12893   rm -rf conftest*
12894   eval "ac_cv_func_$ac_func=no"
12895 fi
12896 rm -f conftest*
12897 fi
12898
12899 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12900   echo "$ac_t""yes" 1>&6
12901     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12902   cat >> confdefs.h <<EOF
12903 #define $ac_tr_func 1
12904 EOF
12905
12906 else
12907   echo "$ac_t""no" 1>&6
12908 fi
12909 done
12910
12911   fi
12912
12913
12914
12915
12916   ac_ext=C
12917 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12918 ac_cpp='$CXXCPP $CPPFLAGS'
12919 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12920 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12921 cross_compiling=$ac_cv_prog_cxx_cross
12922
12923   echo $ac_n "checking for _isnanl declaration""... $ac_c" 1>&6
12924 echo "configure:12925: checking for _isnanl declaration" >&5
12925   cat > conftest.$ac_ext <<EOF
12926 #line 12927 "configure"
12927 #include "confdefs.h"
12928 #include <math.h>
12929 int main() {
12930  _isnanl(0);
12931 ; return 0; }
12932 EOF
12933 if { (eval echo configure:12934: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12934   rm -rf conftest*
12935   use__isnanl=yes
12936 else
12937   echo "configure: failed program was:" >&5
12938   cat conftest.$ac_ext >&5
12939   rm -rf conftest*
12940   use__isnanl=no
12941 fi
12942 rm -f conftest*
12943   echo "$ac_t""$use__isnanl" 1>&6
12944   ac_ext=c
12945 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12946 ac_cpp='$CPP $CPPFLAGS'
12947 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12948 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12949 cross_compiling=$ac_cv_prog_cc_cross
12950
12951   if test x$use__isnanl = x"yes"; then
12952     for ac_func in _isnanl
12953 do
12954 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12955 echo "configure:12956: checking for $ac_func" >&5
12956 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12957   echo $ac_n "(cached) $ac_c" 1>&6
12958 else
12959   cat > conftest.$ac_ext <<EOF
12960 #line 12961 "configure"
12961 #include "confdefs.h"
12962 /* System header to define __stub macros and hopefully few prototypes,
12963     which can conflict with char $ac_func(); below.  */
12964 #include <assert.h>
12965 /* Override any gcc2 internal prototype to avoid an error.  */
12966 /* We use char because int might match the return type of a gcc2
12967     builtin and then its argument prototype would still apply.  */
12968 char $ac_func();
12969
12970 int main() {
12971
12972 /* The GNU C library defines this for functions which it implements
12973     to always fail with ENOSYS.  Some functions are actually named
12974     something starting with __ and the normal name is an alias.  */
12975 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12976 choke me
12977 #else
12978 $ac_func();
12979 #endif
12980
12981 ; return 0; }
12982 EOF
12983 if { (eval echo configure:12984: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12984   rm -rf conftest*
12985   eval "ac_cv_func_$ac_func=yes"
12986 else
12987   echo "configure: failed program was:" >&5
12988   cat conftest.$ac_ext >&5
12989   rm -rf conftest*
12990   eval "ac_cv_func_$ac_func=no"
12991 fi
12992 rm -f conftest*
12993 fi
12994
12995 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12996   echo "$ac_t""yes" 1>&6
12997     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12998   cat >> confdefs.h <<EOF
12999 #define $ac_tr_func 1
13000 EOF
13001
13002 else
13003   echo "$ac_t""no" 1>&6
13004 fi
13005 done
13006
13007   fi
13008
13009
13010
13011   ac_ext=C
13012 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13013 ac_cpp='$CXXCPP $CPPFLAGS'
13014 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13015 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13016 cross_compiling=$ac_cv_prog_cxx_cross
13017
13018   echo $ac_n "checking for _isinfl declaration""... $ac_c" 1>&6
13019 echo "configure:13020: checking for _isinfl declaration" >&5
13020   cat > conftest.$ac_ext <<EOF
13021 #line 13022 "configure"
13022 #include "confdefs.h"
13023 #include <math.h>
13024 int main() {
13025  _isinfl(0);
13026 ; return 0; }
13027 EOF
13028 if { (eval echo configure:13029: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13029   rm -rf conftest*
13030   use__isinfl=yes
13031 else
13032   echo "configure: failed program was:" >&5
13033   cat conftest.$ac_ext >&5
13034   rm -rf conftest*
13035   use__isinfl=no
13036 fi
13037 rm -f conftest*
13038   echo "$ac_t""$use__isinfl" 1>&6
13039   ac_ext=c
13040 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13041 ac_cpp='$CPP $CPPFLAGS'
13042 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13043 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13044 cross_compiling=$ac_cv_prog_cc_cross
13045
13046   if test x$use__isinfl = x"yes"; then
13047     for ac_func in _isinfl
13048 do
13049 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13050 echo "configure:13051: checking for $ac_func" >&5
13051 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13052   echo $ac_n "(cached) $ac_c" 1>&6
13053 else
13054   cat > conftest.$ac_ext <<EOF
13055 #line 13056 "configure"
13056 #include "confdefs.h"
13057 /* System header to define __stub macros and hopefully few prototypes,
13058     which can conflict with char $ac_func(); below.  */
13059 #include <assert.h>
13060 /* Override any gcc2 internal prototype to avoid an error.  */
13061 /* We use char because int might match the return type of a gcc2
13062     builtin and then its argument prototype would still apply.  */
13063 char $ac_func();
13064
13065 int main() {
13066
13067 /* The GNU C library defines this for functions which it implements
13068     to always fail with ENOSYS.  Some functions are actually named
13069     something starting with __ and the normal name is an alias.  */
13070 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13071 choke me
13072 #else
13073 $ac_func();
13074 #endif
13075
13076 ; return 0; }
13077 EOF
13078 if { (eval echo configure:13079: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13079   rm -rf conftest*
13080   eval "ac_cv_func_$ac_func=yes"
13081 else
13082   echo "configure: failed program was:" >&5
13083   cat conftest.$ac_ext >&5
13084   rm -rf conftest*
13085   eval "ac_cv_func_$ac_func=no"
13086 fi
13087 rm -f conftest*
13088 fi
13089
13090 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13091   echo "$ac_t""yes" 1>&6
13092     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13093   cat >> confdefs.h <<EOF
13094 #define $ac_tr_func 1
13095 EOF
13096
13097 else
13098   echo "$ac_t""no" 1>&6
13099 fi
13100 done
13101
13102   fi
13103
13104
13105
13106   ac_ext=C
13107 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13108 ac_cpp='$CXXCPP $CPPFLAGS'
13109 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13110 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13111 cross_compiling=$ac_cv_prog_cxx_cross
13112
13113   echo $ac_n "checking for _copysignl declaration""... $ac_c" 1>&6
13114 echo "configure:13115: checking for _copysignl declaration" >&5
13115   cat > conftest.$ac_ext <<EOF
13116 #line 13117 "configure"
13117 #include "confdefs.h"
13118 #include <math.h>
13119 int main() {
13120  _copysignl(0, 0);
13121 ; return 0; }
13122 EOF
13123 if { (eval echo configure:13124: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13124   rm -rf conftest*
13125   use__copysignl=yes
13126 else
13127   echo "configure: failed program was:" >&5
13128   cat conftest.$ac_ext >&5
13129   rm -rf conftest*
13130   use__copysignl=no
13131 fi
13132 rm -f conftest*
13133   echo "$ac_t""$use__copysignl" 1>&6
13134   ac_ext=c
13135 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13136 ac_cpp='$CPP $CPPFLAGS'
13137 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13138 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13139 cross_compiling=$ac_cv_prog_cc_cross
13140
13141   if test x$use__copysignl = x"yes"; then
13142     for ac_func in _copysignl
13143 do
13144 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13145 echo "configure:13146: checking for $ac_func" >&5
13146 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13147   echo $ac_n "(cached) $ac_c" 1>&6
13148 else
13149   cat > conftest.$ac_ext <<EOF
13150 #line 13151 "configure"
13151 #include "confdefs.h"
13152 /* System header to define __stub macros and hopefully few prototypes,
13153     which can conflict with char $ac_func(); below.  */
13154 #include <assert.h>
13155 /* Override any gcc2 internal prototype to avoid an error.  */
13156 /* We use char because int might match the return type of a gcc2
13157     builtin and then its argument prototype would still apply.  */
13158 char $ac_func();
13159
13160 int main() {
13161
13162 /* The GNU C library defines this for functions which it implements
13163     to always fail with ENOSYS.  Some functions are actually named
13164     something starting with __ and the normal name is an alias.  */
13165 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13166 choke me
13167 #else
13168 $ac_func();
13169 #endif
13170
13171 ; return 0; }
13172 EOF
13173 if { (eval echo configure:13174: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13174   rm -rf conftest*
13175   eval "ac_cv_func_$ac_func=yes"
13176 else
13177   echo "configure: failed program was:" >&5
13178   cat conftest.$ac_ext >&5
13179   rm -rf conftest*
13180   eval "ac_cv_func_$ac_func=no"
13181 fi
13182 rm -f conftest*
13183 fi
13184
13185 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13186   echo "$ac_t""yes" 1>&6
13187     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13188   cat >> confdefs.h <<EOF
13189 #define $ac_tr_func 1
13190 EOF
13191
13192 else
13193   echo "$ac_t""no" 1>&6
13194 fi
13195 done
13196
13197   fi
13198
13199
13200
13201   ac_ext=C
13202 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13203 ac_cpp='$CXXCPP $CPPFLAGS'
13204 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13205 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13206 cross_compiling=$ac_cv_prog_cxx_cross
13207
13208   echo $ac_n "checking for _acosl declaration""... $ac_c" 1>&6
13209 echo "configure:13210: checking for _acosl declaration" >&5
13210   cat > conftest.$ac_ext <<EOF
13211 #line 13212 "configure"
13212 #include "confdefs.h"
13213 #include <math.h>
13214 int main() {
13215  _acosl(0);
13216 ; return 0; }
13217 EOF
13218 if { (eval echo configure:13219: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13219   rm -rf conftest*
13220   use__acosl=yes
13221 else
13222   echo "configure: failed program was:" >&5
13223   cat conftest.$ac_ext >&5
13224   rm -rf conftest*
13225   use__acosl=no
13226 fi
13227 rm -f conftest*
13228   echo "$ac_t""$use__acosl" 1>&6
13229   ac_ext=c
13230 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13231 ac_cpp='$CPP $CPPFLAGS'
13232 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13233 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13234 cross_compiling=$ac_cv_prog_cc_cross
13235
13236   if test x$use__acosl = x"yes"; then
13237     for ac_func in _acosl
13238 do
13239 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13240 echo "configure:13241: checking for $ac_func" >&5
13241 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13242   echo $ac_n "(cached) $ac_c" 1>&6
13243 else
13244   cat > conftest.$ac_ext <<EOF
13245 #line 13246 "configure"
13246 #include "confdefs.h"
13247 /* System header to define __stub macros and hopefully few prototypes,
13248     which can conflict with char $ac_func(); below.  */
13249 #include <assert.h>
13250 /* Override any gcc2 internal prototype to avoid an error.  */
13251 /* We use char because int might match the return type of a gcc2
13252     builtin and then its argument prototype would still apply.  */
13253 char $ac_func();
13254
13255 int main() {
13256
13257 /* The GNU C library defines this for functions which it implements
13258     to always fail with ENOSYS.  Some functions are actually named
13259     something starting with __ and the normal name is an alias.  */
13260 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13261 choke me
13262 #else
13263 $ac_func();
13264 #endif
13265
13266 ; return 0; }
13267 EOF
13268 if { (eval echo configure:13269: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13269   rm -rf conftest*
13270   eval "ac_cv_func_$ac_func=yes"
13271 else
13272   echo "configure: failed program was:" >&5
13273   cat conftest.$ac_ext >&5
13274   rm -rf conftest*
13275   eval "ac_cv_func_$ac_func=no"
13276 fi
13277 rm -f conftest*
13278 fi
13279
13280 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13281   echo "$ac_t""yes" 1>&6
13282     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13283   cat >> confdefs.h <<EOF
13284 #define $ac_tr_func 1
13285 EOF
13286
13287 else
13288   echo "$ac_t""no" 1>&6
13289 fi
13290 done
13291
13292   fi
13293
13294
13295
13296   ac_ext=C
13297 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13298 ac_cpp='$CXXCPP $CPPFLAGS'
13299 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13300 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13301 cross_compiling=$ac_cv_prog_cxx_cross
13302
13303   echo $ac_n "checking for _asinl declaration""... $ac_c" 1>&6
13304 echo "configure:13305: checking for _asinl declaration" >&5
13305   cat > conftest.$ac_ext <<EOF
13306 #line 13307 "configure"
13307 #include "confdefs.h"
13308 #include <math.h>
13309 int main() {
13310  _asinl(0);
13311 ; return 0; }
13312 EOF
13313 if { (eval echo configure:13314: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13314   rm -rf conftest*
13315   use__asinl=yes
13316 else
13317   echo "configure: failed program was:" >&5
13318   cat conftest.$ac_ext >&5
13319   rm -rf conftest*
13320   use__asinl=no
13321 fi
13322 rm -f conftest*
13323   echo "$ac_t""$use__asinl" 1>&6
13324   ac_ext=c
13325 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13326 ac_cpp='$CPP $CPPFLAGS'
13327 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13328 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13329 cross_compiling=$ac_cv_prog_cc_cross
13330
13331   if test x$use__asinl = x"yes"; then
13332     for ac_func in _asinl
13333 do
13334 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13335 echo "configure:13336: checking for $ac_func" >&5
13336 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13337   echo $ac_n "(cached) $ac_c" 1>&6
13338 else
13339   cat > conftest.$ac_ext <<EOF
13340 #line 13341 "configure"
13341 #include "confdefs.h"
13342 /* System header to define __stub macros and hopefully few prototypes,
13343     which can conflict with char $ac_func(); below.  */
13344 #include <assert.h>
13345 /* Override any gcc2 internal prototype to avoid an error.  */
13346 /* We use char because int might match the return type of a gcc2
13347     builtin and then its argument prototype would still apply.  */
13348 char $ac_func();
13349
13350 int main() {
13351
13352 /* The GNU C library defines this for functions which it implements
13353     to always fail with ENOSYS.  Some functions are actually named
13354     something starting with __ and the normal name is an alias.  */
13355 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13356 choke me
13357 #else
13358 $ac_func();
13359 #endif
13360
13361 ; return 0; }
13362 EOF
13363 if { (eval echo configure:13364: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13364   rm -rf conftest*
13365   eval "ac_cv_func_$ac_func=yes"
13366 else
13367   echo "configure: failed program was:" >&5
13368   cat conftest.$ac_ext >&5
13369   rm -rf conftest*
13370   eval "ac_cv_func_$ac_func=no"
13371 fi
13372 rm -f conftest*
13373 fi
13374
13375 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13376   echo "$ac_t""yes" 1>&6
13377     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13378   cat >> confdefs.h <<EOF
13379 #define $ac_tr_func 1
13380 EOF
13381
13382 else
13383   echo "$ac_t""no" 1>&6
13384 fi
13385 done
13386
13387   fi
13388
13389
13390
13391   ac_ext=C
13392 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13393 ac_cpp='$CXXCPP $CPPFLAGS'
13394 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13395 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13396 cross_compiling=$ac_cv_prog_cxx_cross
13397
13398   echo $ac_n "checking for _atanl declaration""... $ac_c" 1>&6
13399 echo "configure:13400: checking for _atanl declaration" >&5
13400   cat > conftest.$ac_ext <<EOF
13401 #line 13402 "configure"
13402 #include "confdefs.h"
13403 #include <math.h>
13404 int main() {
13405  _atanl(0);
13406 ; return 0; }
13407 EOF
13408 if { (eval echo configure:13409: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13409   rm -rf conftest*
13410   use__atanl=yes
13411 else
13412   echo "configure: failed program was:" >&5
13413   cat conftest.$ac_ext >&5
13414   rm -rf conftest*
13415   use__atanl=no
13416 fi
13417 rm -f conftest*
13418   echo "$ac_t""$use__atanl" 1>&6
13419   ac_ext=c
13420 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13421 ac_cpp='$CPP $CPPFLAGS'
13422 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13423 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13424 cross_compiling=$ac_cv_prog_cc_cross
13425
13426   if test x$use__atanl = x"yes"; then
13427     for ac_func in _atanl
13428 do
13429 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13430 echo "configure:13431: checking for $ac_func" >&5
13431 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13432   echo $ac_n "(cached) $ac_c" 1>&6
13433 else
13434   cat > conftest.$ac_ext <<EOF
13435 #line 13436 "configure"
13436 #include "confdefs.h"
13437 /* System header to define __stub macros and hopefully few prototypes,
13438     which can conflict with char $ac_func(); below.  */
13439 #include <assert.h>
13440 /* Override any gcc2 internal prototype to avoid an error.  */
13441 /* We use char because int might match the return type of a gcc2
13442     builtin and then its argument prototype would still apply.  */
13443 char $ac_func();
13444
13445 int main() {
13446
13447 /* The GNU C library defines this for functions which it implements
13448     to always fail with ENOSYS.  Some functions are actually named
13449     something starting with __ and the normal name is an alias.  */
13450 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13451 choke me
13452 #else
13453 $ac_func();
13454 #endif
13455
13456 ; return 0; }
13457 EOF
13458 if { (eval echo configure:13459: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13459   rm -rf conftest*
13460   eval "ac_cv_func_$ac_func=yes"
13461 else
13462   echo "configure: failed program was:" >&5
13463   cat conftest.$ac_ext >&5
13464   rm -rf conftest*
13465   eval "ac_cv_func_$ac_func=no"
13466 fi
13467 rm -f conftest*
13468 fi
13469
13470 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13471   echo "$ac_t""yes" 1>&6
13472     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13473   cat >> confdefs.h <<EOF
13474 #define $ac_tr_func 1
13475 EOF
13476
13477 else
13478   echo "$ac_t""no" 1>&6
13479 fi
13480 done
13481
13482   fi
13483
13484
13485
13486   ac_ext=C
13487 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13488 ac_cpp='$CXXCPP $CPPFLAGS'
13489 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13490 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13491 cross_compiling=$ac_cv_prog_cxx_cross
13492
13493   echo $ac_n "checking for _atan2l declaration""... $ac_c" 1>&6
13494 echo "configure:13495: checking for _atan2l declaration" >&5
13495   cat > conftest.$ac_ext <<EOF
13496 #line 13497 "configure"
13497 #include "confdefs.h"
13498 #include <math.h>
13499 int main() {
13500  _atan2l(0, 0);
13501 ; return 0; }
13502 EOF
13503 if { (eval echo configure:13504: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13504   rm -rf conftest*
13505   use__atan2l=yes
13506 else
13507   echo "configure: failed program was:" >&5
13508   cat conftest.$ac_ext >&5
13509   rm -rf conftest*
13510   use__atan2l=no
13511 fi
13512 rm -f conftest*
13513   echo "$ac_t""$use__atan2l" 1>&6
13514   ac_ext=c
13515 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13516 ac_cpp='$CPP $CPPFLAGS'
13517 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13518 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13519 cross_compiling=$ac_cv_prog_cc_cross
13520
13521   if test x$use__atan2l = x"yes"; then
13522     for ac_func in _atan2l
13523 do
13524 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13525 echo "configure:13526: checking for $ac_func" >&5
13526 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13527   echo $ac_n "(cached) $ac_c" 1>&6
13528 else
13529   cat > conftest.$ac_ext <<EOF
13530 #line 13531 "configure"
13531 #include "confdefs.h"
13532 /* System header to define __stub macros and hopefully few prototypes,
13533     which can conflict with char $ac_func(); below.  */
13534 #include <assert.h>
13535 /* Override any gcc2 internal prototype to avoid an error.  */
13536 /* We use char because int might match the return type of a gcc2
13537     builtin and then its argument prototype would still apply.  */
13538 char $ac_func();
13539
13540 int main() {
13541
13542 /* The GNU C library defines this for functions which it implements
13543     to always fail with ENOSYS.  Some functions are actually named
13544     something starting with __ and the normal name is an alias.  */
13545 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13546 choke me
13547 #else
13548 $ac_func();
13549 #endif
13550
13551 ; return 0; }
13552 EOF
13553 if { (eval echo configure:13554: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13554   rm -rf conftest*
13555   eval "ac_cv_func_$ac_func=yes"
13556 else
13557   echo "configure: failed program was:" >&5
13558   cat conftest.$ac_ext >&5
13559   rm -rf conftest*
13560   eval "ac_cv_func_$ac_func=no"
13561 fi
13562 rm -f conftest*
13563 fi
13564
13565 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13566   echo "$ac_t""yes" 1>&6
13567     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13568   cat >> confdefs.h <<EOF
13569 #define $ac_tr_func 1
13570 EOF
13571
13572 else
13573   echo "$ac_t""no" 1>&6
13574 fi
13575 done
13576
13577   fi
13578
13579
13580
13581   ac_ext=C
13582 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13583 ac_cpp='$CXXCPP $CPPFLAGS'
13584 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13585 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13586 cross_compiling=$ac_cv_prog_cxx_cross
13587
13588   echo $ac_n "checking for _ceill declaration""... $ac_c" 1>&6
13589 echo "configure:13590: checking for _ceill declaration" >&5
13590   cat > conftest.$ac_ext <<EOF
13591 #line 13592 "configure"
13592 #include "confdefs.h"
13593 #include <math.h>
13594 int main() {
13595  _ceill(0);
13596 ; return 0; }
13597 EOF
13598 if { (eval echo configure:13599: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13599   rm -rf conftest*
13600   use__ceill=yes
13601 else
13602   echo "configure: failed program was:" >&5
13603   cat conftest.$ac_ext >&5
13604   rm -rf conftest*
13605   use__ceill=no
13606 fi
13607 rm -f conftest*
13608   echo "$ac_t""$use__ceill" 1>&6
13609   ac_ext=c
13610 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13611 ac_cpp='$CPP $CPPFLAGS'
13612 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13613 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13614 cross_compiling=$ac_cv_prog_cc_cross
13615
13616   if test x$use__ceill = x"yes"; then
13617     for ac_func in _ceill
13618 do
13619 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13620 echo "configure:13621: checking for $ac_func" >&5
13621 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13622   echo $ac_n "(cached) $ac_c" 1>&6
13623 else
13624   cat > conftest.$ac_ext <<EOF
13625 #line 13626 "configure"
13626 #include "confdefs.h"
13627 /* System header to define __stub macros and hopefully few prototypes,
13628     which can conflict with char $ac_func(); below.  */
13629 #include <assert.h>
13630 /* Override any gcc2 internal prototype to avoid an error.  */
13631 /* We use char because int might match the return type of a gcc2
13632     builtin and then its argument prototype would still apply.  */
13633 char $ac_func();
13634
13635 int main() {
13636
13637 /* The GNU C library defines this for functions which it implements
13638     to always fail with ENOSYS.  Some functions are actually named
13639     something starting with __ and the normal name is an alias.  */
13640 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13641 choke me
13642 #else
13643 $ac_func();
13644 #endif
13645
13646 ; return 0; }
13647 EOF
13648 if { (eval echo configure:13649: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13649   rm -rf conftest*
13650   eval "ac_cv_func_$ac_func=yes"
13651 else
13652   echo "configure: failed program was:" >&5
13653   cat conftest.$ac_ext >&5
13654   rm -rf conftest*
13655   eval "ac_cv_func_$ac_func=no"
13656 fi
13657 rm -f conftest*
13658 fi
13659
13660 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13661   echo "$ac_t""yes" 1>&6
13662     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13663   cat >> confdefs.h <<EOF
13664 #define $ac_tr_func 1
13665 EOF
13666
13667 else
13668   echo "$ac_t""no" 1>&6
13669 fi
13670 done
13671
13672   fi
13673
13674
13675
13676   ac_ext=C
13677 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13678 ac_cpp='$CXXCPP $CPPFLAGS'
13679 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13680 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13681 cross_compiling=$ac_cv_prog_cxx_cross
13682
13683   echo $ac_n "checking for _cosl declaration""... $ac_c" 1>&6
13684 echo "configure:13685: checking for _cosl declaration" >&5
13685   cat > conftest.$ac_ext <<EOF
13686 #line 13687 "configure"
13687 #include "confdefs.h"
13688 #include <math.h>
13689 int main() {
13690  _cosl(0);
13691 ; return 0; }
13692 EOF
13693 if { (eval echo configure:13694: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13694   rm -rf conftest*
13695   use__cosl=yes
13696 else
13697   echo "configure: failed program was:" >&5
13698   cat conftest.$ac_ext >&5
13699   rm -rf conftest*
13700   use__cosl=no
13701 fi
13702 rm -f conftest*
13703   echo "$ac_t""$use__cosl" 1>&6
13704   ac_ext=c
13705 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13706 ac_cpp='$CPP $CPPFLAGS'
13707 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13708 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13709 cross_compiling=$ac_cv_prog_cc_cross
13710
13711   if test x$use__cosl = x"yes"; then
13712     for ac_func in _cosl
13713 do
13714 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13715 echo "configure:13716: checking for $ac_func" >&5
13716 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13717   echo $ac_n "(cached) $ac_c" 1>&6
13718 else
13719   cat > conftest.$ac_ext <<EOF
13720 #line 13721 "configure"
13721 #include "confdefs.h"
13722 /* System header to define __stub macros and hopefully few prototypes,
13723     which can conflict with char $ac_func(); below.  */
13724 #include <assert.h>
13725 /* Override any gcc2 internal prototype to avoid an error.  */
13726 /* We use char because int might match the return type of a gcc2
13727     builtin and then its argument prototype would still apply.  */
13728 char $ac_func();
13729
13730 int main() {
13731
13732 /* The GNU C library defines this for functions which it implements
13733     to always fail with ENOSYS.  Some functions are actually named
13734     something starting with __ and the normal name is an alias.  */
13735 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13736 choke me
13737 #else
13738 $ac_func();
13739 #endif
13740
13741 ; return 0; }
13742 EOF
13743 if { (eval echo configure:13744: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13744   rm -rf conftest*
13745   eval "ac_cv_func_$ac_func=yes"
13746 else
13747   echo "configure: failed program was:" >&5
13748   cat conftest.$ac_ext >&5
13749   rm -rf conftest*
13750   eval "ac_cv_func_$ac_func=no"
13751 fi
13752 rm -f conftest*
13753 fi
13754
13755 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13756   echo "$ac_t""yes" 1>&6
13757     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13758   cat >> confdefs.h <<EOF
13759 #define $ac_tr_func 1
13760 EOF
13761
13762 else
13763   echo "$ac_t""no" 1>&6
13764 fi
13765 done
13766
13767   fi
13768
13769
13770
13771   ac_ext=C
13772 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13773 ac_cpp='$CXXCPP $CPPFLAGS'
13774 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13775 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13776 cross_compiling=$ac_cv_prog_cxx_cross
13777
13778   echo $ac_n "checking for _coshl declaration""... $ac_c" 1>&6
13779 echo "configure:13780: checking for _coshl declaration" >&5
13780   cat > conftest.$ac_ext <<EOF
13781 #line 13782 "configure"
13782 #include "confdefs.h"
13783 #include <math.h>
13784 int main() {
13785  _coshl(0);
13786 ; return 0; }
13787 EOF
13788 if { (eval echo configure:13789: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13789   rm -rf conftest*
13790   use__coshl=yes
13791 else
13792   echo "configure: failed program was:" >&5
13793   cat conftest.$ac_ext >&5
13794   rm -rf conftest*
13795   use__coshl=no
13796 fi
13797 rm -f conftest*
13798   echo "$ac_t""$use__coshl" 1>&6
13799   ac_ext=c
13800 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13801 ac_cpp='$CPP $CPPFLAGS'
13802 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13803 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13804 cross_compiling=$ac_cv_prog_cc_cross
13805
13806   if test x$use__coshl = x"yes"; then
13807     for ac_func in _coshl
13808 do
13809 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13810 echo "configure:13811: checking for $ac_func" >&5
13811 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13812   echo $ac_n "(cached) $ac_c" 1>&6
13813 else
13814   cat > conftest.$ac_ext <<EOF
13815 #line 13816 "configure"
13816 #include "confdefs.h"
13817 /* System header to define __stub macros and hopefully few prototypes,
13818     which can conflict with char $ac_func(); below.  */
13819 #include <assert.h>
13820 /* Override any gcc2 internal prototype to avoid an error.  */
13821 /* We use char because int might match the return type of a gcc2
13822     builtin and then its argument prototype would still apply.  */
13823 char $ac_func();
13824
13825 int main() {
13826
13827 /* The GNU C library defines this for functions which it implements
13828     to always fail with ENOSYS.  Some functions are actually named
13829     something starting with __ and the normal name is an alias.  */
13830 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13831 choke me
13832 #else
13833 $ac_func();
13834 #endif
13835
13836 ; return 0; }
13837 EOF
13838 if { (eval echo configure:13839: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13839   rm -rf conftest*
13840   eval "ac_cv_func_$ac_func=yes"
13841 else
13842   echo "configure: failed program was:" >&5
13843   cat conftest.$ac_ext >&5
13844   rm -rf conftest*
13845   eval "ac_cv_func_$ac_func=no"
13846 fi
13847 rm -f conftest*
13848 fi
13849
13850 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13851   echo "$ac_t""yes" 1>&6
13852     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13853   cat >> confdefs.h <<EOF
13854 #define $ac_tr_func 1
13855 EOF
13856
13857 else
13858   echo "$ac_t""no" 1>&6
13859 fi
13860 done
13861
13862   fi
13863
13864
13865
13866   ac_ext=C
13867 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13868 ac_cpp='$CXXCPP $CPPFLAGS'
13869 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13870 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13871 cross_compiling=$ac_cv_prog_cxx_cross
13872
13873   echo $ac_n "checking for _expl declaration""... $ac_c" 1>&6
13874 echo "configure:13875: checking for _expl declaration" >&5
13875   cat > conftest.$ac_ext <<EOF
13876 #line 13877 "configure"
13877 #include "confdefs.h"
13878 #include <math.h>
13879 int main() {
13880  _expl(0);
13881 ; return 0; }
13882 EOF
13883 if { (eval echo configure:13884: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13884   rm -rf conftest*
13885   use__expl=yes
13886 else
13887   echo "configure: failed program was:" >&5
13888   cat conftest.$ac_ext >&5
13889   rm -rf conftest*
13890   use__expl=no
13891 fi
13892 rm -f conftest*
13893   echo "$ac_t""$use__expl" 1>&6
13894   ac_ext=c
13895 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13896 ac_cpp='$CPP $CPPFLAGS'
13897 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13898 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13899 cross_compiling=$ac_cv_prog_cc_cross
13900
13901   if test x$use__expl = x"yes"; then
13902     for ac_func in _expl
13903 do
13904 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13905 echo "configure:13906: checking for $ac_func" >&5
13906 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13907   echo $ac_n "(cached) $ac_c" 1>&6
13908 else
13909   cat > conftest.$ac_ext <<EOF
13910 #line 13911 "configure"
13911 #include "confdefs.h"
13912 /* System header to define __stub macros and hopefully few prototypes,
13913     which can conflict with char $ac_func(); below.  */
13914 #include <assert.h>
13915 /* Override any gcc2 internal prototype to avoid an error.  */
13916 /* We use char because int might match the return type of a gcc2
13917     builtin and then its argument prototype would still apply.  */
13918 char $ac_func();
13919
13920 int main() {
13921
13922 /* The GNU C library defines this for functions which it implements
13923     to always fail with ENOSYS.  Some functions are actually named
13924     something starting with __ and the normal name is an alias.  */
13925 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13926 choke me
13927 #else
13928 $ac_func();
13929 #endif
13930
13931 ; return 0; }
13932 EOF
13933 if { (eval echo configure:13934: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13934   rm -rf conftest*
13935   eval "ac_cv_func_$ac_func=yes"
13936 else
13937   echo "configure: failed program was:" >&5
13938   cat conftest.$ac_ext >&5
13939   rm -rf conftest*
13940   eval "ac_cv_func_$ac_func=no"
13941 fi
13942 rm -f conftest*
13943 fi
13944
13945 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13946   echo "$ac_t""yes" 1>&6
13947     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13948   cat >> confdefs.h <<EOF
13949 #define $ac_tr_func 1
13950 EOF
13951
13952 else
13953   echo "$ac_t""no" 1>&6
13954 fi
13955 done
13956
13957   fi
13958
13959
13960
13961   ac_ext=C
13962 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13963 ac_cpp='$CXXCPP $CPPFLAGS'
13964 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13965 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13966 cross_compiling=$ac_cv_prog_cxx_cross
13967
13968   echo $ac_n "checking for _fabsl declaration""... $ac_c" 1>&6
13969 echo "configure:13970: checking for _fabsl declaration" >&5
13970   cat > conftest.$ac_ext <<EOF
13971 #line 13972 "configure"
13972 #include "confdefs.h"
13973 #include <math.h>
13974 int main() {
13975  _fabsl(0);
13976 ; return 0; }
13977 EOF
13978 if { (eval echo configure:13979: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13979   rm -rf conftest*
13980   use__fabsl=yes
13981 else
13982   echo "configure: failed program was:" >&5
13983   cat conftest.$ac_ext >&5
13984   rm -rf conftest*
13985   use__fabsl=no
13986 fi
13987 rm -f conftest*
13988   echo "$ac_t""$use__fabsl" 1>&6
13989   ac_ext=c
13990 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13991 ac_cpp='$CPP $CPPFLAGS'
13992 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13993 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13994 cross_compiling=$ac_cv_prog_cc_cross
13995
13996   if test x$use__fabsl = x"yes"; then
13997     for ac_func in _fabsl
13998 do
13999 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14000 echo "configure:14001: checking for $ac_func" >&5
14001 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14002   echo $ac_n "(cached) $ac_c" 1>&6
14003 else
14004   cat > conftest.$ac_ext <<EOF
14005 #line 14006 "configure"
14006 #include "confdefs.h"
14007 /* System header to define __stub macros and hopefully few prototypes,
14008     which can conflict with char $ac_func(); below.  */
14009 #include <assert.h>
14010 /* Override any gcc2 internal prototype to avoid an error.  */
14011 /* We use char because int might match the return type of a gcc2
14012     builtin and then its argument prototype would still apply.  */
14013 char $ac_func();
14014
14015 int main() {
14016
14017 /* The GNU C library defines this for functions which it implements
14018     to always fail with ENOSYS.  Some functions are actually named
14019     something starting with __ and the normal name is an alias.  */
14020 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14021 choke me
14022 #else
14023 $ac_func();
14024 #endif
14025
14026 ; return 0; }
14027 EOF
14028 if { (eval echo configure:14029: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14029   rm -rf conftest*
14030   eval "ac_cv_func_$ac_func=yes"
14031 else
14032   echo "configure: failed program was:" >&5
14033   cat conftest.$ac_ext >&5
14034   rm -rf conftest*
14035   eval "ac_cv_func_$ac_func=no"
14036 fi
14037 rm -f conftest*
14038 fi
14039
14040 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14041   echo "$ac_t""yes" 1>&6
14042     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14043   cat >> confdefs.h <<EOF
14044 #define $ac_tr_func 1
14045 EOF
14046
14047 else
14048   echo "$ac_t""no" 1>&6
14049 fi
14050 done
14051
14052   fi
14053
14054
14055
14056   ac_ext=C
14057 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14058 ac_cpp='$CXXCPP $CPPFLAGS'
14059 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14060 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14061 cross_compiling=$ac_cv_prog_cxx_cross
14062
14063   echo $ac_n "checking for _floorl declaration""... $ac_c" 1>&6
14064 echo "configure:14065: checking for _floorl declaration" >&5
14065   cat > conftest.$ac_ext <<EOF
14066 #line 14067 "configure"
14067 #include "confdefs.h"
14068 #include <math.h>
14069 int main() {
14070  _floorl(0);
14071 ; return 0; }
14072 EOF
14073 if { (eval echo configure:14074: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14074   rm -rf conftest*
14075   use__floorl=yes
14076 else
14077   echo "configure: failed program was:" >&5
14078   cat conftest.$ac_ext >&5
14079   rm -rf conftest*
14080   use__floorl=no
14081 fi
14082 rm -f conftest*
14083   echo "$ac_t""$use__floorl" 1>&6
14084   ac_ext=c
14085 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14086 ac_cpp='$CPP $CPPFLAGS'
14087 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14088 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14089 cross_compiling=$ac_cv_prog_cc_cross
14090
14091   if test x$use__floorl = x"yes"; then
14092     for ac_func in _floorl
14093 do
14094 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14095 echo "configure:14096: checking for $ac_func" >&5
14096 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14097   echo $ac_n "(cached) $ac_c" 1>&6
14098 else
14099   cat > conftest.$ac_ext <<EOF
14100 #line 14101 "configure"
14101 #include "confdefs.h"
14102 /* System header to define __stub macros and hopefully few prototypes,
14103     which can conflict with char $ac_func(); below.  */
14104 #include <assert.h>
14105 /* Override any gcc2 internal prototype to avoid an error.  */
14106 /* We use char because int might match the return type of a gcc2
14107     builtin and then its argument prototype would still apply.  */
14108 char $ac_func();
14109
14110 int main() {
14111
14112 /* The GNU C library defines this for functions which it implements
14113     to always fail with ENOSYS.  Some functions are actually named
14114     something starting with __ and the normal name is an alias.  */
14115 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14116 choke me
14117 #else
14118 $ac_func();
14119 #endif
14120
14121 ; return 0; }
14122 EOF
14123 if { (eval echo configure:14124: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14124   rm -rf conftest*
14125   eval "ac_cv_func_$ac_func=yes"
14126 else
14127   echo "configure: failed program was:" >&5
14128   cat conftest.$ac_ext >&5
14129   rm -rf conftest*
14130   eval "ac_cv_func_$ac_func=no"
14131 fi
14132 rm -f conftest*
14133 fi
14134
14135 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14136   echo "$ac_t""yes" 1>&6
14137     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14138   cat >> confdefs.h <<EOF
14139 #define $ac_tr_func 1
14140 EOF
14141
14142 else
14143   echo "$ac_t""no" 1>&6
14144 fi
14145 done
14146
14147   fi
14148
14149
14150
14151   ac_ext=C
14152 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14153 ac_cpp='$CXXCPP $CPPFLAGS'
14154 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14155 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14156 cross_compiling=$ac_cv_prog_cxx_cross
14157
14158   echo $ac_n "checking for _fmodl declaration""... $ac_c" 1>&6
14159 echo "configure:14160: checking for _fmodl declaration" >&5
14160   cat > conftest.$ac_ext <<EOF
14161 #line 14162 "configure"
14162 #include "confdefs.h"
14163 #include <math.h>
14164 int main() {
14165  _fmodl(0, 0);
14166 ; return 0; }
14167 EOF
14168 if { (eval echo configure:14169: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14169   rm -rf conftest*
14170   use__fmodl=yes
14171 else
14172   echo "configure: failed program was:" >&5
14173   cat conftest.$ac_ext >&5
14174   rm -rf conftest*
14175   use__fmodl=no
14176 fi
14177 rm -f conftest*
14178   echo "$ac_t""$use__fmodl" 1>&6
14179   ac_ext=c
14180 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14181 ac_cpp='$CPP $CPPFLAGS'
14182 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14183 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14184 cross_compiling=$ac_cv_prog_cc_cross
14185
14186   if test x$use__fmodl = x"yes"; then
14187     for ac_func in _fmodl
14188 do
14189 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14190 echo "configure:14191: checking for $ac_func" >&5
14191 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14192   echo $ac_n "(cached) $ac_c" 1>&6
14193 else
14194   cat > conftest.$ac_ext <<EOF
14195 #line 14196 "configure"
14196 #include "confdefs.h"
14197 /* System header to define __stub macros and hopefully few prototypes,
14198     which can conflict with char $ac_func(); below.  */
14199 #include <assert.h>
14200 /* Override any gcc2 internal prototype to avoid an error.  */
14201 /* We use char because int might match the return type of a gcc2
14202     builtin and then its argument prototype would still apply.  */
14203 char $ac_func();
14204
14205 int main() {
14206
14207 /* The GNU C library defines this for functions which it implements
14208     to always fail with ENOSYS.  Some functions are actually named
14209     something starting with __ and the normal name is an alias.  */
14210 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14211 choke me
14212 #else
14213 $ac_func();
14214 #endif
14215
14216 ; return 0; }
14217 EOF
14218 if { (eval echo configure:14219: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14219   rm -rf conftest*
14220   eval "ac_cv_func_$ac_func=yes"
14221 else
14222   echo "configure: failed program was:" >&5
14223   cat conftest.$ac_ext >&5
14224   rm -rf conftest*
14225   eval "ac_cv_func_$ac_func=no"
14226 fi
14227 rm -f conftest*
14228 fi
14229
14230 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14231   echo "$ac_t""yes" 1>&6
14232     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14233   cat >> confdefs.h <<EOF
14234 #define $ac_tr_func 1
14235 EOF
14236
14237 else
14238   echo "$ac_t""no" 1>&6
14239 fi
14240 done
14241
14242   fi
14243
14244
14245
14246   ac_ext=C
14247 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14248 ac_cpp='$CXXCPP $CPPFLAGS'
14249 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14250 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14251 cross_compiling=$ac_cv_prog_cxx_cross
14252
14253   echo $ac_n "checking for _frexpl declaration""... $ac_c" 1>&6
14254 echo "configure:14255: checking for _frexpl declaration" >&5
14255   cat > conftest.$ac_ext <<EOF
14256 #line 14257 "configure"
14257 #include "confdefs.h"
14258 #include <math.h>
14259 int main() {
14260  _frexpl(0, 0);
14261 ; return 0; }
14262 EOF
14263 if { (eval echo configure:14264: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14264   rm -rf conftest*
14265   use__frexpl=yes
14266 else
14267   echo "configure: failed program was:" >&5
14268   cat conftest.$ac_ext >&5
14269   rm -rf conftest*
14270   use__frexpl=no
14271 fi
14272 rm -f conftest*
14273   echo "$ac_t""$use__frexpl" 1>&6
14274   ac_ext=c
14275 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14276 ac_cpp='$CPP $CPPFLAGS'
14277 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14278 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14279 cross_compiling=$ac_cv_prog_cc_cross
14280
14281   if test x$use__frexpl = x"yes"; then
14282     for ac_func in _frexpl
14283 do
14284 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14285 echo "configure:14286: checking for $ac_func" >&5
14286 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14287   echo $ac_n "(cached) $ac_c" 1>&6
14288 else
14289   cat > conftest.$ac_ext <<EOF
14290 #line 14291 "configure"
14291 #include "confdefs.h"
14292 /* System header to define __stub macros and hopefully few prototypes,
14293     which can conflict with char $ac_func(); below.  */
14294 #include <assert.h>
14295 /* Override any gcc2 internal prototype to avoid an error.  */
14296 /* We use char because int might match the return type of a gcc2
14297     builtin and then its argument prototype would still apply.  */
14298 char $ac_func();
14299
14300 int main() {
14301
14302 /* The GNU C library defines this for functions which it implements
14303     to always fail with ENOSYS.  Some functions are actually named
14304     something starting with __ and the normal name is an alias.  */
14305 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14306 choke me
14307 #else
14308 $ac_func();
14309 #endif
14310
14311 ; return 0; }
14312 EOF
14313 if { (eval echo configure:14314: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14314   rm -rf conftest*
14315   eval "ac_cv_func_$ac_func=yes"
14316 else
14317   echo "configure: failed program was:" >&5
14318   cat conftest.$ac_ext >&5
14319   rm -rf conftest*
14320   eval "ac_cv_func_$ac_func=no"
14321 fi
14322 rm -f conftest*
14323 fi
14324
14325 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14326   echo "$ac_t""yes" 1>&6
14327     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14328   cat >> confdefs.h <<EOF
14329 #define $ac_tr_func 1
14330 EOF
14331
14332 else
14333   echo "$ac_t""no" 1>&6
14334 fi
14335 done
14336
14337   fi
14338
14339
14340
14341   ac_ext=C
14342 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14343 ac_cpp='$CXXCPP $CPPFLAGS'
14344 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14345 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14346 cross_compiling=$ac_cv_prog_cxx_cross
14347
14348   echo $ac_n "checking for _ldexpl declaration""... $ac_c" 1>&6
14349 echo "configure:14350: checking for _ldexpl declaration" >&5
14350   cat > conftest.$ac_ext <<EOF
14351 #line 14352 "configure"
14352 #include "confdefs.h"
14353 #include <math.h>
14354 int main() {
14355  _ldexpl(0, 0);
14356 ; return 0; }
14357 EOF
14358 if { (eval echo configure:14359: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14359   rm -rf conftest*
14360   use__ldexpl=yes
14361 else
14362   echo "configure: failed program was:" >&5
14363   cat conftest.$ac_ext >&5
14364   rm -rf conftest*
14365   use__ldexpl=no
14366 fi
14367 rm -f conftest*
14368   echo "$ac_t""$use__ldexpl" 1>&6
14369   ac_ext=c
14370 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14371 ac_cpp='$CPP $CPPFLAGS'
14372 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14373 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14374 cross_compiling=$ac_cv_prog_cc_cross
14375
14376   if test x$use__ldexpl = x"yes"; then
14377     for ac_func in _ldexpl
14378 do
14379 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14380 echo "configure:14381: checking for $ac_func" >&5
14381 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14382   echo $ac_n "(cached) $ac_c" 1>&6
14383 else
14384   cat > conftest.$ac_ext <<EOF
14385 #line 14386 "configure"
14386 #include "confdefs.h"
14387 /* System header to define __stub macros and hopefully few prototypes,
14388     which can conflict with char $ac_func(); below.  */
14389 #include <assert.h>
14390 /* Override any gcc2 internal prototype to avoid an error.  */
14391 /* We use char because int might match the return type of a gcc2
14392     builtin and then its argument prototype would still apply.  */
14393 char $ac_func();
14394
14395 int main() {
14396
14397 /* The GNU C library defines this for functions which it implements
14398     to always fail with ENOSYS.  Some functions are actually named
14399     something starting with __ and the normal name is an alias.  */
14400 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14401 choke me
14402 #else
14403 $ac_func();
14404 #endif
14405
14406 ; return 0; }
14407 EOF
14408 if { (eval echo configure:14409: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14409   rm -rf conftest*
14410   eval "ac_cv_func_$ac_func=yes"
14411 else
14412   echo "configure: failed program was:" >&5
14413   cat conftest.$ac_ext >&5
14414   rm -rf conftest*
14415   eval "ac_cv_func_$ac_func=no"
14416 fi
14417 rm -f conftest*
14418 fi
14419
14420 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14421   echo "$ac_t""yes" 1>&6
14422     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14423   cat >> confdefs.h <<EOF
14424 #define $ac_tr_func 1
14425 EOF
14426
14427 else
14428   echo "$ac_t""no" 1>&6
14429 fi
14430 done
14431
14432   fi
14433
14434
14435
14436   ac_ext=C
14437 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14438 ac_cpp='$CXXCPP $CPPFLAGS'
14439 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14440 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14441 cross_compiling=$ac_cv_prog_cxx_cross
14442
14443   echo $ac_n "checking for _logl declaration""... $ac_c" 1>&6
14444 echo "configure:14445: checking for _logl declaration" >&5
14445   cat > conftest.$ac_ext <<EOF
14446 #line 14447 "configure"
14447 #include "confdefs.h"
14448 #include <math.h>
14449 int main() {
14450  _logl(0);
14451 ; return 0; }
14452 EOF
14453 if { (eval echo configure:14454: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14454   rm -rf conftest*
14455   use__logl=yes
14456 else
14457   echo "configure: failed program was:" >&5
14458   cat conftest.$ac_ext >&5
14459   rm -rf conftest*
14460   use__logl=no
14461 fi
14462 rm -f conftest*
14463   echo "$ac_t""$use__logl" 1>&6
14464   ac_ext=c
14465 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14466 ac_cpp='$CPP $CPPFLAGS'
14467 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14468 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14469 cross_compiling=$ac_cv_prog_cc_cross
14470
14471   if test x$use__logl = x"yes"; then
14472     for ac_func in _logl
14473 do
14474 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14475 echo "configure:14476: checking for $ac_func" >&5
14476 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14477   echo $ac_n "(cached) $ac_c" 1>&6
14478 else
14479   cat > conftest.$ac_ext <<EOF
14480 #line 14481 "configure"
14481 #include "confdefs.h"
14482 /* System header to define __stub macros and hopefully few prototypes,
14483     which can conflict with char $ac_func(); below.  */
14484 #include <assert.h>
14485 /* Override any gcc2 internal prototype to avoid an error.  */
14486 /* We use char because int might match the return type of a gcc2
14487     builtin and then its argument prototype would still apply.  */
14488 char $ac_func();
14489
14490 int main() {
14491
14492 /* The GNU C library defines this for functions which it implements
14493     to always fail with ENOSYS.  Some functions are actually named
14494     something starting with __ and the normal name is an alias.  */
14495 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14496 choke me
14497 #else
14498 $ac_func();
14499 #endif
14500
14501 ; return 0; }
14502 EOF
14503 if { (eval echo configure:14504: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14504   rm -rf conftest*
14505   eval "ac_cv_func_$ac_func=yes"
14506 else
14507   echo "configure: failed program was:" >&5
14508   cat conftest.$ac_ext >&5
14509   rm -rf conftest*
14510   eval "ac_cv_func_$ac_func=no"
14511 fi
14512 rm -f conftest*
14513 fi
14514
14515 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14516   echo "$ac_t""yes" 1>&6
14517     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14518   cat >> confdefs.h <<EOF
14519 #define $ac_tr_func 1
14520 EOF
14521
14522 else
14523   echo "$ac_t""no" 1>&6
14524 fi
14525 done
14526
14527   fi
14528
14529
14530
14531   ac_ext=C
14532 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14533 ac_cpp='$CXXCPP $CPPFLAGS'
14534 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14535 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14536 cross_compiling=$ac_cv_prog_cxx_cross
14537
14538   echo $ac_n "checking for _log10l declaration""... $ac_c" 1>&6
14539 echo "configure:14540: checking for _log10l declaration" >&5
14540   cat > conftest.$ac_ext <<EOF
14541 #line 14542 "configure"
14542 #include "confdefs.h"
14543 #include <math.h>
14544 int main() {
14545  _log10l(0);
14546 ; return 0; }
14547 EOF
14548 if { (eval echo configure:14549: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14549   rm -rf conftest*
14550   use__log10l=yes
14551 else
14552   echo "configure: failed program was:" >&5
14553   cat conftest.$ac_ext >&5
14554   rm -rf conftest*
14555   use__log10l=no
14556 fi
14557 rm -f conftest*
14558   echo "$ac_t""$use__log10l" 1>&6
14559   ac_ext=c
14560 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14561 ac_cpp='$CPP $CPPFLAGS'
14562 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14563 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14564 cross_compiling=$ac_cv_prog_cc_cross
14565
14566   if test x$use__log10l = x"yes"; then
14567     for ac_func in _log10l
14568 do
14569 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14570 echo "configure:14571: checking for $ac_func" >&5
14571 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14572   echo $ac_n "(cached) $ac_c" 1>&6
14573 else
14574   cat > conftest.$ac_ext <<EOF
14575 #line 14576 "configure"
14576 #include "confdefs.h"
14577 /* System header to define __stub macros and hopefully few prototypes,
14578     which can conflict with char $ac_func(); below.  */
14579 #include <assert.h>
14580 /* Override any gcc2 internal prototype to avoid an error.  */
14581 /* We use char because int might match the return type of a gcc2
14582     builtin and then its argument prototype would still apply.  */
14583 char $ac_func();
14584
14585 int main() {
14586
14587 /* The GNU C library defines this for functions which it implements
14588     to always fail with ENOSYS.  Some functions are actually named
14589     something starting with __ and the normal name is an alias.  */
14590 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14591 choke me
14592 #else
14593 $ac_func();
14594 #endif
14595
14596 ; return 0; }
14597 EOF
14598 if { (eval echo configure:14599: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14599   rm -rf conftest*
14600   eval "ac_cv_func_$ac_func=yes"
14601 else
14602   echo "configure: failed program was:" >&5
14603   cat conftest.$ac_ext >&5
14604   rm -rf conftest*
14605   eval "ac_cv_func_$ac_func=no"
14606 fi
14607 rm -f conftest*
14608 fi
14609
14610 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14611   echo "$ac_t""yes" 1>&6
14612     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14613   cat >> confdefs.h <<EOF
14614 #define $ac_tr_func 1
14615 EOF
14616
14617 else
14618   echo "$ac_t""no" 1>&6
14619 fi
14620 done
14621
14622   fi
14623
14624
14625
14626   ac_ext=C
14627 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14628 ac_cpp='$CXXCPP $CPPFLAGS'
14629 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14630 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14631 cross_compiling=$ac_cv_prog_cxx_cross
14632
14633   echo $ac_n "checking for _modfl declaration""... $ac_c" 1>&6
14634 echo "configure:14635: checking for _modfl declaration" >&5
14635   cat > conftest.$ac_ext <<EOF
14636 #line 14637 "configure"
14637 #include "confdefs.h"
14638 #include <math.h>
14639 int main() {
14640  _modfl(0, 0);
14641 ; return 0; }
14642 EOF
14643 if { (eval echo configure:14644: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14644   rm -rf conftest*
14645   use__modfl=yes
14646 else
14647   echo "configure: failed program was:" >&5
14648   cat conftest.$ac_ext >&5
14649   rm -rf conftest*
14650   use__modfl=no
14651 fi
14652 rm -f conftest*
14653   echo "$ac_t""$use__modfl" 1>&6
14654   ac_ext=c
14655 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14656 ac_cpp='$CPP $CPPFLAGS'
14657 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14658 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14659 cross_compiling=$ac_cv_prog_cc_cross
14660
14661   if test x$use__modfl = x"yes"; then
14662     for ac_func in _modfl
14663 do
14664 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14665 echo "configure:14666: checking for $ac_func" >&5
14666 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14667   echo $ac_n "(cached) $ac_c" 1>&6
14668 else
14669   cat > conftest.$ac_ext <<EOF
14670 #line 14671 "configure"
14671 #include "confdefs.h"
14672 /* System header to define __stub macros and hopefully few prototypes,
14673     which can conflict with char $ac_func(); below.  */
14674 #include <assert.h>
14675 /* Override any gcc2 internal prototype to avoid an error.  */
14676 /* We use char because int might match the return type of a gcc2
14677     builtin and then its argument prototype would still apply.  */
14678 char $ac_func();
14679
14680 int main() {
14681
14682 /* The GNU C library defines this for functions which it implements
14683     to always fail with ENOSYS.  Some functions are actually named
14684     something starting with __ and the normal name is an alias.  */
14685 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14686 choke me
14687 #else
14688 $ac_func();
14689 #endif
14690
14691 ; return 0; }
14692 EOF
14693 if { (eval echo configure:14694: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14694   rm -rf conftest*
14695   eval "ac_cv_func_$ac_func=yes"
14696 else
14697   echo "configure: failed program was:" >&5
14698   cat conftest.$ac_ext >&5
14699   rm -rf conftest*
14700   eval "ac_cv_func_$ac_func=no"
14701 fi
14702 rm -f conftest*
14703 fi
14704
14705 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14706   echo "$ac_t""yes" 1>&6
14707     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14708   cat >> confdefs.h <<EOF
14709 #define $ac_tr_func 1
14710 EOF
14711
14712 else
14713   echo "$ac_t""no" 1>&6
14714 fi
14715 done
14716
14717   fi
14718
14719
14720
14721   ac_ext=C
14722 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14723 ac_cpp='$CXXCPP $CPPFLAGS'
14724 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14725 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14726 cross_compiling=$ac_cv_prog_cxx_cross
14727
14728   echo $ac_n "checking for _powl declaration""... $ac_c" 1>&6
14729 echo "configure:14730: checking for _powl declaration" >&5
14730   cat > conftest.$ac_ext <<EOF
14731 #line 14732 "configure"
14732 #include "confdefs.h"
14733 #include <math.h>
14734 int main() {
14735  _powl(0, 0);
14736 ; return 0; }
14737 EOF
14738 if { (eval echo configure:14739: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14739   rm -rf conftest*
14740   use__powl=yes
14741 else
14742   echo "configure: failed program was:" >&5
14743   cat conftest.$ac_ext >&5
14744   rm -rf conftest*
14745   use__powl=no
14746 fi
14747 rm -f conftest*
14748   echo "$ac_t""$use__powl" 1>&6
14749   ac_ext=c
14750 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14751 ac_cpp='$CPP $CPPFLAGS'
14752 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14753 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14754 cross_compiling=$ac_cv_prog_cc_cross
14755
14756   if test x$use__powl = x"yes"; then
14757     for ac_func in _powl
14758 do
14759 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14760 echo "configure:14761: checking for $ac_func" >&5
14761 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14762   echo $ac_n "(cached) $ac_c" 1>&6
14763 else
14764   cat > conftest.$ac_ext <<EOF
14765 #line 14766 "configure"
14766 #include "confdefs.h"
14767 /* System header to define __stub macros and hopefully few prototypes,
14768     which can conflict with char $ac_func(); below.  */
14769 #include <assert.h>
14770 /* Override any gcc2 internal prototype to avoid an error.  */
14771 /* We use char because int might match the return type of a gcc2
14772     builtin and then its argument prototype would still apply.  */
14773 char $ac_func();
14774
14775 int main() {
14776
14777 /* The GNU C library defines this for functions which it implements
14778     to always fail with ENOSYS.  Some functions are actually named
14779     something starting with __ and the normal name is an alias.  */
14780 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14781 choke me
14782 #else
14783 $ac_func();
14784 #endif
14785
14786 ; return 0; }
14787 EOF
14788 if { (eval echo configure:14789: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14789   rm -rf conftest*
14790   eval "ac_cv_func_$ac_func=yes"
14791 else
14792   echo "configure: failed program was:" >&5
14793   cat conftest.$ac_ext >&5
14794   rm -rf conftest*
14795   eval "ac_cv_func_$ac_func=no"
14796 fi
14797 rm -f conftest*
14798 fi
14799
14800 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14801   echo "$ac_t""yes" 1>&6
14802     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14803   cat >> confdefs.h <<EOF
14804 #define $ac_tr_func 1
14805 EOF
14806
14807 else
14808   echo "$ac_t""no" 1>&6
14809 fi
14810 done
14811
14812   fi
14813
14814
14815
14816   ac_ext=C
14817 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14818 ac_cpp='$CXXCPP $CPPFLAGS'
14819 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14820 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14821 cross_compiling=$ac_cv_prog_cxx_cross
14822
14823   echo $ac_n "checking for _sinl declaration""... $ac_c" 1>&6
14824 echo "configure:14825: checking for _sinl declaration" >&5
14825   cat > conftest.$ac_ext <<EOF
14826 #line 14827 "configure"
14827 #include "confdefs.h"
14828 #include <math.h>
14829 int main() {
14830  _sinl(0);
14831 ; return 0; }
14832 EOF
14833 if { (eval echo configure:14834: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14834   rm -rf conftest*
14835   use__sinl=yes
14836 else
14837   echo "configure: failed program was:" >&5
14838   cat conftest.$ac_ext >&5
14839   rm -rf conftest*
14840   use__sinl=no
14841 fi
14842 rm -f conftest*
14843   echo "$ac_t""$use__sinl" 1>&6
14844   ac_ext=c
14845 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14846 ac_cpp='$CPP $CPPFLAGS'
14847 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14848 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14849 cross_compiling=$ac_cv_prog_cc_cross
14850
14851   if test x$use__sinl = x"yes"; then
14852     for ac_func in _sinl
14853 do
14854 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14855 echo "configure:14856: checking for $ac_func" >&5
14856 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14857   echo $ac_n "(cached) $ac_c" 1>&6
14858 else
14859   cat > conftest.$ac_ext <<EOF
14860 #line 14861 "configure"
14861 #include "confdefs.h"
14862 /* System header to define __stub macros and hopefully few prototypes,
14863     which can conflict with char $ac_func(); below.  */
14864 #include <assert.h>
14865 /* Override any gcc2 internal prototype to avoid an error.  */
14866 /* We use char because int might match the return type of a gcc2
14867     builtin and then its argument prototype would still apply.  */
14868 char $ac_func();
14869
14870 int main() {
14871
14872 /* The GNU C library defines this for functions which it implements
14873     to always fail with ENOSYS.  Some functions are actually named
14874     something starting with __ and the normal name is an alias.  */
14875 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14876 choke me
14877 #else
14878 $ac_func();
14879 #endif
14880
14881 ; return 0; }
14882 EOF
14883 if { (eval echo configure:14884: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14884   rm -rf conftest*
14885   eval "ac_cv_func_$ac_func=yes"
14886 else
14887   echo "configure: failed program was:" >&5
14888   cat conftest.$ac_ext >&5
14889   rm -rf conftest*
14890   eval "ac_cv_func_$ac_func=no"
14891 fi
14892 rm -f conftest*
14893 fi
14894
14895 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14896   echo "$ac_t""yes" 1>&6
14897     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14898   cat >> confdefs.h <<EOF
14899 #define $ac_tr_func 1
14900 EOF
14901
14902 else
14903   echo "$ac_t""no" 1>&6
14904 fi
14905 done
14906
14907   fi
14908
14909
14910
14911   ac_ext=C
14912 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14913 ac_cpp='$CXXCPP $CPPFLAGS'
14914 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14915 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14916 cross_compiling=$ac_cv_prog_cxx_cross
14917
14918   echo $ac_n "checking for _sinhl declaration""... $ac_c" 1>&6
14919 echo "configure:14920: checking for _sinhl declaration" >&5
14920   cat > conftest.$ac_ext <<EOF
14921 #line 14922 "configure"
14922 #include "confdefs.h"
14923 #include <math.h>
14924 int main() {
14925  _sinhl(0);
14926 ; return 0; }
14927 EOF
14928 if { (eval echo configure:14929: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14929   rm -rf conftest*
14930   use__sinhl=yes
14931 else
14932   echo "configure: failed program was:" >&5
14933   cat conftest.$ac_ext >&5
14934   rm -rf conftest*
14935   use__sinhl=no
14936 fi
14937 rm -f conftest*
14938   echo "$ac_t""$use__sinhl" 1>&6
14939   ac_ext=c
14940 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14941 ac_cpp='$CPP $CPPFLAGS'
14942 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14943 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14944 cross_compiling=$ac_cv_prog_cc_cross
14945
14946   if test x$use__sinhl = x"yes"; then
14947     for ac_func in _sinhl
14948 do
14949 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14950 echo "configure:14951: checking for $ac_func" >&5
14951 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14952   echo $ac_n "(cached) $ac_c" 1>&6
14953 else
14954   cat > conftest.$ac_ext <<EOF
14955 #line 14956 "configure"
14956 #include "confdefs.h"
14957 /* System header to define __stub macros and hopefully few prototypes,
14958     which can conflict with char $ac_func(); below.  */
14959 #include <assert.h>
14960 /* Override any gcc2 internal prototype to avoid an error.  */
14961 /* We use char because int might match the return type of a gcc2
14962     builtin and then its argument prototype would still apply.  */
14963 char $ac_func();
14964
14965 int main() {
14966
14967 /* The GNU C library defines this for functions which it implements
14968     to always fail with ENOSYS.  Some functions are actually named
14969     something starting with __ and the normal name is an alias.  */
14970 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14971 choke me
14972 #else
14973 $ac_func();
14974 #endif
14975
14976 ; return 0; }
14977 EOF
14978 if { (eval echo configure:14979: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14979   rm -rf conftest*
14980   eval "ac_cv_func_$ac_func=yes"
14981 else
14982   echo "configure: failed program was:" >&5
14983   cat conftest.$ac_ext >&5
14984   rm -rf conftest*
14985   eval "ac_cv_func_$ac_func=no"
14986 fi
14987 rm -f conftest*
14988 fi
14989
14990 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14991   echo "$ac_t""yes" 1>&6
14992     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14993   cat >> confdefs.h <<EOF
14994 #define $ac_tr_func 1
14995 EOF
14996
14997 else
14998   echo "$ac_t""no" 1>&6
14999 fi
15000 done
15001
15002   fi
15003
15004
15005
15006   ac_ext=C
15007 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15008 ac_cpp='$CXXCPP $CPPFLAGS'
15009 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15010 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15011 cross_compiling=$ac_cv_prog_cxx_cross
15012
15013   echo $ac_n "checking for _sqrtl declaration""... $ac_c" 1>&6
15014 echo "configure:15015: checking for _sqrtl declaration" >&5
15015   cat > conftest.$ac_ext <<EOF
15016 #line 15017 "configure"
15017 #include "confdefs.h"
15018 #include <math.h>
15019 int main() {
15020  _sqrtl(0);
15021 ; return 0; }
15022 EOF
15023 if { (eval echo configure:15024: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15024   rm -rf conftest*
15025   use__sqrtl=yes
15026 else
15027   echo "configure: failed program was:" >&5
15028   cat conftest.$ac_ext >&5
15029   rm -rf conftest*
15030   use__sqrtl=no
15031 fi
15032 rm -f conftest*
15033   echo "$ac_t""$use__sqrtl" 1>&6
15034   ac_ext=c
15035 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15036 ac_cpp='$CPP $CPPFLAGS'
15037 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15038 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15039 cross_compiling=$ac_cv_prog_cc_cross
15040
15041   if test x$use__sqrtl = x"yes"; then
15042     for ac_func in _sqrtl
15043 do
15044 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15045 echo "configure:15046: checking for $ac_func" >&5
15046 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15047   echo $ac_n "(cached) $ac_c" 1>&6
15048 else
15049   cat > conftest.$ac_ext <<EOF
15050 #line 15051 "configure"
15051 #include "confdefs.h"
15052 /* System header to define __stub macros and hopefully few prototypes,
15053     which can conflict with char $ac_func(); below.  */
15054 #include <assert.h>
15055 /* Override any gcc2 internal prototype to avoid an error.  */
15056 /* We use char because int might match the return type of a gcc2
15057     builtin and then its argument prototype would still apply.  */
15058 char $ac_func();
15059
15060 int main() {
15061
15062 /* The GNU C library defines this for functions which it implements
15063     to always fail with ENOSYS.  Some functions are actually named
15064     something starting with __ and the normal name is an alias.  */
15065 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15066 choke me
15067 #else
15068 $ac_func();
15069 #endif
15070
15071 ; return 0; }
15072 EOF
15073 if { (eval echo configure:15074: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15074   rm -rf conftest*
15075   eval "ac_cv_func_$ac_func=yes"
15076 else
15077   echo "configure: failed program was:" >&5
15078   cat conftest.$ac_ext >&5
15079   rm -rf conftest*
15080   eval "ac_cv_func_$ac_func=no"
15081 fi
15082 rm -f conftest*
15083 fi
15084
15085 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15086   echo "$ac_t""yes" 1>&6
15087     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15088   cat >> confdefs.h <<EOF
15089 #define $ac_tr_func 1
15090 EOF
15091
15092 else
15093   echo "$ac_t""no" 1>&6
15094 fi
15095 done
15096
15097   fi
15098
15099
15100
15101   ac_ext=C
15102 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15103 ac_cpp='$CXXCPP $CPPFLAGS'
15104 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15105 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15106 cross_compiling=$ac_cv_prog_cxx_cross
15107
15108   echo $ac_n "checking for _tanl declaration""... $ac_c" 1>&6
15109 echo "configure:15110: checking for _tanl declaration" >&5
15110   cat > conftest.$ac_ext <<EOF
15111 #line 15112 "configure"
15112 #include "confdefs.h"
15113 #include <math.h>
15114 int main() {
15115  _tanl(0);
15116 ; return 0; }
15117 EOF
15118 if { (eval echo configure:15119: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15119   rm -rf conftest*
15120   use__tanl=yes
15121 else
15122   echo "configure: failed program was:" >&5
15123   cat conftest.$ac_ext >&5
15124   rm -rf conftest*
15125   use__tanl=no
15126 fi
15127 rm -f conftest*
15128   echo "$ac_t""$use__tanl" 1>&6
15129   ac_ext=c
15130 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15131 ac_cpp='$CPP $CPPFLAGS'
15132 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15133 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15134 cross_compiling=$ac_cv_prog_cc_cross
15135
15136   if test x$use__tanl = x"yes"; then
15137     for ac_func in _tanl
15138 do
15139 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15140 echo "configure:15141: checking for $ac_func" >&5
15141 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15142   echo $ac_n "(cached) $ac_c" 1>&6
15143 else
15144   cat > conftest.$ac_ext <<EOF
15145 #line 15146 "configure"
15146 #include "confdefs.h"
15147 /* System header to define __stub macros and hopefully few prototypes,
15148     which can conflict with char $ac_func(); below.  */
15149 #include <assert.h>
15150 /* Override any gcc2 internal prototype to avoid an error.  */
15151 /* We use char because int might match the return type of a gcc2
15152     builtin and then its argument prototype would still apply.  */
15153 char $ac_func();
15154
15155 int main() {
15156
15157 /* The GNU C library defines this for functions which it implements
15158     to always fail with ENOSYS.  Some functions are actually named
15159     something starting with __ and the normal name is an alias.  */
15160 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15161 choke me
15162 #else
15163 $ac_func();
15164 #endif
15165
15166 ; return 0; }
15167 EOF
15168 if { (eval echo configure:15169: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15169   rm -rf conftest*
15170   eval "ac_cv_func_$ac_func=yes"
15171 else
15172   echo "configure: failed program was:" >&5
15173   cat conftest.$ac_ext >&5
15174   rm -rf conftest*
15175   eval "ac_cv_func_$ac_func=no"
15176 fi
15177 rm -f conftest*
15178 fi
15179
15180 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15181   echo "$ac_t""yes" 1>&6
15182     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15183   cat >> confdefs.h <<EOF
15184 #define $ac_tr_func 1
15185 EOF
15186
15187 else
15188   echo "$ac_t""no" 1>&6
15189 fi
15190 done
15191
15192   fi
15193
15194
15195
15196   ac_ext=C
15197 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15198 ac_cpp='$CXXCPP $CPPFLAGS'
15199 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15200 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15201 cross_compiling=$ac_cv_prog_cxx_cross
15202
15203   echo $ac_n "checking for _tanhl declaration""... $ac_c" 1>&6
15204 echo "configure:15205: checking for _tanhl declaration" >&5
15205   cat > conftest.$ac_ext <<EOF
15206 #line 15207 "configure"
15207 #include "confdefs.h"
15208 #include <math.h>
15209 int main() {
15210  _tanhl(0);
15211 ; return 0; }
15212 EOF
15213 if { (eval echo configure:15214: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15214   rm -rf conftest*
15215   use__tanhl=yes
15216 else
15217   echo "configure: failed program was:" >&5
15218   cat conftest.$ac_ext >&5
15219   rm -rf conftest*
15220   use__tanhl=no
15221 fi
15222 rm -f conftest*
15223   echo "$ac_t""$use__tanhl" 1>&6
15224   ac_ext=c
15225 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15226 ac_cpp='$CPP $CPPFLAGS'
15227 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15228 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15229 cross_compiling=$ac_cv_prog_cc_cross
15230
15231   if test x$use__tanhl = x"yes"; then
15232     for ac_func in _tanhl
15233 do
15234 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15235 echo "configure:15236: checking for $ac_func" >&5
15236 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15237   echo $ac_n "(cached) $ac_c" 1>&6
15238 else
15239   cat > conftest.$ac_ext <<EOF
15240 #line 15241 "configure"
15241 #include "confdefs.h"
15242 /* System header to define __stub macros and hopefully few prototypes,
15243     which can conflict with char $ac_func(); below.  */
15244 #include <assert.h>
15245 /* Override any gcc2 internal prototype to avoid an error.  */
15246 /* We use char because int might match the return type of a gcc2
15247     builtin and then its argument prototype would still apply.  */
15248 char $ac_func();
15249
15250 int main() {
15251
15252 /* The GNU C library defines this for functions which it implements
15253     to always fail with ENOSYS.  Some functions are actually named
15254     something starting with __ and the normal name is an alias.  */
15255 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15256 choke me
15257 #else
15258 $ac_func();
15259 #endif
15260
15261 ; return 0; }
15262 EOF
15263 if { (eval echo configure:15264: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15264   rm -rf conftest*
15265   eval "ac_cv_func_$ac_func=yes"
15266 else
15267   echo "configure: failed program was:" >&5
15268   cat conftest.$ac_ext >&5
15269   rm -rf conftest*
15270   eval "ac_cv_func_$ac_func=no"
15271 fi
15272 rm -f conftest*
15273 fi
15274
15275 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15276   echo "$ac_t""yes" 1>&6
15277     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15278   cat >> confdefs.h <<EOF
15279 #define $ac_tr_func 1
15280 EOF
15281
15282 else
15283   echo "$ac_t""no" 1>&6
15284 fi
15285 done
15286
15287   fi
15288
15289
15290
15291   ac_ext=C
15292 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15293 ac_cpp='$CXXCPP $CPPFLAGS'
15294 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15295 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15296 cross_compiling=$ac_cv_prog_cxx_cross
15297
15298   echo $ac_n "checking for _sincosl declaration""... $ac_c" 1>&6
15299 echo "configure:15300: checking for _sincosl declaration" >&5
15300   cat > conftest.$ac_ext <<EOF
15301 #line 15302 "configure"
15302 #include "confdefs.h"
15303 #include <math.h>
15304 int main() {
15305  _sincosl(0, 0, 0);
15306 ; return 0; }
15307 EOF
15308 if { (eval echo configure:15309: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15309   rm -rf conftest*
15310   use__sincosl=yes
15311 else
15312   echo "configure: failed program was:" >&5
15313   cat conftest.$ac_ext >&5
15314   rm -rf conftest*
15315   use__sincosl=no
15316 fi
15317 rm -f conftest*
15318   echo "$ac_t""$use__sincosl" 1>&6
15319   ac_ext=c
15320 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15321 ac_cpp='$CPP $CPPFLAGS'
15322 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15323 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15324 cross_compiling=$ac_cv_prog_cc_cross
15325
15326   if test x$use__sincosl = x"yes"; then
15327     for ac_func in _sincosl
15328 do
15329 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15330 echo "configure:15331: checking for $ac_func" >&5
15331 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15332   echo $ac_n "(cached) $ac_c" 1>&6
15333 else
15334   cat > conftest.$ac_ext <<EOF
15335 #line 15336 "configure"
15336 #include "confdefs.h"
15337 /* System header to define __stub macros and hopefully few prototypes,
15338     which can conflict with char $ac_func(); below.  */
15339 #include <assert.h>
15340 /* Override any gcc2 internal prototype to avoid an error.  */
15341 /* We use char because int might match the return type of a gcc2
15342     builtin and then its argument prototype would still apply.  */
15343 char $ac_func();
15344
15345 int main() {
15346
15347 /* The GNU C library defines this for functions which it implements
15348     to always fail with ENOSYS.  Some functions are actually named
15349     something starting with __ and the normal name is an alias.  */
15350 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15351 choke me
15352 #else
15353 $ac_func();
15354 #endif
15355
15356 ; return 0; }
15357 EOF
15358 if { (eval echo configure:15359: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15359   rm -rf conftest*
15360   eval "ac_cv_func_$ac_func=yes"
15361 else
15362   echo "configure: failed program was:" >&5
15363   cat conftest.$ac_ext >&5
15364   rm -rf conftest*
15365   eval "ac_cv_func_$ac_func=no"
15366 fi
15367 rm -f conftest*
15368 fi
15369
15370 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15371   echo "$ac_t""yes" 1>&6
15372     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15373   cat >> confdefs.h <<EOF
15374 #define $ac_tr_func 1
15375 EOF
15376
15377 else
15378   echo "$ac_t""no" 1>&6
15379 fi
15380 done
15381
15382   fi
15383
15384
15385
15386   ac_ext=C
15387 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15388 ac_cpp='$CXXCPP $CPPFLAGS'
15389 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15390 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15391 cross_compiling=$ac_cv_prog_cxx_cross
15392
15393   echo $ac_n "checking for _finitel declaration""... $ac_c" 1>&6
15394 echo "configure:15395: checking for _finitel declaration" >&5
15395   cat > conftest.$ac_ext <<EOF
15396 #line 15397 "configure"
15397 #include "confdefs.h"
15398 #include <math.h>
15399 int main() {
15400  _finitel(0);
15401 ; return 0; }
15402 EOF
15403 if { (eval echo configure:15404: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15404   rm -rf conftest*
15405   use__finitel=yes
15406 else
15407   echo "configure: failed program was:" >&5
15408   cat conftest.$ac_ext >&5
15409   rm -rf conftest*
15410   use__finitel=no
15411 fi
15412 rm -f conftest*
15413   echo "$ac_t""$use__finitel" 1>&6
15414   ac_ext=c
15415 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15416 ac_cpp='$CPP $CPPFLAGS'
15417 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15418 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15419 cross_compiling=$ac_cv_prog_cc_cross
15420
15421   if test x$use__finitel = x"yes"; then
15422     for ac_func in _finitel
15423 do
15424 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15425 echo "configure:15426: checking for $ac_func" >&5
15426 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15427   echo $ac_n "(cached) $ac_c" 1>&6
15428 else
15429   cat > conftest.$ac_ext <<EOF
15430 #line 15431 "configure"
15431 #include "confdefs.h"
15432 /* System header to define __stub macros and hopefully few prototypes,
15433     which can conflict with char $ac_func(); below.  */
15434 #include <assert.h>
15435 /* Override any gcc2 internal prototype to avoid an error.  */
15436 /* We use char because int might match the return type of a gcc2
15437     builtin and then its argument prototype would still apply.  */
15438 char $ac_func();
15439
15440 int main() {
15441
15442 /* The GNU C library defines this for functions which it implements
15443     to always fail with ENOSYS.  Some functions are actually named
15444     something starting with __ and the normal name is an alias.  */
15445 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15446 choke me
15447 #else
15448 $ac_func();
15449 #endif
15450
15451 ; return 0; }
15452 EOF
15453 if { (eval echo configure:15454: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15454   rm -rf conftest*
15455   eval "ac_cv_func_$ac_func=yes"
15456 else
15457   echo "configure: failed program was:" >&5
15458   cat conftest.$ac_ext >&5
15459   rm -rf conftest*
15460   eval "ac_cv_func_$ac_func=no"
15461 fi
15462 rm -f conftest*
15463 fi
15464
15465 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15466   echo "$ac_t""yes" 1>&6
15467     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15468   cat >> confdefs.h <<EOF
15469 #define $ac_tr_func 1
15470 EOF
15471
15472 else
15473   echo "$ac_t""no" 1>&6
15474 fi
15475 done
15476
15477   fi
15478
15479
15480   LIBS="$ac_save_LIBS"
15481   CXXFLAGS="$ac_save_CXXFLAGS"
15482
15483
15484     for ac_hdr in complex.h
15485 do
15486 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
15487 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
15488 echo "configure:15489: checking for $ac_hdr" >&5
15489 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
15490   echo $ac_n "(cached) $ac_c" 1>&6
15491 else
15492   cat > conftest.$ac_ext <<EOF
15493 #line 15494 "configure"
15494 #include "confdefs.h"
15495 #include <$ac_hdr>
15496 EOF
15497 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
15498 { (eval echo configure:15499: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
15499 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
15500 if test -z "$ac_err"; then
15501   rm -rf conftest*
15502   eval "ac_cv_header_$ac_safe=yes"
15503 else
15504   echo "$ac_err" >&5
15505   echo "configure: failed program was:" >&5
15506   cat conftest.$ac_ext >&5
15507   rm -rf conftest*
15508   eval "ac_cv_header_$ac_safe=no"
15509 fi
15510 rm -f conftest*
15511 fi
15512 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
15513   echo "$ac_t""yes" 1>&6
15514     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
15515   cat >> confdefs.h <<EOF
15516 #define $ac_tr_hdr 1
15517 EOF
15518
15519 else
15520   echo "$ac_t""no" 1>&6
15521 fi
15522 done
15523
15524   for ac_func in ccos ccosf ccosh ccoshf cexp cexpf c_log c_logf \
15525   clog10 clog10f cpow cpowf csin csinf csinh csinhf csqrt csqrtf \
15526   ctan ctanf ctanh ctanhf carg cargf nan hypot hypotf atan2f expf copysignf
15527 do
15528 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15529 echo "configure:15530: checking for $ac_func" >&5
15530 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15531   echo $ac_n "(cached) $ac_c" 1>&6
15532 else
15533   cat > conftest.$ac_ext <<EOF
15534 #line 15535 "configure"
15535 #include "confdefs.h"
15536 /* System header to define __stub macros and hopefully few prototypes,
15537     which can conflict with char $ac_func(); below.  */
15538 #include <assert.h>
15539 /* Override any gcc2 internal prototype to avoid an error.  */
15540 /* We use char because int might match the return type of a gcc2
15541     builtin and then its argument prototype would still apply.  */
15542 char $ac_func();
15543
15544 int main() {
15545
15546 /* The GNU C library defines this for functions which it implements
15547     to always fail with ENOSYS.  Some functions are actually named
15548     something starting with __ and the normal name is an alias.  */
15549 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15550 choke me
15551 #else
15552 $ac_func();
15553 #endif
15554
15555 ; return 0; }
15556 EOF
15557 if { (eval echo configure:15558: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15558   rm -rf conftest*
15559   eval "ac_cv_func_$ac_func=yes"
15560 else
15561   echo "configure: failed program was:" >&5
15562   cat conftest.$ac_ext >&5
15563   rm -rf conftest*
15564   eval "ac_cv_func_$ac_func=no"
15565 fi
15566 rm -f conftest*
15567 fi
15568
15569 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15570   echo "$ac_t""yes" 1>&6
15571     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15572   cat >> confdefs.h <<EOF
15573 #define $ac_tr_func 1
15574 EOF
15575
15576 else
15577   echo "$ac_t""no" 1>&6
15578 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
15579 fi
15580 done
15581
15582
15583
15584           USE_COMPLEX_LONG_DOUBLE=no
15585   if test x$ac_cv_func_atan2l = x"yes" \
15586      && test x$ac_cv_func_copysignl = x"yes"; then
15587     USE_COMPLEX_LONG_DOUBLE=yes
15588     for ac_func in ccoshl ccosl cexpl cpowl csinhl csinl \
15589     csqrtl ctanhl ctanl cargl hypotl signbitl c_logl clog10l
15590 do
15591 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15592 echo "configure:15593: checking for $ac_func" >&5
15593 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15594   echo $ac_n "(cached) $ac_c" 1>&6
15595 else
15596   cat > conftest.$ac_ext <<EOF
15597 #line 15598 "configure"
15598 #include "confdefs.h"
15599 /* System header to define __stub macros and hopefully few prototypes,
15600     which can conflict with char $ac_func(); below.  */
15601 #include <assert.h>
15602 /* Override any gcc2 internal prototype to avoid an error.  */
15603 /* We use char because int might match the return type of a gcc2
15604     builtin and then its argument prototype would still apply.  */
15605 char $ac_func();
15606
15607 int main() {
15608
15609 /* The GNU C library defines this for functions which it implements
15610     to always fail with ENOSYS.  Some functions are actually named
15611     something starting with __ and the normal name is an alias.  */
15612 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15613 choke me
15614 #else
15615 $ac_func();
15616 #endif
15617
15618 ; return 0; }
15619 EOF
15620 if { (eval echo configure:15621: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15621   rm -rf conftest*
15622   eval "ac_cv_func_$ac_func=yes"
15623 else
15624   echo "configure: failed program was:" >&5
15625   cat conftest.$ac_ext >&5
15626   rm -rf conftest*
15627   eval "ac_cv_func_$ac_func=no"
15628 fi
15629 rm -f conftest*
15630 fi
15631
15632 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15633   echo "$ac_t""yes" 1>&6
15634     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15635   cat >> confdefs.h <<EOF
15636 #define $ac_tr_func 1
15637 EOF
15638
15639 else
15640   echo "$ac_t""no" 1>&6
15641 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
15642 fi
15643 done
15644
15645
15646   fi
15647
15648
15649
15650
15651
15652
15653   echo $ac_n "checking for GNU C++ __complex__ support""... $ac_c" 1>&6
15654 echo "configure:15655: checking for GNU C++ __complex__ support" >&5
15655   if eval "test \"`echo '$''{'glibcpp_cv_complex'+set}'`\" = set"; then
15656   echo $ac_n "(cached) $ac_c" 1>&6
15657 else
15658
15659
15660     ac_ext=C
15661 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15662 ac_cpp='$CXXCPP $CPPFLAGS'
15663 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15664 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15665 cross_compiling=$ac_cv_prog_cxx_cross
15666
15667     cat > conftest.$ac_ext <<EOF
15668 #line 15669 "configure"
15669 #include "confdefs.h"
15670 struct dcomplex { __complex__ double x; }; \
15671                     dcomplex f(const dcomplex& x) { return dcomplex(x); }
15672 int main() {
15673 \
15674                      dcomplex x; f(x);
15675 ; return 0; }
15676 EOF
15677 if { (eval echo configure:15678: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15678   rm -rf conftest*
15679   glibcpp_cv_complex=ok
15680 else
15681   echo "configure: failed program was:" >&5
15682   cat conftest.$ac_ext >&5
15683   rm -rf conftest*
15684   glibcpp_cv_complex=buggy
15685
15686 fi
15687 rm -f conftest*
15688     ac_ext=c
15689 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15690 ac_cpp='$CPP $CPPFLAGS'
15691 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15692 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15693 cross_compiling=$ac_cv_prog_cc_cross
15694
15695
15696 fi
15697
15698   echo "$ac_t""$glibcpp_cv_complex" 1>&6
15699   if test $glibcpp_cv_complex = buggy; then
15700     cat >> confdefs.h <<\EOF
15701 #define _GLIBCPP_BUGGY_COMPLEX 1
15702 EOF
15703
15704   fi
15705
15706   echo $ac_n "checking for GNU C++ __complex__ float support""... $ac_c" 1>&6
15707 echo "configure:15708: checking for GNU C++ __complex__ float support" >&5
15708   if eval "test \"`echo '$''{'glibcpp_cv_float_complex'+set}'`\" = set"; then
15709   echo $ac_n "(cached) $ac_c" 1>&6
15710 else
15711
15712
15713     ac_ext=C
15714 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15715 ac_cpp='$CXXCPP $CPPFLAGS'
15716 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15717 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15718 cross_compiling=$ac_cv_prog_cxx_cross
15719
15720     rm -f conftest.h
15721     cat > conftest.h <<EOB
15722       //
15723       // Check for buggy __complex__ that causes ICE in most versions of egcs
15724       // and gcc-2.95.x on certain platforms (eg., x86-win32).
15725       //
15726       // See http://egcs.cygnus.com/ml/gcc-bugs/1999-07/msg00845.html for
15727       // more info on the bug itself.
15728       //
15729       struct
15730       float_complex
15731       {
15732        __complex__ float m_value;
15733        float_complex (float = 0.0f, float = 0.0f);
15734        float_complex (__complex__ float val) : m_value (val) {}
15735        float_complex foo (const float_complex &val)
15736          { return float_complex (~val.m_value); }
15737       };
15738 EOB
15739     cat > conftest.$ac_ext <<EOF
15740 #line 15741 "configure"
15741 #include "confdefs.h"
15742 #include "conftest.h"
15743 int main() {
15744
15745 ; return 0; }
15746 EOF
15747 if { (eval echo configure:15748: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15748   rm -rf conftest*
15749   glibcpp_cv_float_complex=ok
15750 else
15751   echo "configure: failed program was:" >&5
15752   cat conftest.$ac_ext >&5
15753   rm -rf conftest*
15754   glibcpp_cv_float_complex=buggy
15755
15756 fi
15757 rm -f conftest*
15758     ac_ext=c
15759 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15760 ac_cpp='$CPP $CPPFLAGS'
15761 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15762 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15763 cross_compiling=$ac_cv_prog_cc_cross
15764
15765
15766 fi
15767
15768   echo "$ac_t""$glibcpp_cv_float_complex" 1>&6
15769   if test $glibcpp_cv_float_complex = buggy; then
15770     cat >> confdefs.h <<\EOF
15771 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
15772 EOF
15773
15774   fi
15775
15776
15777
15778     ac_safe=`echo "wchar.h" | sed 'y%./+-%__p_%'`
15779 echo $ac_n "checking for wchar.h""... $ac_c" 1>&6
15780 echo "configure:15781: checking for wchar.h" >&5
15781 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
15782   echo $ac_n "(cached) $ac_c" 1>&6
15783 else
15784   cat > conftest.$ac_ext <<EOF
15785 #line 15786 "configure"
15786 #include "confdefs.h"
15787 #include <wchar.h>
15788 EOF
15789 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
15790 { (eval echo configure:15791: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
15791 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
15792 if test -z "$ac_err"; then
15793   rm -rf conftest*
15794   eval "ac_cv_header_$ac_safe=yes"
15795 else
15796   echo "$ac_err" >&5
15797   echo "configure: failed program was:" >&5
15798   cat conftest.$ac_ext >&5
15799   rm -rf conftest*
15800   eval "ac_cv_header_$ac_safe=no"
15801 fi
15802 rm -f conftest*
15803 fi
15804 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
15805   echo "$ac_t""yes" 1>&6
15806   ac_has_wchar_h=yes
15807 else
15808   echo "$ac_t""no" 1>&6
15809 ac_has_wchar_h=no
15810 fi
15811
15812   ac_safe=`echo "wctype.h" | sed 'y%./+-%__p_%'`
15813 echo $ac_n "checking for wctype.h""... $ac_c" 1>&6
15814 echo "configure:15815: checking for wctype.h" >&5
15815 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
15816   echo $ac_n "(cached) $ac_c" 1>&6
15817 else
15818   cat > conftest.$ac_ext <<EOF
15819 #line 15820 "configure"
15820 #include "confdefs.h"
15821 #include <wctype.h>
15822 EOF
15823 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
15824 { (eval echo configure:15825: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
15825 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
15826 if test -z "$ac_err"; then
15827   rm -rf conftest*
15828   eval "ac_cv_header_$ac_safe=yes"
15829 else
15830   echo "$ac_err" >&5
15831   echo "configure: failed program was:" >&5
15832   cat conftest.$ac_ext >&5
15833   rm -rf conftest*
15834   eval "ac_cv_header_$ac_safe=no"
15835 fi
15836 rm -f conftest*
15837 fi
15838 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
15839   echo "$ac_t""yes" 1>&6
15840   ac_has_wctype_h=yes
15841 else
15842   echo "$ac_t""no" 1>&6
15843 ac_has_wctype_h=no
15844 fi
15845
15846
15847     if test x"$ac_has_wchar_h" = xyes && test x"$ac_has_wctype_h" = xyes; then
15848
15849         echo $ac_n "checking for mbstate_t""... $ac_c" 1>&6
15850 echo "configure:15851: checking for mbstate_t" >&5
15851     cat > conftest.$ac_ext <<EOF
15852 #line 15853 "configure"
15853 #include "confdefs.h"
15854 #include <wchar.h>
15855 int main() {
15856 mbstate_t teststate;
15857 ; return 0; }
15858 EOF
15859 if { (eval echo configure:15860: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15860   rm -rf conftest*
15861   use_native_mbstatet=yes
15862 else
15863   echo "configure: failed program was:" >&5
15864   cat conftest.$ac_ext >&5
15865   rm -rf conftest*
15866   use_native_mbstatet=no
15867 fi
15868 rm -f conftest*
15869     echo "$ac_t""$use_native_mbstatet" 1>&6
15870     if test x"$use_native_mbstatet" = xno; then
15871       cat >> confdefs.h <<\EOF
15872 #define _GLIBCPP_NEED_MBSTATE_T 1
15873 EOF
15874
15875     fi
15876
15877             echo $ac_n "checking for WCHAR_MIN and WCHAR_MAX""... $ac_c" 1>&6
15878 echo "configure:15879: checking for WCHAR_MIN and WCHAR_MAX" >&5
15879     cat > conftest.$ac_ext <<EOF
15880 #line 15881 "configure"
15881 #include "confdefs.h"
15882 #include <wchar.h>
15883 int main() {
15884 int i = WCHAR_MIN; int j = WCHAR_MAX;
15885 ; return 0; }
15886 EOF
15887 if { (eval echo configure:15888: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15888   rm -rf conftest*
15889   has_wchar_minmax=yes
15890 else
15891   echo "configure: failed program was:" >&5
15892   cat conftest.$ac_ext >&5
15893   rm -rf conftest*
15894   has_wchar_minmax=no
15895 fi
15896 rm -f conftest*
15897     echo "$ac_t""$has_wchar_minmax" 1>&6
15898
15899             echo $ac_n "checking for WEOF""... $ac_c" 1>&6
15900 echo "configure:15901: checking for WEOF" >&5
15901     cat > conftest.$ac_ext <<EOF
15902 #line 15903 "configure"
15903 #include "confdefs.h"
15904
15905       #include <wchar.h>
15906       #include <stddef.h>
15907 int main() {
15908 wint_t i = WEOF;
15909 ; return 0; }
15910 EOF
15911 if { (eval echo configure:15912: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15912   rm -rf conftest*
15913   has_weof=yes
15914 else
15915   echo "configure: failed program was:" >&5
15916   cat conftest.$ac_ext >&5
15917   rm -rf conftest*
15918   has_weof=no
15919 fi
15920 rm -f conftest*
15921     echo "$ac_t""$has_weof" 1>&6
15922
15923         for ac_func in wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset
15924 do
15925 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15926 echo "configure:15927: checking for $ac_func" >&5
15927 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15928   echo $ac_n "(cached) $ac_c" 1>&6
15929 else
15930   cat > conftest.$ac_ext <<EOF
15931 #line 15932 "configure"
15932 #include "confdefs.h"
15933 /* System header to define __stub macros and hopefully few prototypes,
15934     which can conflict with char $ac_func(); below.  */
15935 #include <assert.h>
15936 /* Override any gcc2 internal prototype to avoid an error.  */
15937 /* We use char because int might match the return type of a gcc2
15938     builtin and then its argument prototype would still apply.  */
15939 char $ac_func();
15940
15941 int main() {
15942
15943 /* The GNU C library defines this for functions which it implements
15944     to always fail with ENOSYS.  Some functions are actually named
15945     something starting with __ and the normal name is an alias.  */
15946 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15947 choke me
15948 #else
15949 $ac_func();
15950 #endif
15951
15952 ; return 0; }
15953 EOF
15954 if { (eval echo configure:15955: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15955   rm -rf conftest*
15956   eval "ac_cv_func_$ac_func=yes"
15957 else
15958   echo "configure: failed program was:" >&5
15959   cat conftest.$ac_ext >&5
15960   rm -rf conftest*
15961   eval "ac_cv_func_$ac_func=no"
15962 fi
15963 rm -f conftest*
15964 fi
15965
15966 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15967   echo "$ac_t""yes" 1>&6
15968     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15969   cat >> confdefs.h <<EOF
15970 #define $ac_tr_func 1
15971 EOF
15972  ac_wfuncs=yes
15973 else
15974   echo "$ac_t""no" 1>&6
15975 ac_wfuncs=no
15976 fi
15977 done
15978
15979
15980     echo $ac_n "checking for ISO C9X wchar_t support""... $ac_c" 1>&6
15981 echo "configure:15982: checking for ISO C9X wchar_t support" >&5
15982     if test x"$has_weof" = xyes && test x"$has_wchar_minmax" = xyes && test x"$ac_wfuncs" = xyes; then
15983       ac_isoC9X_wchar_t=yes
15984     else
15985       ac_isoC9X_wchar_t=no
15986     fi
15987     echo "$ac_t""$ac_isoC9X_wchar_t" 1>&6
15988
15989             ac_safe=`echo "iconv.h" | sed 'y%./+-%__p_%'`
15990 echo $ac_n "checking for iconv.h""... $ac_c" 1>&6
15991 echo "configure:15992: checking for iconv.h" >&5
15992 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
15993   echo $ac_n "(cached) $ac_c" 1>&6
15994 else
15995   cat > conftest.$ac_ext <<EOF
15996 #line 15997 "configure"
15997 #include "confdefs.h"
15998 #include <iconv.h>
15999 EOF
16000 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
16001 { (eval echo configure:16002: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
16002 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
16003 if test -z "$ac_err"; then
16004   rm -rf conftest*
16005   eval "ac_cv_header_$ac_safe=yes"
16006 else
16007   echo "$ac_err" >&5
16008   echo "configure: failed program was:" >&5
16009   cat conftest.$ac_ext >&5
16010   rm -rf conftest*
16011   eval "ac_cv_header_$ac_safe=no"
16012 fi
16013 rm -f conftest*
16014 fi
16015 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
16016   echo "$ac_t""yes" 1>&6
16017   ac_has_iconv_h=yes
16018 else
16019   echo "$ac_t""no" 1>&6
16020 ac_has_iconv_h=no
16021 fi
16022
16023     for ac_func in iconv_open iconv_close iconv
16024 do
16025 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16026 echo "configure:16027: checking for $ac_func" >&5
16027 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16028   echo $ac_n "(cached) $ac_c" 1>&6
16029 else
16030   cat > conftest.$ac_ext <<EOF
16031 #line 16032 "configure"
16032 #include "confdefs.h"
16033 /* System header to define __stub macros and hopefully few prototypes,
16034     which can conflict with char $ac_func(); below.  */
16035 #include <assert.h>
16036 /* Override any gcc2 internal prototype to avoid an error.  */
16037 /* We use char because int might match the return type of a gcc2
16038     builtin and then its argument prototype would still apply.  */
16039 char $ac_func();
16040
16041 int main() {
16042
16043 /* The GNU C library defines this for functions which it implements
16044     to always fail with ENOSYS.  Some functions are actually named
16045     something starting with __ and the normal name is an alias.  */
16046 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16047 choke me
16048 #else
16049 $ac_func();
16050 #endif
16051
16052 ; return 0; }
16053 EOF
16054 if { (eval echo configure:16055: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16055   rm -rf conftest*
16056   eval "ac_cv_func_$ac_func=yes"
16057 else
16058   echo "configure: failed program was:" >&5
16059   cat conftest.$ac_ext >&5
16060   rm -rf conftest*
16061   eval "ac_cv_func_$ac_func=no"
16062 fi
16063 rm -f conftest*
16064 fi
16065
16066 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16067   echo "$ac_t""yes" 1>&6
16068     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16069   cat >> confdefs.h <<EOF
16070 #define $ac_tr_func 1
16071 EOF
16072  ac_XPG2funcs=yes
16073 else
16074   echo "$ac_t""no" 1>&6
16075 ac_XPG2funcs=no
16076 fi
16077 done
16078
16079
16080     echo $ac_n "checking for XPG2 wchar_t support""... $ac_c" 1>&6
16081 echo "configure:16082: checking for XPG2 wchar_t support" >&5
16082     if test x"$ac_has_iconv_h" = xyes && test x"$ac_XPG2funcs" = xyes; then
16083       ac_XPG2_wchar_t=yes
16084     else
16085       ac_XPG2_wchar_t=no
16086     fi
16087     echo "$ac_t""$ac_XPG2_wchar_t" 1>&6
16088
16089             echo $ac_n "checking for enabled wchar_t specializations""... $ac_c" 1>&6
16090 echo "configure:16091: checking for enabled wchar_t specializations" >&5
16091     if test x"$ac_isoC9X_wchar_t" = xyes && test x"$ac_XPG2_wchar_t" = xyes; then
16092       libinst_wstring_la="libinst-wstring.la"
16093       cat >> confdefs.h <<\EOF
16094 #define _GLIBCPP_USE_WCHAR_T 1
16095 EOF
16096
16097       echo "$ac_t"""yes"" 1>&6
16098     else
16099       libinst_wstring_la=""
16100       echo "$ac_t"""no"" 1>&6
16101     fi
16102
16103
16104   else
16105     echo "configure: warning: <wchar.h> not found" 1>&2
16106     cat >> confdefs.h <<\EOF
16107 #define _GLIBCPP_NEED_MBSTATE_T 1
16108 EOF
16109
16110   fi
16111
16112
16113   ac_safe=`echo "ctype.h" | sed 'y%./+-%__p_%'`
16114 echo $ac_n "checking for ctype.h""... $ac_c" 1>&6
16115 echo "configure:16116: checking for ctype.h" >&5
16116 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
16117   echo $ac_n "(cached) $ac_c" 1>&6
16118 else
16119   cat > conftest.$ac_ext <<EOF
16120 #line 16121 "configure"
16121 #include "confdefs.h"
16122 #include <ctype.h>
16123 EOF
16124 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
16125 { (eval echo configure:16126: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
16126 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
16127 if test -z "$ac_err"; then
16128   rm -rf conftest*
16129   eval "ac_cv_header_$ac_safe=yes"
16130 else
16131   echo "$ac_err" >&5
16132   echo "configure: failed program was:" >&5
16133   cat conftest.$ac_ext >&5
16134   rm -rf conftest*
16135   eval "ac_cv_header_$ac_safe=no"
16136 fi
16137 rm -f conftest*
16138 fi
16139 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
16140   echo "$ac_t""yes" 1>&6
16141
16142
16143         ctype_default=yes
16144
16145         echo $ac_n "checking <ctype> for gnu-linux ""... $ac_c" 1>&6
16146 echo "configure:16147: checking <ctype> for gnu-linux " >&5
16147     cat > conftest.$ac_ext <<EOF
16148 #line 16149 "configure"
16149 #include "confdefs.h"
16150 #include <ctype.h>
16151 int main() {
16152 int
16153     foo (int a)
16154     { return _ISspace + _ISprint + _IScntrl + _ISupper + _ISlower + _ISalpha \
16155         + _ISdigit + _ISpunct + _ISxdigit + _ISalnum + _ISgraph \
16156         + __ctype_tolower[a] + __ctype_toupper[a] + __ctype_b[a];}
16157 ; return 0; }
16158 EOF
16159 if { (eval echo configure:16160: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16160   rm -rf conftest*
16161   \
16162     ctype_linux=yes
16163 else
16164   echo "configure: failed program was:" >&5
16165   cat conftest.$ac_ext >&5
16166   rm -rf conftest*
16167   ctype_linux=no
16168 fi
16169 rm -f conftest*
16170     echo "$ac_t""$ctype_linux" 1>&6
16171     if test $ctype_linux = "yes"; then
16172       ctype_include_dir="config/gnu-linux"
16173       ctype_default=no
16174     fi
16175
16176         if test $ctype_default = "yes"; then
16177     echo $ac_n "checking <ctype> for freebsd 4.0 ""... $ac_c" 1>&6
16178 echo "configure:16179: checking <ctype> for freebsd 4.0 " >&5
16179     cat > conftest.$ac_ext <<EOF
16180 #line 16181 "configure"
16181 #include "confdefs.h"
16182 #include <ctype.h>
16183 int main() {
16184 int
16185     foo (int a)
16186     { return _CTYPE_S + _CTYPE_R + _CTYPE_C + _CTYPE_U + _CTYPE_L + _CTYPE_A \
16187         + _CTYPE_D + _CTYPE_P + _CTYPE_X + _CTYPE_G ;}
16188 ; return 0; }
16189 EOF
16190 if { (eval echo configure:16191: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16191   rm -rf conftest*
16192   \
16193     ctype_bsd=yes
16194 else
16195   echo "configure: failed program was:" >&5
16196   cat conftest.$ac_ext >&5
16197   rm -rf conftest*
16198   ctype_bsd=no
16199 fi
16200 rm -f conftest*
16201     echo "$ac_t""$ctype_bsd" 1>&6
16202     if test $ctype_bsd = "yes"; then
16203       ctype_include_dir="config/bsd"
16204       ctype_default=no
16205     fi
16206     fi
16207
16208         if test $ctype_default = "yes"; then
16209     echo $ac_n "checking <ctype> for freebsd 3.4 ""... $ac_c" 1>&6
16210 echo "configure:16211: checking <ctype> for freebsd 3.4 " >&5
16211     cat > conftest.$ac_ext <<EOF
16212 #line 16213 "configure"
16213 #include "confdefs.h"
16214 #include <ctype.h>
16215 int main() {
16216 int
16217     foo (int a)
16218     { return _S + _R + _C + _U + _L + _A \
16219       + _D + _P + _X + _G + __istype (a, 0);}
16220 ; return 0; }
16221 EOF
16222 if { (eval echo configure:16223: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16223   rm -rf conftest*
16224   \
16225     ctype_freebsd34=yes
16226 else
16227   echo "configure: failed program was:" >&5
16228   cat conftest.$ac_ext >&5
16229   rm -rf conftest*
16230   ctype_freebsd34=no
16231 fi
16232 rm -f conftest*
16233     echo "$ac_t""$ctype_freebsd34" 1>&6
16234     if test $ctype_freebsd34 = "yes"; then
16235       ctype_include_dir="config/bsd"
16236       ctype_default=no
16237     fi
16238     fi
16239
16240         if test $ctype_default = "yes"; then
16241     echo $ac_n "checking <ctype> for solaris 2.6,7,8 ""... $ac_c" 1>&6
16242 echo "configure:16243: checking <ctype> for solaris 2.6,7,8 " >&5
16243     cat > conftest.$ac_ext <<EOF
16244 #line 16245 "configure"
16245 #include "confdefs.h"
16246 #include <ctype.h>
16247 int main() {
16248 int
16249     foo (int a)
16250     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
16251         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
16252         + __trans_lower[a] + __trans_upper[a] + __ctype_mask[a];}
16253 ; return 0; }
16254 EOF
16255 if { (eval echo configure:16256: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16256   rm -rf conftest*
16257   \
16258     ctype_solaris=yes
16259 else
16260   echo "configure: failed program was:" >&5
16261   cat conftest.$ac_ext >&5
16262   rm -rf conftest*
16263   ctype_solaris=no
16264 fi
16265 rm -f conftest*
16266     echo "$ac_t""$ctype_solaris" 1>&6
16267
16268     if test $ctype_solaris = "yes"; then
16269       echo $ac_n "checking   for version""... $ac_c" 1>&6
16270 echo "configure:16271: checking   for version" >&5
16271       ac_ext=C
16272 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16273 ac_cpp='$CXXCPP $CPPFLAGS'
16274 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16275 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16276 cross_compiling=$ac_cv_prog_cxx_cross
16277
16278       cat > conftest.$ac_ext <<EOF
16279 #line 16280 "configure"
16280 #include "confdefs.h"
16281 #include <ctype.h>
16282 int main() {
16283 typedef long* __to_type; __to_type const& _M_toupper = __trans_upper;
16284 ; return 0; }
16285 EOF
16286 if { (eval echo configure:16287: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16287   rm -rf conftest*
16288   \
16289       ctype_solaris26=yes
16290 else
16291   echo "configure: failed program was:" >&5
16292   cat conftest.$ac_ext >&5
16293   rm -rf conftest*
16294   ctype_solaris26=no
16295 fi
16296 rm -f conftest*
16297       ac_ext=c
16298 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16299 ac_cpp='$CPP $CPPFLAGS'
16300 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16301 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16302 cross_compiling=$ac_cv_prog_cc_cross
16303
16304       if test $ctype_solaris26 = "yes"; then
16305         ctype_include_dir="config/solaris/solaris2.6"
16306         echo "$ac_t"""solaris2.6"" 1>&6
16307         ctype_default=no
16308       else
16309         ctype_include_dir="config/solaris/solaris2.7"
16310         echo "$ac_t"""solaris2.7,8"" 1>&6
16311         ctype_default=no
16312       fi
16313     fi
16314     fi
16315
16316         if test $ctype_default = "yes"; then
16317     echo $ac_n "checking <ctype> for solaris 2.5.1 ""... $ac_c" 1>&6
16318 echo "configure:16319: checking <ctype> for solaris 2.5.1 " >&5
16319     cat > conftest.$ac_ext <<EOF
16320 #line 16321 "configure"
16321 #include "confdefs.h"
16322 #include <ctype.h>
16323 int main() {
16324 int
16325     foo (int a)
16326     { return _U + _L + _N + _S + _P + _C + _X + _B \
16327         + __ctype[a];}
16328 ; return 0; }
16329 EOF
16330 if { (eval echo configure:16331: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16331   rm -rf conftest*
16332   \
16333     ctype_solaris25=yes
16334 else
16335   echo "configure: failed program was:" >&5
16336   cat conftest.$ac_ext >&5
16337   rm -rf conftest*
16338   ctype_solaris25=no
16339 fi
16340 rm -f conftest*
16341     echo "$ac_t""$ctype_solaris25" 1>&6
16342     if test $ctype_solaris25 = "yes"; then
16343       ctype_include_dir="config/solaris/solaris2.5"
16344       ctype_default=no
16345     fi
16346     fi
16347
16348         if test $ctype_default = "yes"; then
16349     echo $ac_n "checking <ctype> for aix ""... $ac_c" 1>&6
16350 echo "configure:16351: checking <ctype> for aix " >&5
16351     cat > conftest.$ac_ext <<EOF
16352 #line 16353 "configure"
16353 #include "confdefs.h"
16354 #include <ctype.h>
16355 int main() {
16356 int
16357     foo (int a)
16358     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
16359         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
16360         + _VALC('a') + _IS('c', 0);}
16361 ; return 0; }
16362 EOF
16363 if { (eval echo configure:16364: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16364   rm -rf conftest*
16365   \
16366     ctype_aix=yes
16367 else
16368   echo "configure: failed program was:" >&5
16369   cat conftest.$ac_ext >&5
16370   rm -rf conftest*
16371   ctype_aix=no
16372 fi
16373 rm -f conftest*
16374     echo "$ac_t""$ctype_aix" 1>&6
16375     if test $ctype_aix = "yes"; then
16376       ctype_include_dir="config/aix"
16377       ctype_default=no
16378     fi
16379     fi
16380
16381         if test $ctype_default = "yes"; then
16382     echo $ac_n "checking <ctype> for newlib ""... $ac_c" 1>&6
16383 echo "configure:16384: checking <ctype> for newlib " >&5
16384     cat > conftest.$ac_ext <<EOF
16385 #line 16386 "configure"
16386 #include "confdefs.h"
16387 #include <ctype.h>
16388 int main() {
16389 int
16390     foo (int a)
16391     { return _U + _L + _N + _S + _P + _C + _X + _B \
16392         + _ctype_[a];}
16393 ; return 0; }
16394 EOF
16395 if { (eval echo configure:16396: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16396   rm -rf conftest*
16397   \
16398     ctype_newlib=yes
16399 else
16400   echo "configure: failed program was:" >&5
16401   cat conftest.$ac_ext >&5
16402   rm -rf conftest*
16403   ctype_newlib=no
16404 fi
16405 rm -f conftest*
16406     echo "$ac_t""$ctype_newlib" 1>&6
16407     if test $ctype_newlib = "yes"; then
16408       ctype_include_dir="config/newlib"
16409       ctype_default=no
16410     fi
16411     fi
16412
16413     if test $ctype_default = "yes"; then
16414       ctype_include_dir="config/generic"
16415       echo "configure: warning: "Using default ctype headers."" 1>&2
16416     fi
16417
16418
16419 else
16420   echo "$ac_t""no" 1>&6
16421 fi
16422
16423
16424
16425   for ac_hdr in unistd.h
16426 do
16427 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
16428 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
16429 echo "configure:16430: checking for $ac_hdr" >&5
16430 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
16431   echo $ac_n "(cached) $ac_c" 1>&6
16432 else
16433   cat > conftest.$ac_ext <<EOF
16434 #line 16435 "configure"
16435 #include "confdefs.h"
16436 #include <$ac_hdr>
16437 EOF
16438 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
16439 { (eval echo configure:16440: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
16440 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
16441 if test -z "$ac_err"; then
16442   rm -rf conftest*
16443   eval "ac_cv_header_$ac_safe=yes"
16444 else
16445   echo "$ac_err" >&5
16446   echo "configure: failed program was:" >&5
16447   cat conftest.$ac_ext >&5
16448   rm -rf conftest*
16449   eval "ac_cv_header_$ac_safe=no"
16450 fi
16451 rm -f conftest*
16452 fi
16453 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
16454   echo "$ac_t""yes" 1>&6
16455     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
16456   cat >> confdefs.h <<EOF
16457 #define $ac_tr_hdr 1
16458 EOF
16459
16460 else
16461   echo "$ac_t""no" 1>&6
16462 fi
16463 done
16464
16465 for ac_func in getpagesize
16466 do
16467 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16468 echo "configure:16469: checking for $ac_func" >&5
16469 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16470   echo $ac_n "(cached) $ac_c" 1>&6
16471 else
16472   cat > conftest.$ac_ext <<EOF
16473 #line 16474 "configure"
16474 #include "confdefs.h"
16475 /* System header to define __stub macros and hopefully few prototypes,
16476     which can conflict with char $ac_func(); below.  */
16477 #include <assert.h>
16478 /* Override any gcc2 internal prototype to avoid an error.  */
16479 /* We use char because int might match the return type of a gcc2
16480     builtin and then its argument prototype would still apply.  */
16481 char $ac_func();
16482
16483 int main() {
16484
16485 /* The GNU C library defines this for functions which it implements
16486     to always fail with ENOSYS.  Some functions are actually named
16487     something starting with __ and the normal name is an alias.  */
16488 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16489 choke me
16490 #else
16491 $ac_func();
16492 #endif
16493
16494 ; return 0; }
16495 EOF
16496 if { (eval echo configure:16497: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16497   rm -rf conftest*
16498   eval "ac_cv_func_$ac_func=yes"
16499 else
16500   echo "configure: failed program was:" >&5
16501   cat conftest.$ac_ext >&5
16502   rm -rf conftest*
16503   eval "ac_cv_func_$ac_func=no"
16504 fi
16505 rm -f conftest*
16506 fi
16507
16508 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16509   echo "$ac_t""yes" 1>&6
16510     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16511   cat >> confdefs.h <<EOF
16512 #define $ac_tr_func 1
16513 EOF
16514
16515 else
16516   echo "$ac_t""no" 1>&6
16517 fi
16518 done
16519
16520 echo $ac_n "checking for working mmap""... $ac_c" 1>&6
16521 echo "configure:16522: checking for working mmap" >&5
16522 if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then
16523   echo $ac_n "(cached) $ac_c" 1>&6
16524 else
16525   if test "$cross_compiling" = yes; then
16526   ac_cv_func_mmap_fixed_mapped=no
16527 else
16528   cat > conftest.$ac_ext <<EOF
16529 #line 16530 "configure"
16530 #include "confdefs.h"
16531
16532 /* Thanks to Mike Haertel and Jim Avera for this test.
16533    Here is a matrix of mmap possibilities:
16534         mmap private not fixed
16535         mmap private fixed at somewhere currently unmapped
16536         mmap private fixed at somewhere already mapped
16537         mmap shared not fixed
16538         mmap shared fixed at somewhere currently unmapped
16539         mmap shared fixed at somewhere already mapped
16540    For private mappings, we should verify that changes cannot be read()
16541    back from the file, nor mmap's back from the file at a different
16542    address.  (There have been systems where private was not correctly
16543    implemented like the infamous i386 svr4.0, and systems where the
16544    VM page cache was not coherent with the filesystem buffer cache
16545    like early versions of FreeBSD and possibly contemporary NetBSD.)
16546    For shared mappings, we should conversely verify that changes get
16547    propogated back to all the places they're supposed to be.
16548
16549    Grep wants private fixed already mapped.
16550    The main things grep needs to know about mmap are:
16551    * does it exist and is it safe to write into the mmap'd area
16552    * how to use it (BSD variants)  */
16553 #include <sys/types.h>
16554 #include <fcntl.h>
16555 #include <sys/mman.h>
16556
16557 /* This mess was copied from the GNU getpagesize.h.  */
16558 #ifndef HAVE_GETPAGESIZE
16559 # ifdef HAVE_UNISTD_H
16560 #  include <unistd.h>
16561 # endif
16562
16563 /* Assume that all systems that can run configure have sys/param.h.  */
16564 # ifndef HAVE_SYS_PARAM_H
16565 #  define HAVE_SYS_PARAM_H 1
16566 # endif
16567
16568 # ifdef _SC_PAGESIZE
16569 #  define getpagesize() sysconf(_SC_PAGESIZE)
16570 # else /* no _SC_PAGESIZE */
16571 #  ifdef HAVE_SYS_PARAM_H
16572 #   include <sys/param.h>
16573 #   ifdef EXEC_PAGESIZE
16574 #    define getpagesize() EXEC_PAGESIZE
16575 #   else /* no EXEC_PAGESIZE */
16576 #    ifdef NBPG
16577 #     define getpagesize() NBPG * CLSIZE
16578 #     ifndef CLSIZE
16579 #      define CLSIZE 1
16580 #     endif /* no CLSIZE */
16581 #    else /* no NBPG */
16582 #     ifdef NBPC
16583 #      define getpagesize() NBPC
16584 #     else /* no NBPC */
16585 #      ifdef PAGESIZE
16586 #       define getpagesize() PAGESIZE
16587 #      endif /* PAGESIZE */
16588 #     endif /* no NBPC */
16589 #    endif /* no NBPG */
16590 #   endif /* no EXEC_PAGESIZE */
16591 #  else /* no HAVE_SYS_PARAM_H */
16592 #   define getpagesize() 8192   /* punt totally */
16593 #  endif /* no HAVE_SYS_PARAM_H */
16594 # endif /* no _SC_PAGESIZE */
16595
16596 #endif /* no HAVE_GETPAGESIZE */
16597
16598 #ifdef __cplusplus
16599 extern "C" { void *malloc(unsigned); }
16600 #else
16601 char *malloc();
16602 #endif
16603
16604 int
16605 main()
16606 {
16607         char *data, *data2, *data3;
16608         int i, pagesize;
16609         int fd;
16610
16611         pagesize = getpagesize();
16612
16613         /*
16614          * First, make a file with some known garbage in it.
16615          */
16616         data = malloc(pagesize);
16617         if (!data)
16618                 exit(1);
16619         for (i = 0; i < pagesize; ++i)
16620                 *(data + i) = rand();
16621         umask(0);
16622         fd = creat("conftestmmap", 0600);
16623         if (fd < 0)
16624                 exit(1);
16625         if (write(fd, data, pagesize) != pagesize)
16626                 exit(1);
16627         close(fd);
16628
16629         /*
16630          * Next, try to mmap the file at a fixed address which
16631          * already has something else allocated at it.  If we can,
16632          * also make sure that we see the same garbage.
16633          */
16634         fd = open("conftestmmap", O_RDWR);
16635         if (fd < 0)
16636                 exit(1);
16637         data2 = malloc(2 * pagesize);
16638         if (!data2)
16639                 exit(1);
16640         data2 += (pagesize - ((int) data2 & (pagesize - 1))) & (pagesize - 1);
16641         if (data2 != mmap(data2, pagesize, PROT_READ | PROT_WRITE,
16642             MAP_PRIVATE | MAP_FIXED, fd, 0L))
16643                 exit(1);
16644         for (i = 0; i < pagesize; ++i)
16645                 if (*(data + i) != *(data2 + i))
16646                         exit(1);
16647
16648         /*
16649          * Finally, make sure that changes to the mapped area
16650          * do not percolate back to the file as seen by read().
16651          * (This is a bug on some variants of i386 svr4.0.)
16652          */
16653         for (i = 0; i < pagesize; ++i)
16654                 *(data2 + i) = *(data2 + i) + 1;
16655         data3 = malloc(pagesize);
16656         if (!data3)
16657                 exit(1);
16658         if (read(fd, data3, pagesize) != pagesize)
16659                 exit(1);
16660         for (i = 0; i < pagesize; ++i)
16661                 if (*(data + i) != *(data3 + i))
16662                         exit(1);
16663         close(fd);
16664         unlink("conftestmmap");
16665         exit(0);
16666 }
16667
16668 EOF
16669 if { (eval echo configure:16670: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
16670 then
16671   ac_cv_func_mmap_fixed_mapped=yes
16672 else
16673   echo "configure: failed program was:" >&5
16674   cat conftest.$ac_ext >&5
16675   rm -fr conftest*
16676   ac_cv_func_mmap_fixed_mapped=no
16677 fi
16678 rm -fr conftest*
16679 fi
16680
16681 fi
16682
16683 echo "$ac_t""$ac_cv_func_mmap_fixed_mapped" 1>&6
16684 if test $ac_cv_func_mmap_fixed_mapped = yes; then
16685   cat >> confdefs.h <<\EOF
16686 #define HAVE_MMAP 1
16687 EOF
16688
16689 fi
16690
16691 fi
16692
16693
16694
16695 if test "$CANADIAN" = yes; then
16696   CANADIAN_TRUE=
16697   CANADIAN_FALSE='#'
16698 else
16699   CANADIAN_TRUE='#'
16700   CANADIAN_FALSE=
16701 fi
16702
16703
16704 if test "$NULL_TARGET" = yes; then
16705   NULL_TARGET_TRUE=
16706   NULL_TARGET_FALSE='#'
16707 else
16708   NULL_TARGET_TRUE='#'
16709   NULL_TARGET_FALSE=
16710 fi
16711
16712
16713 if test "$NATIVE" = yes || test "$NULL_TARGET" = yes; then
16714   NATIVE_TRUE=
16715   NATIVE_FALSE='#'
16716 else
16717   NATIVE_TRUE='#'
16718   NATIVE_FALSE=
16719 fi
16720
16721
16722 if test -z "$with_cross_host"; then
16723   USE_LIBDIR_TRUE=
16724   USE_LIBDIR_FALSE='#'
16725 else
16726   USE_LIBDIR_TRUE='#'
16727   USE_LIBDIR_FALSE=
16728 fi
16729
16730 if test $ac_cv_header_locale_h = yes; then
16731     echo $ac_n "checking for LC_MESSAGES""... $ac_c" 1>&6
16732 echo "configure:16733: checking for LC_MESSAGES" >&5
16733 if eval "test \"`echo '$''{'ac_cv_val_LC_MESSAGES'+set}'`\" = set"; then
16734   echo $ac_n "(cached) $ac_c" 1>&6
16735 else
16736   cat > conftest.$ac_ext <<EOF
16737 #line 16738 "configure"
16738 #include "confdefs.h"
16739 #include <locale.h>
16740 int main() {
16741 return LC_MESSAGES
16742 ; return 0; }
16743 EOF
16744 if { (eval echo configure:16745: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16745   rm -rf conftest*
16746   ac_cv_val_LC_MESSAGES=yes
16747 else
16748   echo "configure: failed program was:" >&5
16749   cat conftest.$ac_ext >&5
16750   rm -rf conftest*
16751   ac_cv_val_LC_MESSAGES=no
16752 fi
16753 rm -f conftest*
16754 fi
16755
16756 echo "$ac_t""$ac_cv_val_LC_MESSAGES" 1>&6
16757     if test $ac_cv_val_LC_MESSAGES = yes; then
16758       cat >> confdefs.h <<\EOF
16759 #define HAVE_LC_MESSAGES 1
16760 EOF
16761
16762     fi
16763   fi
16764
16765
16766 # Sanity checking & User-visible messages.
16767 # Checks down here, otherwise they get scrolled off before
16768 # the user will notice.
16769 if test "$enable_namespaces" = "yes" && test "$enable_libgcc_rebuild" = "no"
16770 then
16771   echo "configure: warning: libgcc.a will not match mangled symbols unless it is rebuilt" 1>&2
16772 fi
16773 if test "$enable_namespaces" = "no" && test "$enable_libgcc_rebuild" != "no"
16774 then
16775   # Other things besides namespaces can make this true as well, but none
16776   # of them are done automatically... yet
16777   echo "configure: warning: no point in rebuilding libgcc.a if namespaces aren't used" 1>&2
16778 fi
16779
16780
16781 if test "${multilib}" = "yes"; then
16782   multilib_arg="--enable-multilib"
16783 else
16784   multilib_arg=
16785 fi
16786
16787
16788 # Generate the various Makefiles, include files, and scripts.
16789
16790 # NB: Multilibs need MULTISUBDIR defined correctly in src/Makefile.am
16791 # so that multilib installs will end up installed in the correct
16792 # place. To work around this not being passed down from config-ml.in
16793 # -> top_srcdir/Makefile.am -> top_srcdir/src/Makefile.am, manually
16794 # append it here.
16795
16796 trap '' 1 2 15
16797 cat > confcache <<\EOF
16798 # This file is a shell script that caches the results of configure
16799 # tests run on this system so they can be shared between configure
16800 # scripts and configure runs.  It is not useful on other systems.
16801 # If it contains results you don't want to keep, you may remove or edit it.
16802 #
16803 # By default, configure uses ./config.cache as the cache file,
16804 # creating it if it does not exist already.  You can give configure
16805 # the --cache-file=FILE option to use a different cache file; that is
16806 # what configure does when it calls configure scripts in
16807 # subdirectories, so they share the cache.
16808 # Giving --cache-file=/dev/null disables caching, for debugging configure.
16809 # config.status only pays attention to the cache file if you give it the
16810 # --recheck option to rerun configure.
16811 #
16812 EOF
16813 # The following way of writing the cache mishandles newlines in values,
16814 # but we know of no workaround that is simple, portable, and efficient.
16815 # So, don't put newlines in cache variables' values.
16816 # Ultrix sh set writes to stderr and can't be redirected directly,
16817 # and sets the high bit in the cache file unless we assign to the vars.
16818 (set) 2>&1 |
16819   case `(ac_space=' '; set | grep ac_space) 2>&1` in
16820   *ac_space=\ *)
16821     # `set' does not quote correctly, so add quotes (double-quote substitution
16822     # turns \\\\ into \\, and sed turns \\ into \).
16823     sed -n \
16824       -e "s/'/'\\\\''/g" \
16825       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
16826     ;;
16827   *)
16828     # `set' quotes correctly as required by POSIX, so do not add quotes.
16829     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
16830     ;;
16831   esac >> confcache
16832 if cmp -s $cache_file confcache; then
16833   :
16834 else
16835   if test -w $cache_file; then
16836     echo "updating cache $cache_file"
16837     cat confcache > $cache_file
16838   else
16839     echo "not updating unwritable cache $cache_file"
16840   fi
16841 fi
16842 rm -f confcache
16843
16844 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
16845
16846 test "x$prefix" = xNONE && prefix=$ac_default_prefix
16847 # Let make expand exec_prefix.
16848 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
16849
16850 # Any assignment to VPATH causes Sun make to only execute
16851 # the first set of double-colon rules, so remove it if not needed.
16852 # If there is a colon in the path, we need to keep it.
16853 if test "x$srcdir" = x.; then
16854   ac_vpsub='/^[         ]*VPATH[        ]*=[^:]*$/d'
16855 fi
16856
16857 trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15
16858
16859 DEFS=-DHAVE_CONFIG_H
16860
16861 # Without the "./", some shells look in PATH for config.status.
16862 : ${CONFIG_STATUS=./config.status}
16863
16864 echo creating $CONFIG_STATUS
16865 rm -f $CONFIG_STATUS
16866 cat > $CONFIG_STATUS <<EOF
16867 #! /bin/sh
16868 # Generated automatically by configure.
16869 # Run this file to recreate the current configuration.
16870 # This directory was configured as follows,
16871 # on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
16872 #
16873 # $0 $ac_configure_args
16874 #
16875 # Compiler output produced by configure, useful for debugging
16876 # configure, is in ./config.log if it exists.
16877
16878 ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]"
16879 for ac_option
16880 do
16881   case "\$ac_option" in
16882   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
16883     echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion"
16884     exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;;
16885   -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
16886     echo "$CONFIG_STATUS generated by autoconf version 2.13"
16887     exit 0 ;;
16888   -help | --help | --hel | --he | --h)
16889     echo "\$ac_cs_usage"; exit 0 ;;
16890   *) echo "\$ac_cs_usage"; exit 1 ;;
16891   esac
16892 done
16893
16894 ac_given_srcdir=$srcdir
16895 ac_given_INSTALL="$INSTALL"
16896
16897 trap 'rm -fr `echo "mkcheck Makefile src/Makefile math/Makefile libio/Makefile config.h" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15
16898 EOF
16899 cat >> $CONFIG_STATUS <<EOF
16900
16901 # Protect against being on the right side of a sed subst in config.status.
16902 sed 's/%@/@@/; s/@%/@@/; s/%g\$/@g/; /@g\$/s/[\\\\&%]/\\\\&/g;
16903  s/@@/%@/; s/@@/@%/; s/@g\$/%g/' > conftest.subs <<\\CEOF
16904 $ac_vpsub
16905 $extrasub
16906 s%@SHELL@%$SHELL%g
16907 s%@CFLAGS@%$CFLAGS%g
16908 s%@CPPFLAGS@%$CPPFLAGS%g
16909 s%@CXXFLAGS@%$CXXFLAGS%g
16910 s%@FFLAGS@%$FFLAGS%g
16911 s%@DEFS@%$DEFS%g
16912 s%@LDFLAGS@%$LDFLAGS%g
16913 s%@LIBS@%$LIBS%g
16914 s%@exec_prefix@%$exec_prefix%g
16915 s%@prefix@%$prefix%g
16916 s%@program_transform_name@%$program_transform_name%g
16917 s%@bindir@%$bindir%g
16918 s%@sbindir@%$sbindir%g
16919 s%@libexecdir@%$libexecdir%g
16920 s%@datadir@%$datadir%g
16921 s%@sysconfdir@%$sysconfdir%g
16922 s%@sharedstatedir@%$sharedstatedir%g
16923 s%@localstatedir@%$localstatedir%g
16924 s%@libdir@%$libdir%g
16925 s%@includedir@%$includedir%g
16926 s%@oldincludedir@%$oldincludedir%g
16927 s%@infodir@%$infodir%g
16928 s%@mandir@%$mandir%g
16929 s%@host@%$host%g
16930 s%@host_alias@%$host_alias%g
16931 s%@host_cpu@%$host_cpu%g
16932 s%@host_vendor@%$host_vendor%g
16933 s%@host_os@%$host_os%g
16934 s%@target@%$target%g
16935 s%@target_alias@%$target_alias%g
16936 s%@target_cpu@%$target_cpu%g
16937 s%@target_vendor@%$target_vendor%g
16938 s%@target_os@%$target_os%g
16939 s%@build@%$build%g
16940 s%@build_alias@%$build_alias%g
16941 s%@build_cpu@%$build_cpu%g
16942 s%@build_vendor@%$build_vendor%g
16943 s%@build_os@%$build_os%g
16944 s%@glibcpp_basedir@%$glibcpp_basedir%g
16945 s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
16946 s%@INSTALL_SCRIPT@%$INSTALL_SCRIPT%g
16947 s%@INSTALL_DATA@%$INSTALL_DATA%g
16948 s%@PACKAGE@%$PACKAGE%g
16949 s%@VERSION@%$VERSION%g
16950 s%@ACLOCAL@%$ACLOCAL%g
16951 s%@AUTOCONF@%$AUTOCONF%g
16952 s%@AUTOMAKE@%$AUTOMAKE%g
16953 s%@AUTOHEADER@%$AUTOHEADER%g
16954 s%@MAKEINFO@%$MAKEINFO%g
16955 s%@SET_MAKE@%$SET_MAKE%g
16956 s%@CC@%$CC%g
16957 s%@CXX@%$CXX%g
16958 s%@AS@%$AS%g
16959 s%@AR@%$AR%g
16960 s%@RANLIB@%$RANLIB%g
16961 s%@MAINTAINER_MODE_TRUE@%$MAINTAINER_MODE_TRUE%g
16962 s%@MAINTAINER_MODE_FALSE@%$MAINTAINER_MODE_FALSE%g
16963 s%@MAINT@%$MAINT%g
16964 s%@EXEEXT@%$EXEEXT%g
16965 s%@GLIBCPP_CFLAGS@%$GLIBCPP_CFLAGS%g
16966 s%@GLIBCPP_CXXFLAGS@%$GLIBCPP_CXXFLAGS%g
16967 s%@LN_S@%$LN_S%g
16968 s%@LIBTOOL@%$LIBTOOL%g
16969 s%@CPP@%$CPP%g
16970 s%@cpu_include_dir@%$cpu_include_dir%g
16971 s%@CPU_FLAGS@%$CPU_FLAGS%g
16972 s%@DEBUG_FLAGS@%$DEBUG_FLAGS%g
16973 s%@BUILD_LIBIO_INCLUDE@%$BUILD_LIBIO_INCLUDE%g
16974 s%@GLIBCPP_NEED_LIBIO_CONFIG_H_TRUE@%$GLIBCPP_NEED_LIBIO_CONFIG_H_TRUE%g
16975 s%@GLIBCPP_NEED_LIBIO_CONFIG_H_FALSE@%$GLIBCPP_NEED_LIBIO_CONFIG_H_FALSE%g
16976 s%@CSTDIO_H@%$CSTDIO_H%g
16977 s%@CSTDIO_CC@%$CSTDIO_CC%g
16978 s%@GLIBCPP_NEED_LIBIO_TRUE@%$GLIBCPP_NEED_LIBIO_TRUE%g
16979 s%@GLIBCPP_NEED_LIBIO_FALSE@%$GLIBCPP_NEED_LIBIO_FALSE%g
16980 s%@CSHADOWFLAGS@%$CSHADOWFLAGS%g
16981 s%@CSHADOW_INCLUDES@%$CSHADOW_INCLUDES%g
16982 s%@GLIBCPP_USE_CSHADOW_TRUE@%$GLIBCPP_USE_CSHADOW_TRUE%g
16983 s%@GLIBCPP_USE_CSHADOW_FALSE@%$GLIBCPP_USE_CSHADOW_FALSE%g
16984 s%@THREADLIBS@%$THREADLIBS%g
16985 s%@THREADINCS@%$THREADINCS%g
16986 s%@THREADDEPS@%$THREADDEPS%g
16987 s%@THREADOBJS@%$THREADOBJS%g
16988 s%@THREADSPEC@%$THREADSPEC%g
16989 s%@EXTRA_CXX_FLAGS@%$EXTRA_CXX_FLAGS%g
16990 s%@ctype_include_dir@%$ctype_include_dir%g
16991 s%@WERROR@%$WERROR%g
16992 s%@WFMT_FLAGS@%$WFMT_FLAGS%g
16993 s%@SECTION_FLAGS@%$SECTION_FLAGS%g
16994 s%@SECTION_LDFLAGS@%$SECTION_LDFLAGS%g
16995 s%@LIBMATHOBJS@%$LIBMATHOBJS%g
16996 s%@USE_COMPLEX_LONG_DOUBLE@%$USE_COMPLEX_LONG_DOUBLE%g
16997 s%@libinst_wstring_la@%$libinst_wstring_la%g
16998 s%@CANADIAN_TRUE@%$CANADIAN_TRUE%g
16999 s%@CANADIAN_FALSE@%$CANADIAN_FALSE%g
17000 s%@NULL_TARGET_TRUE@%$NULL_TARGET_TRUE%g
17001 s%@NULL_TARGET_FALSE@%$NULL_TARGET_FALSE%g
17002 s%@NATIVE_TRUE@%$NATIVE_TRUE%g
17003 s%@NATIVE_FALSE@%$NATIVE_FALSE%g
17004 s%@USE_LIBDIR_TRUE@%$USE_LIBDIR_TRUE%g
17005 s%@USE_LIBDIR_FALSE@%$USE_LIBDIR_FALSE%g
17006
17007 CEOF
17008 EOF
17009
17010 cat >> $CONFIG_STATUS <<\EOF
17011
17012 # Split the substitutions into bite-sized pieces for seds with
17013 # small command number limits, like on Digital OSF/1 and HP-UX.
17014 ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script.
17015 ac_file=1 # Number of current file.
17016 ac_beg=1 # First line for current file.
17017 ac_end=$ac_max_sed_cmds # Line after last line for current file.
17018 ac_more_lines=:
17019 ac_sed_cmds=""
17020 while $ac_more_lines; do
17021   if test $ac_beg -gt 1; then
17022     sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file
17023   else
17024     sed "${ac_end}q" conftest.subs > conftest.s$ac_file
17025   fi
17026   if test ! -s conftest.s$ac_file; then
17027     ac_more_lines=false
17028     rm -f conftest.s$ac_file
17029   else
17030     if test -z "$ac_sed_cmds"; then
17031       ac_sed_cmds="sed -f conftest.s$ac_file"
17032     else
17033       ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file"
17034     fi
17035     ac_file=`expr $ac_file + 1`
17036     ac_beg=$ac_end
17037     ac_end=`expr $ac_end + $ac_max_sed_cmds`
17038   fi
17039 done
17040 if test -z "$ac_sed_cmds"; then
17041   ac_sed_cmds=cat
17042 fi
17043 EOF
17044
17045 cat >> $CONFIG_STATUS <<EOF
17046
17047 CONFIG_FILES=\${CONFIG_FILES-"mkcheck Makefile src/Makefile math/Makefile libio/Makefile"}
17048 EOF
17049 cat >> $CONFIG_STATUS <<\EOF
17050 for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then
17051   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
17052   case "$ac_file" in
17053   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
17054        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
17055   *) ac_file_in="${ac_file}.in" ;;
17056   esac
17057
17058   # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories.
17059
17060   # Remove last slash and all that follows it.  Not all systems have dirname.
17061   ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
17062   if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
17063     # The file is in a subdirectory.
17064     test ! -d "$ac_dir" && mkdir "$ac_dir"
17065     ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`"
17066     # A "../" for each directory in $ac_dir_suffix.
17067     ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'`
17068   else
17069     ac_dir_suffix= ac_dots=
17070   fi
17071
17072   case "$ac_given_srcdir" in
17073   .)  srcdir=.
17074       if test -z "$ac_dots"; then top_srcdir=.
17075       else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;;
17076   /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;;
17077   *) # Relative path.
17078     srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix"
17079     top_srcdir="$ac_dots$ac_given_srcdir" ;;
17080   esac
17081
17082   case "$ac_given_INSTALL" in
17083   [/$]*) INSTALL="$ac_given_INSTALL" ;;
17084   *) INSTALL="$ac_dots$ac_given_INSTALL" ;;
17085   esac
17086
17087   echo creating "$ac_file"
17088   rm -f "$ac_file"
17089   configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure."
17090   case "$ac_file" in
17091   *Makefile*) ac_comsub="1i\\
17092 # $configure_input" ;;
17093   *) ac_comsub= ;;
17094   esac
17095
17096   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
17097   sed -e "$ac_comsub
17098 s%@configure_input@%$configure_input%g
17099 s%@srcdir@%$srcdir%g
17100 s%@top_srcdir@%$top_srcdir%g
17101 s%@INSTALL@%$INSTALL%g
17102 " $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file
17103 fi; done
17104 rm -f conftest.s*
17105
17106 # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
17107 # NAME is the cpp macro being defined and VALUE is the value it is being given.
17108 #
17109 # ac_d sets the value in "#define NAME VALUE" lines.
17110 ac_dA='s%^\([   ]*\)#\([        ]*define[       ][      ]*\)'
17111 ac_dB='\([      ][      ]*\)[^  ]*%\1#\2'
17112 ac_dC='\3'
17113 ac_dD='%g'
17114 # ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
17115 ac_uA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
17116 ac_uB='\([      ]\)%\1#\2define\3'
17117 ac_uC=' '
17118 ac_uD='\4%g'
17119 # ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
17120 ac_eA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
17121 ac_eB='$%\1#\2define\3'
17122 ac_eC=' '
17123 ac_eD='%g'
17124
17125 if test "${CONFIG_HEADERS+set}" != set; then
17126 EOF
17127 cat >> $CONFIG_STATUS <<EOF
17128   CONFIG_HEADERS="config.h"
17129 EOF
17130 cat >> $CONFIG_STATUS <<\EOF
17131 fi
17132 for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then
17133   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
17134   case "$ac_file" in
17135   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
17136        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
17137   *) ac_file_in="${ac_file}.in" ;;
17138   esac
17139
17140   echo creating $ac_file
17141
17142   rm -f conftest.frag conftest.in conftest.out
17143   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
17144   cat $ac_file_inputs > conftest.in
17145
17146 EOF
17147
17148 # Transform confdefs.h into a sed script conftest.vals that substitutes
17149 # the proper values into config.h.in to produce config.h.  And first:
17150 # Protect against being on the right side of a sed subst in config.status.
17151 # Protect against being in an unquoted here document in config.status.
17152 rm -f conftest.vals
17153 cat > conftest.hdr <<\EOF
17154 s/[\\&%]/\\&/g
17155 s%[\\$`]%\\&%g
17156 s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp
17157 s%ac_d%ac_u%gp
17158 s%ac_u%ac_e%gp
17159 EOF
17160 sed -n -f conftest.hdr confdefs.h > conftest.vals
17161 rm -f conftest.hdr
17162
17163 # This sed command replaces #undef with comments.  This is necessary, for
17164 # example, in the case of _POSIX_SOURCE, which is predefined and required
17165 # on some systems where configure will not decide to define it.
17166 cat >> conftest.vals <<\EOF
17167 s%^[    ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*%/* & */%
17168 EOF
17169
17170 # Break up conftest.vals because some shells have a limit on
17171 # the size of here documents, and old seds have small limits too.
17172
17173 rm -f conftest.tail
17174 while :
17175 do
17176   ac_lines=`grep -c . conftest.vals`
17177   # grep -c gives empty output for an empty file on some AIX systems.
17178   if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi
17179   # Write a limited-size here document to conftest.frag.
17180   echo '  cat > conftest.frag <<CEOF' >> $CONFIG_STATUS
17181   sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS
17182   echo 'CEOF
17183   sed -f conftest.frag conftest.in > conftest.out
17184   rm -f conftest.in
17185   mv conftest.out conftest.in
17186 ' >> $CONFIG_STATUS
17187   sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail
17188   rm -f conftest.vals
17189   mv conftest.tail conftest.vals
17190 done
17191 rm -f conftest.vals
17192
17193 cat >> $CONFIG_STATUS <<\EOF
17194   rm -f conftest.frag conftest.h
17195   echo "/* $ac_file.  Generated automatically by configure.  */" > conftest.h
17196   cat conftest.in >> conftest.h
17197   rm -f conftest.in
17198   if cmp -s $ac_file conftest.h 2>/dev/null; then
17199     echo "$ac_file is unchanged"
17200     rm -f conftest.h
17201   else
17202     # Remove last slash and all that follows it.  Not all systems have dirname.
17203       ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
17204       if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
17205       # The file is in a subdirectory.
17206       test ! -d "$ac_dir" && mkdir "$ac_dir"
17207     fi
17208     rm -f $ac_file
17209     mv conftest.h $ac_file
17210   fi
17211 fi; done
17212
17213 EOF
17214 cat >> $CONFIG_STATUS <<EOF
17215
17216 srcdir=${srcdir}
17217 host=${host}
17218 target=${target}
17219 with_multisubdir=${with_multisubdir}
17220 ac_configure_args="${multilib_arg} ${ac_configure_args}"
17221 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
17222 glibcpp_basedir=${glibcpp_basedir}
17223 CC="${CC}"
17224 CXX="${CXX}"
17225
17226 EOF
17227 cat >> $CONFIG_STATUS <<\EOF
17228 test -z "$CONFIG_HEADERS" || echo timestamp > stamp-h
17229 if test -n "$CONFIG_FILES"; then
17230   ac_file=Makefile . ${glibcpp_basedir}/../config-ml.in
17231   grep '^MULTISUBDIR =' Makefile >> src/Makefile
17232 fi
17233 exit 0
17234 EOF
17235 chmod +x $CONFIG_STATUS
17236 rm -fr confdefs* $ac_clean_files
17237 test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1
17238
17239
17240
17241 blddir=`pwd`
17242 # Generate mkcheck having execute privs
17243
17244
17245 # Generate bits/c++config.h
17246 # NB: This must be the first generated file as others include it. . .
17247
17248
17249 # Generate bits/std_limits.h and src/limitsMEMBERS.cc
17250
17251
17252 # Generate bits/c++threads.h
17253
17254
17255 # Generate bits/c++io.h and src/c++io.cc
17256
17257
17258 chmod +x $blddir/mkcheck
17259 $srcdir/mkc++config $blddir $srcdir
17260 $srcdir/mknumeric_limits $blddir $srcdir $xcompiling
17261 cp $srcdir/config/$THREADH $blddir/bits/c++threads.h
17262 cp $srcdir/config/$CSTDIO_H $blddir/bits/c++io.h
17263 cp $srcdir/config/$CSTDIO_CC $blddir/src/c++io.cc
17264
17265
17266
17267
17268
17269